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






namespace CosCompoundLifeCycle
{

class Operations;
typedef Operations *Operations_ptr;
typedef Operations_ptr OperationsRef;
typedef ObjVar< Operations > Operations_var;
typedef ObjOut< Operations > Operations_out;

class OperationsFactory;
typedef OperationsFactory *OperationsFactory_ptr;
typedef OperationsFactory_ptr OperationsFactoryRef;
typedef ObjVar< OperationsFactory > OperationsFactory_var;
typedef ObjOut< OperationsFactory > OperationsFactory_out;

class Node;
typedef Node *Node_ptr;
typedef Node_ptr NodeRef;
typedef ObjVar< Node > Node_var;
typedef ObjOut< Node > Node_out;

class Role;
typedef Role *Role_ptr;
typedef Role_ptr RoleRef;
typedef ObjVar< Role > Role_var;
typedef ObjOut< Role > Role_out;

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

class PropagationCriteriaFactory;
typedef PropagationCriteriaFactory *PropagationCriteriaFactory_ptr;
typedef PropagationCriteriaFactory_ptr PropagationCriteriaFactoryRef;
typedef ObjVar< PropagationCriteriaFactory > PropagationCriteriaFactory_var;
typedef ObjOut< PropagationCriteriaFactory > PropagationCriteriaFactory_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>



namespace CosCompoundLifeCycle
{


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

class OperationsFactory : 
  virtual public CORBA::Object
{
  public:
    virtual ~OperationsFactory();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef OperationsFactory_ptr _ptr_type;
    typedef OperationsFactory_var _var_type;
    #endif

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

    static OperationsFactory_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual Operations_ptr create_compound_operations() = 0;

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

extern CORBA::TypeCodeConst _tc_OperationsFactory;

// Stub for interface OperationsFactory
class OperationsFactory_stub:
  virtual public OperationsFactory
{
  public:
    virtual ~OperationsFactory_stub();
    Operations_ptr create_compound_operations();

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

#ifndef MICO_CONF_NO_POA

class OperationsFactory_stub_clp :
  virtual public OperationsFactory_stub,
  virtual public PortableServer::StubBase
{
  public:
    OperationsFactory_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~OperationsFactory_stub_clp ();
    Operations_ptr create_compound_operations();

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

#endif // MICO_CONF_NO_POA


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

class Operations : 
  virtual public CORBA::Object
{
  public:
    virtual ~Operations();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef Operations_ptr _ptr_type;
    typedef Operations_var _var_type;
    #endif

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

    static Operations_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual Node_ptr copy( Node_ptr starting_node, ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria ) = 0;
    virtual void move( Node_ptr starting_node, ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria ) = 0;
    virtual void remove( Node_ptr& starting_node ) = 0;
    virtual void destroy() = 0;

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

extern CORBA::TypeCodeConst _tc_Operations;

// Stub for interface Operations
class Operations_stub:
  virtual public Operations
{
  public:
    virtual ~Operations_stub();
    Node_ptr copy( Node_ptr starting_node, ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria );
    void move( Node_ptr starting_node, ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria );
    void remove( Node_ptr& starting_node );
    void destroy();

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

#ifndef MICO_CONF_NO_POA

class Operations_stub_clp :
  virtual public Operations_stub,
  virtual public PortableServer::StubBase
{
  public:
    Operations_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~Operations_stub_clp ();
    Node_ptr copy( Node_ptr starting_node, ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria );
    void move( Node_ptr starting_node, ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria );
    void remove( Node_ptr& starting_node );
    void destroy();

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

#endif // MICO_CONF_NO_POA


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

class Node : 
  virtual public ::CosGraphs::Node
{
  public:
    virtual ~Node();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef Node_ptr _ptr_type;
    typedef Node_var _var_type;
    #endif

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

    static Node_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    struct NotLifeCycleObject : public CORBA::UserException {
      #ifdef HAVE_EXPLICIT_STRUCT_OPS
      NotLifeCycleObject();
      ~NotLifeCycleObject();
      NotLifeCycleObject( const NotLifeCycleObject& s );
      NotLifeCycleObject& operator=( const NotLifeCycleObject& s );
      #endif //HAVE_EXPLICIT_STRUCT_OPS


      #ifdef HAVE_STD_EH
      NotLifeCycleObject *operator->() { return this; }
      NotLifeCycleObject& operator*() { return *this; }
      operator NotLifeCycleObject*() { return this; }
      #endif // HAVE_STD_EH

      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static NotLifeCycleObject *_downcast( CORBA::Exception *ex );
      static const NotLifeCycleObject *_downcast( const CORBA::Exception *ex );
    };

    #ifdef HAVE_STD_EH
    typedef NotLifeCycleObject NotLifeCycleObject_catch;
    #else
    typedef ExceptVar< NotLifeCycleObject > NotLifeCycleObject_var;
    typedef TVarOut< NotLifeCycleObject > NotLifeCycleObject_out;
    typedef NotLifeCycleObject_var NotLifeCycleObject_catch;
    #endif // HAVE_STD_EH

    static CORBA::TypeCodeConst _tc_NotLifeCycleObject;

    virtual void copy_node( ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria, Node_out new_node, ::CosGraphs::Node::Roles_out roles_of_new_node ) = 0;
    virtual void move_node( ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria ) = 0;
    virtual void remove_node() = 0;
    virtual ::CosLifeCycle::LifeCycleObject_ptr get_life_cycle_object() = 0;

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

extern CORBA::TypeCodeConst _tc_Node;

// Stub for interface Node
class Node_stub:
  virtual public Node,
  virtual public ::CosGraphs::Node_stub
{
  public:
    virtual ~Node_stub();
    void copy_node( ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria, Node_out new_node, ::CosGraphs::Node::Roles_out roles_of_new_node );
    void move_node( ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria );
    void remove_node();
    ::CosLifeCycle::LifeCycleObject_ptr get_life_cycle_object();

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

#ifndef MICO_CONF_NO_POA

class Node_stub_clp :
  virtual public Node_stub,
  virtual public ::CosGraphs::Node_stub_clp
{
  public:
    Node_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~Node_stub_clp ();
    void copy_node( ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria, Node_out new_node, ::CosGraphs::Node::Roles_out roles_of_new_node );
    void move_node( ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria );
    void remove_node();
    ::CosLifeCycle::LifeCycleObject_ptr get_life_cycle_object();

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

#endif // MICO_CONF_NO_POA

enum Operation {
  copy = 0,
  move,
  remove
};

typedef Operation& Operation_out;

extern CORBA::TypeCodeConst _tc_Operation;

struct RelationshipHandle;
typedef TVarVar< RelationshipHandle > RelationshipHandle_var;
typedef TVarOut< RelationshipHandle > RelationshipHandle_out;


struct RelationshipHandle {
  #ifdef HAVE_TYPEDEF_OVERLOAD
  typedef RelationshipHandle_var _var_type;
  #endif
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  RelationshipHandle();
  ~RelationshipHandle();
  RelationshipHandle( const RelationshipHandle& s );
  RelationshipHandle& operator=( const RelationshipHandle& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  Relationship_var the_relationship;
  ::CosObjectIdentity::ObjectIdentifier constant_random_id;
};

extern CORBA::TypeCodeConst _tc_RelationshipHandle;


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

class Role : 
  virtual public ::CosGraphs::Role
{
  public:
    virtual ~Role();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef Role_ptr _ptr_type;
    typedef Role_var _var_type;
    #endif

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

    static Role_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual Role_ptr copy_role( ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria ) = 0;
    virtual void move_role( ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria ) = 0;
    virtual ::CosGraphs::PropagationValue life_cycle_propagation( Operation op, const RelationshipHandle& rel, const char* to_role_name, CORBA::Boolean_out same_for_all ) = 0;

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

extern CORBA::TypeCodeConst _tc_Role;

// Stub for interface Role
class Role_stub:
  virtual public Role,
  virtual public ::CosGraphs::Role_stub
{
  public:
    virtual ~Role_stub();
    Role_ptr copy_role( ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria );
    void move_role( ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria );
    ::CosGraphs::PropagationValue life_cycle_propagation( Operation op, const RelationshipHandle& rel, const char* to_role_name, CORBA::Boolean_out same_for_all );

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

#ifndef MICO_CONF_NO_POA

class Role_stub_clp :
  virtual public Role_stub,
  virtual public ::CosGraphs::Role_stub_clp
{
  public:
    Role_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~Role_stub_clp ();
    Role_ptr copy_role( ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria );
    void move_role( ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria );
    ::CosGraphs::PropagationValue life_cycle_propagation( Operation op, const RelationshipHandle& rel, const char* to_role_name, CORBA::Boolean_out same_for_all );

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

#endif // MICO_CONF_NO_POA


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

class Relationship : 
  virtual public ::CosRelationships::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 );

    virtual Relationship_ptr copy_relationship( ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria, const ::CosGraphs::NamedRoles& new_roles ) = 0;
    virtual void move_relationship( ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria ) = 0;
    virtual ::CosGraphs::PropagationValue life_cycle_propagation( Operation op, const char* from_role_name, const char* to_role_name, CORBA::Boolean_out same_for_all ) = 0;

  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 ::CosRelationships::Relationship_stub
{
  public:
    virtual ~Relationship_stub();
    Relationship_ptr copy_relationship( ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria, const ::CosGraphs::NamedRoles& new_roles );
    void move_relationship( ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria );
    ::CosGraphs::PropagationValue life_cycle_propagation( Operation op, const char* from_role_name, const char* to_role_name, CORBA::Boolean_out same_for_all );

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

#ifndef MICO_CONF_NO_POA

class Relationship_stub_clp :
  virtual public Relationship_stub,
  virtual public ::CosRelationships::Relationship_stub_clp
{
  public:
    Relationship_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~Relationship_stub_clp ();
    Relationship_ptr copy_relationship( ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria, const ::CosGraphs::NamedRoles& new_roles );
    void move_relationship( ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria );
    ::CosGraphs::PropagationValue life_cycle_propagation( Operation op, const char* from_role_name, const char* to_role_name, CORBA::Boolean_out same_for_all );

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

#endif // MICO_CONF_NO_POA


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

class PropagationCriteriaFactory : 
  virtual public CORBA::Object
{
  public:
    virtual ~PropagationCriteriaFactory();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef PropagationCriteriaFactory_ptr _ptr_type;
    typedef PropagationCriteriaFactory_var _var_type;
    #endif

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

    static PropagationCriteriaFactory_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::CosGraphs::TraversalCriteria_ptr create( Operation op ) = 0;

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

extern CORBA::TypeCodeConst _tc_PropagationCriteriaFactory;

// Stub for interface PropagationCriteriaFactory
class PropagationCriteriaFactory_stub:
  virtual public PropagationCriteriaFactory
{
  public:
    virtual ~PropagationCriteriaFactory_stub();
    ::CosGraphs::TraversalCriteria_ptr create( Operation op );

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

#ifndef MICO_CONF_NO_POA

class PropagationCriteriaFactory_stub_clp :
  virtual public PropagationCriteriaFactory_stub,
  virtual public PortableServer::StubBase
{
  public:
    PropagationCriteriaFactory_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~PropagationCriteriaFactory_stub_clp ();
    ::CosGraphs::TraversalCriteria_ptr create( Operation op );

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

#endif // MICO_CONF_NO_POA

}


#ifndef MICO_CONF_NO_POA



namespace POA_CosCompoundLifeCycle
{

class OperationsFactory : virtual public PortableServer::StaticImplementation
{
  public:
    virtual ~OperationsFactory ();
    CosCompoundLifeCycle::OperationsFactory_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 OperationsFactory * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual ::CosCompoundLifeCycle::Operations_ptr create_compound_operations() = 0;

  protected:
    OperationsFactory () {};

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

class Operations : virtual public PortableServer::StaticImplementation
{
  public:
    virtual ~Operations ();
    CosCompoundLifeCycle::Operations_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 Operations * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual ::CosCompoundLifeCycle::Node_ptr copy( ::CosCompoundLifeCycle::Node_ptr starting_node, ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria ) = 0;
    virtual void move( ::CosCompoundLifeCycle::Node_ptr starting_node, ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria ) = 0;
    virtual void remove( ::CosCompoundLifeCycle::Node_ptr& starting_node ) = 0;
    virtual void destroy() = 0;

  protected:
    Operations () {};

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

class Node : 
  virtual public POA_CosGraphs::Node
{
  public:
    virtual ~Node ();
    CosCompoundLifeCycle::Node_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 Node * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual void copy_node( ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria, ::CosCompoundLifeCycle::Node_out new_node, ::CosGraphs::Node::Roles_out roles_of_new_node ) = 0;
    virtual void move_node( ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria ) = 0;
    virtual void remove_node() = 0;
    virtual ::CosLifeCycle::LifeCycleObject_ptr get_life_cycle_object() = 0;

  protected:
    Node () {};

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

class Role : 
  virtual public POA_CosGraphs::Role
{
  public:
    virtual ~Role ();
    CosCompoundLifeCycle::Role_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 Role * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual ::CosCompoundLifeCycle::Role_ptr copy_role( ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria ) = 0;
    virtual void move_role( ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria ) = 0;
    virtual ::CosGraphs::PropagationValue life_cycle_propagation( ::CosCompoundLifeCycle::Operation op, const ::CosCompoundLifeCycle::RelationshipHandle& rel, const char* to_role_name, CORBA::Boolean_out same_for_all ) = 0;

  protected:
    Role () {};

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

class Relationship : 
  virtual public POA_CosRelationships::Relationship
{
  public:
    virtual ~Relationship ();
    CosCompoundLifeCycle::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);

    virtual ::CosCompoundLifeCycle::Relationship_ptr copy_relationship( ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria, const ::CosGraphs::NamedRoles& new_roles ) = 0;
    virtual void move_relationship( ::CosLifeCycle::FactoryFinder_ptr there, const ::CosLifeCycle::Criteria& the_criteria ) = 0;
    virtual ::CosGraphs::PropagationValue life_cycle_propagation( ::CosCompoundLifeCycle::Operation op, const char* from_role_name, const char* to_role_name, CORBA::Boolean_out same_for_all ) = 0;

  protected:
    Relationship () {};

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

class PropagationCriteriaFactory : virtual public PortableServer::StaticImplementation
{
  public:
    virtual ~PropagationCriteriaFactory ();
    CosCompoundLifeCycle::PropagationCriteriaFactory_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 PropagationCriteriaFactory * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual ::CosGraphs::TraversalCriteria_ptr create( ::CosCompoundLifeCycle::Operation op ) = 0;

  protected:
    PropagationCriteriaFactory () {};

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

}


#endif // MICO_CONF_NO_POA

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

extern CORBA::StaticTypeInfo *_marshaller_CosCompoundLifeCycle_OperationsFactory;

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

extern CORBA::StaticTypeInfo *_marshaller_CosCompoundLifeCycle_Operations;

void operator<<=( CORBA::Any &a, const ::CosCompoundLifeCycle::Node::NotLifeCycleObject &e );
void operator<<=( CORBA::Any &a, ::CosCompoundLifeCycle::Node::NotLifeCycleObject *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosCompoundLifeCycle::Node::NotLifeCycleObject &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosCompoundLifeCycle::Node::NotLifeCycleObject *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosCompoundLifeCycle_Node_NotLifeCycleObject;

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

extern CORBA::StaticTypeInfo *_marshaller_CosCompoundLifeCycle_Node;

void operator<<=( CORBA::Any &a, const ::CosCompoundLifeCycle::Operation &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosCompoundLifeCycle::Operation &e );

extern CORBA::StaticTypeInfo *_marshaller_CosCompoundLifeCycle_Operation;

void operator<<=( CORBA::Any &_a, const ::CosCompoundLifeCycle::RelationshipHandle &_s );
void operator<<=( CORBA::Any &_a, ::CosCompoundLifeCycle::RelationshipHandle *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::CosCompoundLifeCycle::RelationshipHandle &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::CosCompoundLifeCycle::RelationshipHandle *&_s );

extern CORBA::StaticTypeInfo *_marshaller_CosCompoundLifeCycle_RelationshipHandle;

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

extern CORBA::StaticTypeInfo *_marshaller_CosCompoundLifeCycle_Role;

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

extern CORBA::StaticTypeInfo *_marshaller_CosCompoundLifeCycle_Relationship;

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

extern CORBA::StaticTypeInfo *_marshaller_CosCompoundLifeCycle_PropagationCriteriaFactory;

#endif
