/*
 *  MICO --- an Open Source CORBA implementation
 *  Copyright (c) 1997-2003 by The Mico Team
 *
 *  This file was automatically generated. DO NOT EDIT!
 */

#include <CORBA.h>
#include <mico/throw.h>

#ifndef __COSEXTERNALIZATIONCONTAINMENT_H__
#define __COSEXTERNALIZATIONCONTAINMENT_H__






namespace CosExternalizationContainment
{

class Relationship;
typedef Relationship *Relationship_ptr;
typedef Relationship_ptr RelationshipRef;
typedef ObjVar< Relationship > Relationship_var;
typedef ObjOut< Relationship > Relationship_out;

class ContainsRole;
typedef ContainsRole *ContainsRole_ptr;
typedef ContainsRole_ptr ContainsRoleRef;
typedef ObjVar< ContainsRole > ContainsRole_var;
typedef ObjOut< ContainsRole > ContainsRole_out;

class ContainedInRole;
typedef ContainedInRole *ContainedInRole_ptr;
typedef ContainedInRole_ptr ContainedInRoleRef;
typedef ObjVar< ContainedInRole > ContainedInRole_var;
typedef ObjOut< ContainedInRole > ContainedInRole_out;

}



#include <coss/CosObjectIdentity.h>
#include <mico/ir_base.h>
#include <mico/ir.h>
#include <coss/CosRelationships.h>
#include <coss/CosGraphs.h>
#include <coss/CosContainment.h>
#include <coss/CosNaming.h>
#include <coss/CosLifeCycle.h>
#include <coss/CosExternalization.h>



namespace CosExternalizationContainment
{


/*
 * Base class and common definitions for interface Relationship
 */

class Relationship : 
  virtual public ::CosCompoundExternalization::Relationship,
  virtual public ::CosContainment::Relationship
{
  public:
    virtual ~Relationship();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef Relationship_ptr _ptr_type;
    typedef Relationship_var _var_type;
    #endif

    static Relationship_ptr _narrow( CORBA::Object_ptr obj );
    static Relationship_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static Relationship_ptr _duplicate( Relationship_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static Relationship_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    Relationship() {};
  private:
    Relationship( const Relationship& );
    void operator=( const Relationship& );
};

extern CORBA::TypeCodeConst _tc_Relationship;

// Stub for interface Relationship
class Relationship_stub:
  virtual public Relationship,
  virtual public ::CosCompoundExternalization::Relationship_stub,
  virtual public ::CosContainment::Relationship_stub
{
  public:
    virtual ~Relationship_stub();
  private:
    void operator=( const Relationship_stub& );
};

#ifndef MICO_CONF_NO_POA

class Relationship_stub_clp :
  virtual public Relationship_stub,
  virtual public ::CosCompoundExternalization::Relationship_stub_clp,
  virtual public ::CosContainment::Relationship_stub_clp
{
  public:
    Relationship_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~Relationship_stub_clp ();
  protected:
    Relationship_stub_clp ();
  private:
    void operator=( const Relationship_stub_clp & );
};

#endif // MICO_CONF_NO_POA


/*
 * Base class and common definitions for interface ContainsRole
 */

class ContainsRole : 
  virtual public ::CosCompoundExternalization::Role,
  virtual public ::CosContainment::ContainsRole
{
  public:
    virtual ~ContainsRole();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef ContainsRole_ptr _ptr_type;
    typedef ContainsRole_var _var_type;
    #endif

    static ContainsRole_ptr _narrow( CORBA::Object_ptr obj );
    static ContainsRole_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static ContainsRole_ptr _duplicate( ContainsRole_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static ContainsRole_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    ContainsRole() {};
  private:
    ContainsRole( const ContainsRole& );
    void operator=( const ContainsRole& );
};

extern CORBA::TypeCodeConst _tc_ContainsRole;

// Stub for interface ContainsRole
class ContainsRole_stub:
  virtual public ContainsRole,
  virtual public ::CosCompoundExternalization::Role_stub,
  virtual public ::CosContainment::ContainsRole_stub
{
  public:
    virtual ~ContainsRole_stub();
  private:
    void operator=( const ContainsRole_stub& );
};

#ifndef MICO_CONF_NO_POA

class ContainsRole_stub_clp :
  virtual public ContainsRole_stub,
  virtual public ::CosCompoundExternalization::Role_stub_clp,
  virtual public ::CosContainment::ContainsRole_stub_clp
{
  public:
    ContainsRole_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~ContainsRole_stub_clp ();
  protected:
    ContainsRole_stub_clp ();
  private:
    void operator=( const ContainsRole_stub_clp & );
};

#endif // MICO_CONF_NO_POA


/*
 * Base class and common definitions for interface ContainedInRole
 */

class ContainedInRole : 
  virtual public ::CosCompoundExternalization::Role,
  virtual public ::CosContainment::ContainedInRole
{
  public:
    virtual ~ContainedInRole();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef ContainedInRole_ptr _ptr_type;
    typedef ContainedInRole_var _var_type;
    #endif

    static ContainedInRole_ptr _narrow( CORBA::Object_ptr obj );
    static ContainedInRole_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static ContainedInRole_ptr _duplicate( ContainedInRole_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static ContainedInRole_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    ContainedInRole() {};
  private:
    ContainedInRole( const ContainedInRole& );
    void operator=( const ContainedInRole& );
};

extern CORBA::TypeCodeConst _tc_ContainedInRole;

// Stub for interface ContainedInRole
class ContainedInRole_stub:
  virtual public ContainedInRole,
  virtual public ::CosCompoundExternalization::Role_stub,
  virtual public ::CosContainment::ContainedInRole_stub
{
  public:
    virtual ~ContainedInRole_stub();
  private:
    void operator=( const ContainedInRole_stub& );
};

#ifndef MICO_CONF_NO_POA

class ContainedInRole_stub_clp :
  virtual public ContainedInRole_stub,
  virtual public ::CosCompoundExternalization::Role_stub_clp,
  virtual public ::CosContainment::ContainedInRole_stub_clp
{
  public:
    ContainedInRole_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~ContainedInRole_stub_clp ();
  protected:
    ContainedInRole_stub_clp ();
  private:
    void operator=( const ContainedInRole_stub_clp & );
};

#endif // MICO_CONF_NO_POA

}


#ifndef MICO_CONF_NO_POA



namespace POA_CosExternalizationContainment
{

class Relationship : 
  virtual public POA_CosCompoundExternalization::Relationship,
  virtual public POA_CosContainment::Relationship
{
  public:
    virtual ~Relationship ();
    CosExternalizationContainment::Relationship_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static Relationship * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

  protected:
    Relationship () {};

  private:
    Relationship (const Relationship &);
    void operator= (const Relationship &);
};

class ContainsRole : 
  virtual public POA_CosCompoundExternalization::Role,
  virtual public POA_CosContainment::ContainsRole
{
  public:
    virtual ~ContainsRole ();
    CosExternalizationContainment::ContainsRole_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static ContainsRole * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

  protected:
    ContainsRole () {};

  private:
    ContainsRole (const ContainsRole &);
    void operator= (const ContainsRole &);
};

class ContainedInRole : 
  virtual public POA_CosCompoundExternalization::Role,
  virtual public POA_CosContainment::ContainedInRole
{
  public:
    virtual ~ContainedInRole ();
    CosExternalizationContainment::ContainedInRole_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static ContainedInRole * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

  protected:
    ContainedInRole () {};

  private:
    ContainedInRole (const ContainedInRole &);
    void operator= (const ContainedInRole &);
};

}


#endif // MICO_CONF_NO_POA

void operator<<=( CORBA::Any &a, const CosExternalizationContainment::Relationship_ptr obj );
void operator<<=( CORBA::Any &a, CosExternalizationContainment::Relationship_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CosExternalizationContainment::Relationship_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CosExternalizationContainment_Relationship;

void operator<<=( CORBA::Any &a, const CosExternalizationContainment::ContainsRole_ptr obj );
void operator<<=( CORBA::Any &a, CosExternalizationContainment::ContainsRole_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CosExternalizationContainment::ContainsRole_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CosExternalizationContainment_ContainsRole;

void operator<<=( CORBA::Any &a, const CosExternalizationContainment::ContainedInRole_ptr obj );
void operator<<=( CORBA::Any &a, CosExternalizationContainment::ContainedInRole_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CosExternalizationContainment::ContainedInRole_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CosExternalizationContainment_ContainedInRole;

#endif
