/*
 *  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 __COSLIFECYCLEREFERENCE_H__
#define __COSLIFECYCLEREFERENCE_H__






namespace CosLifeCycleReference
{

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

class ReferencesRole;
typedef ReferencesRole *ReferencesRole_ptr;
typedef ReferencesRole_ptr ReferencesRoleRef;
typedef ObjVar< ReferencesRole > ReferencesRole_var;
typedef ObjOut< ReferencesRole > ReferencesRole_out;

class ReferencedByRole;
typedef ReferencedByRole *ReferencedByRole_ptr;
typedef ReferencedByRole_ptr ReferencedByRoleRef;
typedef ObjVar< ReferencedByRole > ReferencedByRole_var;
typedef ObjOut< ReferencedByRole > ReferencedByRole_out;

}



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



namespace CosLifeCycleReference
{


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

class Relationship : 
  virtual public ::CosReference::Relationship,
  virtual public ::CosCompoundLifeCycle::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 ::CosReference::Relationship_stub,
  virtual public ::CosCompoundLifeCycle::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 ::CosReference::Relationship_stub_clp,
  virtual public ::CosCompoundLifeCycle::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 ReferencesRole
 */

class ReferencesRole : 
  virtual public ::CosReference::ReferencesRole,
  virtual public ::CosCompoundLifeCycle::Role
{
  public:
    virtual ~ReferencesRole();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef ReferencesRole_ptr _ptr_type;
    typedef ReferencesRole_var _var_type;
    #endif

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

    static ReferencesRole_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

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

extern CORBA::TypeCodeConst _tc_ReferencesRole;

// Stub for interface ReferencesRole
class ReferencesRole_stub:
  virtual public ReferencesRole,
  virtual public ::CosReference::ReferencesRole_stub,
  virtual public ::CosCompoundLifeCycle::Role_stub
{
  public:
    virtual ~ReferencesRole_stub();
  private:
    void operator=( const ReferencesRole_stub& );
};

#ifndef MICO_CONF_NO_POA

class ReferencesRole_stub_clp :
  virtual public ReferencesRole_stub,
  virtual public ::CosReference::ReferencesRole_stub_clp,
  virtual public ::CosCompoundLifeCycle::Role_stub_clp
{
  public:
    ReferencesRole_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~ReferencesRole_stub_clp ();
  protected:
    ReferencesRole_stub_clp ();
  private:
    void operator=( const ReferencesRole_stub_clp & );
};

#endif // MICO_CONF_NO_POA


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

class ReferencedByRole : 
  virtual public ::CosReference::ReferencedByRole,
  virtual public ::CosCompoundLifeCycle::Role
{
  public:
    virtual ~ReferencedByRole();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef ReferencedByRole_ptr _ptr_type;
    typedef ReferencedByRole_var _var_type;
    #endif

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

    static ReferencedByRole_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

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

extern CORBA::TypeCodeConst _tc_ReferencedByRole;

// Stub for interface ReferencedByRole
class ReferencedByRole_stub:
  virtual public ReferencedByRole,
  virtual public ::CosReference::ReferencedByRole_stub,
  virtual public ::CosCompoundLifeCycle::Role_stub
{
  public:
    virtual ~ReferencedByRole_stub();
  private:
    void operator=( const ReferencedByRole_stub& );
};

#ifndef MICO_CONF_NO_POA

class ReferencedByRole_stub_clp :
  virtual public ReferencedByRole_stub,
  virtual public ::CosReference::ReferencedByRole_stub_clp,
  virtual public ::CosCompoundLifeCycle::Role_stub_clp
{
  public:
    ReferencedByRole_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~ReferencedByRole_stub_clp ();
  protected:
    ReferencedByRole_stub_clp ();
  private:
    void operator=( const ReferencedByRole_stub_clp & );
};

#endif // MICO_CONF_NO_POA

}


#ifndef MICO_CONF_NO_POA



namespace POA_CosLifeCycleReference
{

class Relationship : 
  virtual public POA_CosReference::Relationship,
  virtual public POA_CosCompoundLifeCycle::Relationship
{
  public:
    virtual ~Relationship ();
    CosLifeCycleReference::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 ReferencesRole : 
  virtual public POA_CosReference::ReferencesRole,
  virtual public POA_CosCompoundLifeCycle::Role
{
  public:
    virtual ~ReferencesRole ();
    CosLifeCycleReference::ReferencesRole_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 ReferencesRole * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

  protected:
    ReferencesRole () {};

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

class ReferencedByRole : 
  virtual public POA_CosReference::ReferencedByRole,
  virtual public POA_CosCompoundLifeCycle::Role
{
  public:
    virtual ~ReferencedByRole ();
    CosLifeCycleReference::ReferencedByRole_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 ReferencedByRole * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

  protected:
    ReferencedByRole () {};

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

}


#endif // MICO_CONF_NO_POA

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

extern CORBA::StaticTypeInfo *_marshaller_CosLifeCycleReference_Relationship;

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

extern CORBA::StaticTypeInfo *_marshaller_CosLifeCycleReference_ReferencesRole;

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

extern CORBA::StaticTypeInfo *_marshaller_CosLifeCycleReference_ReferencedByRole;

#endif
