/* * MICO --- an Open Source CORBA implementation * Copyright (c) 1997-2001 by The Mico Team * * This file was automatically generated. DO NOT EDIT! */ #include #include #ifndef __HOME_H__ #define __HOME_H__ namespace Components { class Navigation; typedef Navigation *Navigation_ptr; typedef Navigation_ptr NavigationRef; typedef ObjVar< Navigation > Navigation_var; typedef ObjOut< Navigation > Navigation_out; class Receptacles; typedef Receptacles *Receptacles_ptr; typedef Receptacles_ptr ReceptaclesRef; typedef ObjVar< Receptacles > Receptacles_var; typedef ObjOut< Receptacles > Receptacles_out; class EventConsumerBase; typedef EventConsumerBase *EventConsumerBase_ptr; typedef EventConsumerBase_ptr EventConsumerBaseRef; typedef ObjVar< EventConsumerBase > EventConsumerBase_var; typedef ObjOut< EventConsumerBase > EventConsumerBase_out; class Events; typedef Events *Events_ptr; typedef Events_ptr EventsRef; typedef ObjVar< Events > Events_var; typedef ObjOut< Events > Events_out; class CCMObject; typedef CCMObject *CCMObject_ptr; typedef CCMObject_ptr CCMObjectRef; typedef ObjVar< CCMObject > CCMObject_var; typedef ObjOut< CCMObject > CCMObject_out; class CCMHome; typedef CCMHome *CCMHome_ptr; typedef CCMHome_ptr CCMHomeRef; typedef ObjVar< CCMHome > CCMHome_var; typedef ObjOut< CCMHome > CCMHome_out; class KeylessCCMHome; typedef KeylessCCMHome *KeylessCCMHome_ptr; typedef KeylessCCMHome_ptr KeylessCCMHomeRef; typedef ObjVar< KeylessCCMHome > KeylessCCMHome_var; typedef ObjOut< KeylessCCMHome > KeylessCCMHome_out; class HomeFinder; typedef HomeFinder *HomeFinder_ptr; typedef HomeFinder_ptr HomeFinderRef; typedef ObjVar< HomeFinder > HomeFinder_var; typedef ObjOut< HomeFinder > HomeFinder_out; class Configurator; typedef Configurator *Configurator_ptr; typedef Configurator_ptr ConfiguratorRef; typedef ObjVar< Configurator > Configurator_var; typedef ObjOut< Configurator > Configurator_out; class StandardConfigurator; typedef StandardConfigurator *StandardConfigurator_ptr; typedef StandardConfigurator_ptr StandardConfiguratorRef; typedef ObjVar< StandardConfigurator > StandardConfigurator_var; typedef ObjOut< StandardConfigurator > StandardConfigurator_out; class CCMContext; typedef CCMContext *CCMContext_ptr; typedef CCMContext_ptr CCMContextRef; typedef ObjVar< CCMContext > CCMContext_var; typedef ObjOut< CCMContext > CCMContext_out; class SessionContext; typedef SessionContext *SessionContext_ptr; typedef SessionContext_ptr SessionContextRef; typedef ObjVar< SessionContext > SessionContext_var; typedef ObjOut< SessionContext > SessionContext_out; class EnterpriseComponent; typedef EnterpriseComponent *EnterpriseComponent_ptr; typedef EnterpriseComponent_ptr EnterpriseComponentRef; typedef ObjVar< EnterpriseComponent > EnterpriseComponent_var; typedef ObjOut< EnterpriseComponent > EnterpriseComponent_out; class SessionComponent; typedef SessionComponent *SessionComponent_ptr; typedef SessionComponent_ptr SessionComponentRef; typedef ObjVar< SessionComponent > SessionComponent_var; typedef ObjOut< SessionComponent > SessionComponent_out; class HomeExecutorBase; typedef HomeExecutorBase *HomeExecutorBase_ptr; typedef HomeExecutorBase_ptr HomeExecutorBaseRef; typedef ObjVar< HomeExecutorBase > HomeExecutorBase_var; typedef ObjOut< HomeExecutorBase > HomeExecutorBase_out; class ExecutorLocator; typedef ExecutorLocator *ExecutorLocator_ptr; typedef ExecutorLocator_ptr ExecutorLocatorRef; typedef ObjVar< ExecutorLocator > ExecutorLocator_var; typedef ObjOut< ExecutorLocator > ExecutorLocator_out; class ComponentServer; typedef ComponentServer *ComponentServer_ptr; typedef ComponentServer_ptr ComponentServerRef; typedef ObjVar< ComponentServer > ComponentServer_var; typedef ObjOut< ComponentServer > ComponentServer_out; class Container; typedef Container *Container_ptr; typedef Container_ptr ContainerRef; typedef ObjVar< Container > Container_var; typedef ObjOut< Container > Container_out; class ServerActivator; typedef ServerActivator *ServerActivator_ptr; typedef ServerActivator_ptr ServerActivatorRef; typedef ObjVar< ServerActivator > ServerActivator_var; typedef ObjOut< ServerActivator > ServerActivator_out; class ComponentInstallation; typedef ComponentInstallation *ComponentInstallation_ptr; typedef ComponentInstallation_ptr ComponentInstallationRef; typedef ObjVar< ComponentInstallation > ComponentInstallation_var; typedef ObjOut< ComponentInstallation > ComponentInstallation_out; class Assembly; typedef Assembly *Assembly_ptr; typedef Assembly_ptr AssemblyRef; typedef ObjVar< Assembly > Assembly_var; typedef ObjOut< Assembly > Assembly_out; class AssemblyFactory; typedef AssemblyFactory *AssemblyFactory_ptr; typedef AssemblyFactory_ptr AssemblyFactoryRef; typedef ObjVar< AssemblyFactory > AssemblyFactory_var; typedef ObjOut< AssemblyFactory > AssemblyFactory_out; } namespace MICOCCM { class MicoCCMD; typedef MicoCCMD *MicoCCMD_ptr; typedef MicoCCMD_ptr MicoCCMDRef; typedef ObjVar< MicoCCMD > MicoCCMD_var; typedef ObjOut< MicoCCMD > MicoCCMD_out; class ComponentServer; typedef ComponentServer *ComponentServer_ptr; typedef ComponentServer_ptr ComponentServerRef; typedef ObjVar< ComponentServer > ComponentServer_var; typedef ObjOut< ComponentServer > ComponentServer_out; } namespace HPI { class HomeFinder; typedef HomeFinder *HomeFinder_ptr; typedef HomeFinder_ptr HomeFinderRef; typedef ObjVar< HomeFinder > HomeFinder_var; typedef ObjOut< HomeFinder > HomeFinder_out; } namespace Components { typedef char* FeatureName; typedef CORBA::String_var FeatureName_var; typedef CORBA::String_out FeatureName_out; typedef StringSequenceTmpl NameList; typedef TSeqVar< StringSequenceTmpl > NameList_var; typedef TSeqOut< StringSequenceTmpl > NameList_out; struct InvalidName : public CORBA::UserException { #ifdef HAVE_EXPLICIT_STRUCT_OPS InvalidName(); ~InvalidName(); InvalidName( const InvalidName& s ); InvalidName& operator=( const InvalidName& s ); #endif //HAVE_EXPLICIT_STRUCT_OPS #ifdef HAVE_STD_EH InvalidName *operator->() { return this; } InvalidName& operator*() { return *this; } operator InvalidName*() { 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 InvalidName *_downcast( CORBA::Exception *ex ); static const InvalidName *_downcast( const CORBA::Exception *ex ); }; #ifdef HAVE_STD_EH typedef InvalidName InvalidName_catch; #else typedef ExceptVar< InvalidName > InvalidName_var; typedef TVarOut< InvalidName > InvalidName_out; typedef InvalidName_var InvalidName_catch; #endif // HAVE_STD_EH struct InvalidConfiguration : public CORBA::UserException { #ifdef HAVE_EXPLICIT_STRUCT_OPS InvalidConfiguration(); ~InvalidConfiguration(); InvalidConfiguration( const InvalidConfiguration& s ); InvalidConfiguration& operator=( const InvalidConfiguration& s ); #endif //HAVE_EXPLICIT_STRUCT_OPS #ifdef HAVE_STD_EH InvalidConfiguration *operator->() { return this; } InvalidConfiguration& operator*() { return *this; } operator InvalidConfiguration*() { 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 InvalidConfiguration *_downcast( CORBA::Exception *ex ); static const InvalidConfiguration *_downcast( const CORBA::Exception *ex ); }; #ifdef HAVE_STD_EH typedef InvalidConfiguration InvalidConfiguration_catch; #else typedef ExceptVar< InvalidConfiguration > InvalidConfiguration_var; typedef TVarOut< InvalidConfiguration > InvalidConfiguration_out; typedef InvalidConfiguration_var InvalidConfiguration_catch; #endif // HAVE_STD_EH struct AlreadyConnected : public CORBA::UserException { #ifdef HAVE_EXPLICIT_STRUCT_OPS AlreadyConnected(); ~AlreadyConnected(); AlreadyConnected( const AlreadyConnected& s ); AlreadyConnected& operator=( const AlreadyConnected& s ); #endif //HAVE_EXPLICIT_STRUCT_OPS #ifdef HAVE_STD_EH AlreadyConnected *operator->() { return this; } AlreadyConnected& operator*() { return *this; } operator AlreadyConnected*() { 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 AlreadyConnected *_downcast( CORBA::Exception *ex ); static const AlreadyConnected *_downcast( const CORBA::Exception *ex ); }; #ifdef HAVE_STD_EH typedef AlreadyConnected AlreadyConnected_catch; #else typedef ExceptVar< AlreadyConnected > AlreadyConnected_var; typedef TVarOut< AlreadyConnected > AlreadyConnected_out; typedef AlreadyConnected_var AlreadyConnected_catch; #endif // HAVE_STD_EH struct InvalidConnection : public CORBA::UserException { #ifdef HAVE_EXPLICIT_STRUCT_OPS InvalidConnection(); ~InvalidConnection(); InvalidConnection( const InvalidConnection& s ); InvalidConnection& operator=( const InvalidConnection& s ); #endif //HAVE_EXPLICIT_STRUCT_OPS #ifdef HAVE_STD_EH InvalidConnection *operator->() { return this; } InvalidConnection& operator*() { return *this; } operator InvalidConnection*() { 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 InvalidConnection *_downcast( CORBA::Exception *ex ); static const InvalidConnection *_downcast( const CORBA::Exception *ex ); }; #ifdef HAVE_STD_EH typedef InvalidConnection InvalidConnection_catch; #else typedef ExceptVar< InvalidConnection > InvalidConnection_var; typedef TVarOut< InvalidConnection > InvalidConnection_out; typedef InvalidConnection_var InvalidConnection_catch; #endif // HAVE_STD_EH struct NoConnection : public CORBA::UserException { #ifdef HAVE_EXPLICIT_STRUCT_OPS NoConnection(); ~NoConnection(); NoConnection( const NoConnection& s ); NoConnection& operator=( const NoConnection& s ); #endif //HAVE_EXPLICIT_STRUCT_OPS #ifdef HAVE_STD_EH NoConnection *operator->() { return this; } NoConnection& operator*() { return *this; } operator NoConnection*() { 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 NoConnection *_downcast( CORBA::Exception *ex ); static const NoConnection *_downcast( const CORBA::Exception *ex ); }; #ifdef HAVE_STD_EH typedef NoConnection NoConnection_catch; #else typedef ExceptVar< NoConnection > NoConnection_var; typedef TVarOut< NoConnection > NoConnection_out; typedef NoConnection_var NoConnection_catch; #endif // HAVE_STD_EH struct ExceededConnectionLimit : public CORBA::UserException { #ifdef HAVE_EXPLICIT_STRUCT_OPS ExceededConnectionLimit(); ~ExceededConnectionLimit(); ExceededConnectionLimit( const ExceededConnectionLimit& s ); ExceededConnectionLimit& operator=( const ExceededConnectionLimit& s ); #endif //HAVE_EXPLICIT_STRUCT_OPS #ifdef HAVE_STD_EH ExceededConnectionLimit *operator->() { return this; } ExceededConnectionLimit& operator*() { return *this; } operator ExceededConnectionLimit*() { 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 ExceededConnectionLimit *_downcast( CORBA::Exception *ex ); static const ExceededConnectionLimit *_downcast( const CORBA::Exception *ex ); }; #ifdef HAVE_STD_EH typedef ExceededConnectionLimit ExceededConnectionLimit_catch; #else typedef ExceptVar< ExceededConnectionLimit > ExceededConnectionLimit_var; typedef TVarOut< ExceededConnectionLimit > ExceededConnectionLimit_out; typedef ExceededConnectionLimit_var ExceededConnectionLimit_catch; #endif // HAVE_STD_EH struct CookieRequired : public CORBA::UserException { #ifdef HAVE_EXPLICIT_STRUCT_OPS CookieRequired(); ~CookieRequired(); CookieRequired( const CookieRequired& s ); CookieRequired& operator=( const CookieRequired& s ); #endif //HAVE_EXPLICIT_STRUCT_OPS #ifdef HAVE_STD_EH CookieRequired *operator->() { return this; } CookieRequired& operator*() { return *this; } operator CookieRequired*() { 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 CookieRequired *_downcast( CORBA::Exception *ex ); static const CookieRequired *_downcast( const CORBA::Exception *ex ); }; #ifdef HAVE_STD_EH typedef CookieRequired CookieRequired_catch; #else typedef ExceptVar< CookieRequired > CookieRequired_var; typedef TVarOut< CookieRequired > CookieRequired_out; typedef CookieRequired_var CookieRequired_catch; #endif // HAVE_STD_EH class PortDescription; typedef PortDescription *PortDescription_ptr; typedef PortDescription_ptr PortDescriptionRef; typedef ValueVar< PortDescription > PortDescription_var; typedef ValueOut< PortDescription > PortDescription_out; // Common definitions for valuetype PortDescription class PortDescription : virtual public CORBA::ValueBase { public: static PortDescription* _downcast (CORBA::ValueBase *); static PortDescription* _downcast (CORBA::AbstractBase *); virtual void name( char *_p ) = 0; virtual void name( const char *_p ) = 0; virtual void name( const CORBA::String_var &_p ) = 0; virtual const char *name() const = 0; virtual void type_id( char *_p ) = 0; virtual void type_id( const char *_p ) = 0; virtual void type_id( const CORBA::String_var &_p ) = 0; virtual const char *type_id() const = 0; public: CORBA::ValueBase * _copy_value (); CORBA::ValueDef_ptr get_value_def (); virtual void * _narrow_helper (const char *); void _get_marshal_info (std::vector &, CORBA::Boolean &); void _marshal_members (CORBA::DataEncoder &); CORBA::Boolean _demarshal_members (CORBA::DataDecoder &); protected: PortDescription (); virtual ~PortDescription (); void _copy_members (const PortDescription&); private: PortDescription (const PortDescription &); void operator= (const PortDescription &); }; class Cookie; typedef Cookie *Cookie_ptr; typedef Cookie_ptr CookieRef; typedef ValueVar< Cookie > Cookie_var; typedef ValueOut< Cookie > Cookie_out; // Common definitions for valuetype Cookie class Cookie : virtual public CORBA::ValueBase { public: static Cookie* _downcast (CORBA::ValueBase *); static Cookie* _downcast (CORBA::AbstractBase *); typedef SequenceTmpl< CORBA::Octet,MICO_TID_OCTET> _CookieValue_seq; virtual void CookieValue( const _CookieValue_seq & _p) = 0; virtual const _CookieValue_seq & CookieValue() const = 0; virtual _CookieValue_seq & CookieValue() = 0; public: CORBA::ValueBase * _copy_value (); CORBA::ValueDef_ptr get_value_def (); virtual void * _narrow_helper (const char *); void _get_marshal_info (std::vector &, CORBA::Boolean &); void _marshal_members (CORBA::DataEncoder &); CORBA::Boolean _demarshal_members (CORBA::DataDecoder &); protected: Cookie (); virtual ~Cookie (); void _copy_members (const Cookie&); private: Cookie (const Cookie &); void operator= (const Cookie &); }; class EventBase; typedef EventBase *EventBase_ptr; typedef EventBase_ptr EventBaseRef; typedef ValueVar< EventBase > EventBase_var; typedef ValueOut< EventBase > EventBase_out; // Common definitions for valuetype EventBase class EventBase : virtual public CORBA::ValueBase { public: static EventBase* _downcast (CORBA::ValueBase *); static EventBase* _downcast (CORBA::AbstractBase *); public: CORBA::ValueDef_ptr get_value_def (); virtual void * _narrow_helper (const char *); void _get_marshal_info (std::vector &, CORBA::Boolean &); void _marshal_members (CORBA::DataEncoder &); CORBA::Boolean _demarshal_members (CORBA::DataDecoder &); protected: EventBase (); virtual ~EventBase (); private: EventBase (const EventBase &); void operator= (const EventBase &); }; class FacetDescription; typedef FacetDescription *FacetDescription_ptr; typedef FacetDescription_ptr FacetDescriptionRef; typedef ValueVar< FacetDescription > FacetDescription_var; typedef ValueOut< FacetDescription > FacetDescription_out; // Common definitions for valuetype FacetDescription class FacetDescription : virtual public ::Components::PortDescription { public: static FacetDescription* _downcast (CORBA::ValueBase *); static FacetDescription* _downcast (CORBA::AbstractBase *); virtual void facet_ref( CORBA::Object_ptr _p ) = 0; virtual CORBA::Object_ptr facet_ref() const = 0; public: CORBA::ValueBase * _copy_value (); CORBA::ValueDef_ptr get_value_def (); virtual void * _narrow_helper (const char *); void _get_marshal_info (std::vector &, CORBA::Boolean &); void _marshal_members (CORBA::DataEncoder &); CORBA::Boolean _demarshal_members (CORBA::DataDecoder &); protected: FacetDescription (); virtual ~FacetDescription (); void _copy_members (const FacetDescription&); private: FacetDescription (const FacetDescription &); void operator= (const FacetDescription &); }; typedef SequenceTmpl< FacetDescription_var,MICO_TID_DEF> FacetDescriptions; typedef TSeqVar< SequenceTmpl< FacetDescription_var,MICO_TID_DEF> > FacetDescriptions_var; typedef TSeqOut< SequenceTmpl< FacetDescription_var,MICO_TID_DEF> > FacetDescriptions_out; /* * Base class and common definitions for interface Navigation */ class Navigation : virtual public CORBA::Object { public: virtual ~Navigation(); #ifdef HAVE_TYPEDEF_OVERLOAD typedef Navigation_ptr _ptr_type; typedef Navigation_var _var_type; #endif static Navigation_ptr _narrow( CORBA::Object_ptr obj ); static Navigation_ptr _narrow( CORBA::AbstractBase_ptr obj ); static Navigation_ptr _duplicate( Navigation_ptr _obj ) { CORBA::Object::_duplicate (_obj); return _obj; } static Navigation_ptr _nil() { return 0; } virtual void *_narrow_helper( const char *repoid ); virtual CORBA::Object_ptr provide_facet( const char* name ) = 0; virtual FacetDescriptions* get_all_facets() = 0; virtual FacetDescriptions* get_named_facets( const NameList& names ) = 0; virtual CORBA::Boolean same_component( CORBA::Object_ptr ref ) = 0; protected: Navigation() {}; private: Navigation( const Navigation& ); void operator=( const Navigation& ); }; // Stub for interface Navigation class Navigation_stub: virtual public Navigation { public: virtual ~Navigation_stub(); CORBA::Object_ptr provide_facet( const char* name ); FacetDescriptions* get_all_facets(); FacetDescriptions* get_named_facets( const NameList& names ); CORBA::Boolean same_component( CORBA::Object_ptr ref ); private: void operator=( const Navigation_stub& ); }; #ifndef MICO_CONF_NO_POA class Navigation_stub_clp : virtual public Navigation_stub, virtual public PortableServer::StubBase { public: Navigation_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr); virtual ~Navigation_stub_clp (); CORBA::Object_ptr provide_facet( const char* name ); FacetDescriptions* get_all_facets(); FacetDescriptions* get_named_facets( const NameList& names ); CORBA::Boolean same_component( CORBA::Object_ptr ref ); protected: Navigation_stub_clp (); private: void operator=( const Navigation_stub_clp & ); }; #endif // MICO_CONF_NO_POA class ConnectionDescription; typedef ConnectionDescription *ConnectionDescription_ptr; typedef ConnectionDescription_ptr ConnectionDescriptionRef; typedef ValueVar< ConnectionDescription > ConnectionDescription_var; typedef ValueOut< ConnectionDescription > ConnectionDescription_out; // Common definitions for valuetype ConnectionDescription class ConnectionDescription : virtual public CORBA::ValueBase { public: static ConnectionDescription* _downcast (CORBA::ValueBase *); static ConnectionDescription* _downcast (CORBA::AbstractBase *); virtual void ck( Cookie* _p ) = 0; virtual Cookie* ck() const = 0; virtual void objref( CORBA::Object_ptr _p ) = 0; virtual CORBA::Object_ptr objref() const = 0; public: CORBA::ValueBase * _copy_value (); CORBA::ValueDef_ptr get_value_def (); virtual void * _narrow_helper (const char *); void _get_marshal_info (std::vector &, CORBA::Boolean &); void _marshal_members (CORBA::DataEncoder &); CORBA::Boolean _demarshal_members (CORBA::DataDecoder &); protected: ConnectionDescription (); virtual ~ConnectionDescription (); void _copy_members (const ConnectionDescription&); private: ConnectionDescription (const ConnectionDescription &); void operator= (const ConnectionDescription &); }; typedef SequenceTmpl< ConnectionDescription_var,MICO_TID_DEF> ConnectionDescriptions; typedef TSeqVar< SequenceTmpl< ConnectionDescription_var,MICO_TID_DEF> > ConnectionDescriptions_var; typedef TSeqOut< SequenceTmpl< ConnectionDescription_var,MICO_TID_DEF> > ConnectionDescriptions_out; class ReceptacleDescription; typedef ReceptacleDescription *ReceptacleDescription_ptr; typedef ReceptacleDescription_ptr ReceptacleDescriptionRef; typedef ValueVar< ReceptacleDescription > ReceptacleDescription_var; typedef ValueOut< ReceptacleDescription > ReceptacleDescription_out; // Common definitions for valuetype ReceptacleDescription class ReceptacleDescription : virtual public ::Components::PortDescription { public: static ReceptacleDescription* _downcast (CORBA::ValueBase *); static ReceptacleDescription* _downcast (CORBA::AbstractBase *); virtual void is_multiplex( CORBA::Boolean _p ) = 0; virtual CORBA::Boolean is_multiplex() const = 0; virtual void connections( const ConnectionDescriptions& _p ) = 0; virtual const ConnectionDescriptions& connections() const = 0; virtual ConnectionDescriptions& connections() = 0; public: CORBA::ValueBase * _copy_value (); CORBA::ValueDef_ptr get_value_def (); virtual void * _narrow_helper (const char *); void _get_marshal_info (std::vector &, CORBA::Boolean &); void _marshal_members (CORBA::DataEncoder &); CORBA::Boolean _demarshal_members (CORBA::DataDecoder &); protected: ReceptacleDescription (); virtual ~ReceptacleDescription (); void _copy_members (const ReceptacleDescription&); private: ReceptacleDescription (const ReceptacleDescription &); void operator= (const ReceptacleDescription &); }; typedef SequenceTmpl< ReceptacleDescription_var,MICO_TID_DEF> ReceptacleDescriptions; typedef TSeqVar< SequenceTmpl< ReceptacleDescription_var,MICO_TID_DEF> > ReceptacleDescriptions_var; typedef TSeqOut< SequenceTmpl< ReceptacleDescription_var,MICO_TID_DEF> > ReceptacleDescriptions_out; /* * Base class and common definitions for interface Receptacles */ class Receptacles : virtual public CORBA::Object { public: virtual ~Receptacles(); #ifdef HAVE_TYPEDEF_OVERLOAD typedef Receptacles_ptr _ptr_type; typedef Receptacles_var _var_type; #endif static Receptacles_ptr _narrow( CORBA::Object_ptr obj ); static Receptacles_ptr _narrow( CORBA::AbstractBase_ptr obj ); static Receptacles_ptr _duplicate( Receptacles_ptr _obj ) { CORBA::Object::_duplicate (_obj); return _obj; } static Receptacles_ptr _nil() { return 0; } virtual void *_narrow_helper( const char *repoid ); virtual Cookie* connect( const char* name, CORBA::Object_ptr connection ) = 0; virtual void disconnect( const char* name, Cookie* ck ) = 0; virtual ConnectionDescriptions* get_connections( const char* name ) = 0; virtual ReceptacleDescriptions* get_all_receptacles() = 0; virtual ReceptacleDescriptions* get_named_receptacles( const NameList& names ) = 0; protected: Receptacles() {}; private: Receptacles( const Receptacles& ); void operator=( const Receptacles& ); }; // Stub for interface Receptacles class Receptacles_stub: virtual public Receptacles { public: virtual ~Receptacles_stub(); Cookie* connect( const char* name, CORBA::Object_ptr connection ); void disconnect( const char* name, Cookie* ck ); ConnectionDescriptions* get_connections( const char* name ); ReceptacleDescriptions* get_all_receptacles(); ReceptacleDescriptions* get_named_receptacles( const NameList& names ); private: void operator=( const Receptacles_stub& ); }; #ifndef MICO_CONF_NO_POA class Receptacles_stub_clp : virtual public Receptacles_stub, virtual public PortableServer::StubBase { public: Receptacles_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr); virtual ~Receptacles_stub_clp (); Cookie* connect( const char* name, CORBA::Object_ptr connection ); void disconnect( const char* name, Cookie* ck ); ConnectionDescriptions* get_connections( const char* name ); ReceptacleDescriptions* get_all_receptacles(); ReceptacleDescriptions* get_named_receptacles( const NameList& names ); protected: Receptacles_stub_clp (); private: void operator=( const Receptacles_stub_clp & ); }; #endif // MICO_CONF_NO_POA struct BadEventType : public CORBA::UserException { #ifdef HAVE_EXPLICIT_STRUCT_OPS BadEventType(); ~BadEventType(); BadEventType( const BadEventType& s ); BadEventType& operator=( const BadEventType& s ); #endif //HAVE_EXPLICIT_STRUCT_OPS #ifndef HAVE_EXPLICIT_STRUCT_OPS BadEventType(); #endif //HAVE_EXPLICIT_STRUCT_OPS BadEventType( const char* _m0 ); #ifdef HAVE_STD_EH BadEventType *operator->() { return this; } BadEventType& operator*() { return *this; } operator BadEventType*() { 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 BadEventType *_downcast( CORBA::Exception *ex ); static const BadEventType *_downcast( const CORBA::Exception *ex ); CORBA::String_var expected_event_type; }; #ifdef HAVE_STD_EH typedef BadEventType BadEventType_catch; #else typedef ExceptVar< BadEventType > BadEventType_var; typedef TVarOut< BadEventType > BadEventType_out; typedef BadEventType_var BadEventType_catch; #endif // HAVE_STD_EH /* * Base class and common definitions for interface EventConsumerBase */ class EventConsumerBase : virtual public CORBA::Object { public: virtual ~EventConsumerBase(); #ifdef HAVE_TYPEDEF_OVERLOAD typedef EventConsumerBase_ptr _ptr_type; typedef EventConsumerBase_var _var_type; #endif static EventConsumerBase_ptr _narrow( CORBA::Object_ptr obj ); static EventConsumerBase_ptr _narrow( CORBA::AbstractBase_ptr obj ); static EventConsumerBase_ptr _duplicate( EventConsumerBase_ptr _obj ) { CORBA::Object::_duplicate (_obj); return _obj; } static EventConsumerBase_ptr _nil() { return 0; } virtual void *_narrow_helper( const char *repoid ); virtual void push_event( EventBase* evt ) = 0; protected: EventConsumerBase() {}; private: EventConsumerBase( const EventConsumerBase& ); void operator=( const EventConsumerBase& ); }; // Stub for interface EventConsumerBase class EventConsumerBase_stub: virtual public EventConsumerBase { public: virtual ~EventConsumerBase_stub(); void push_event( EventBase* evt ); private: void operator=( const EventConsumerBase_stub& ); }; #ifndef MICO_CONF_NO_POA class EventConsumerBase_stub_clp : virtual public EventConsumerBase_stub, virtual public PortableServer::StubBase { public: EventConsumerBase_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr); virtual ~EventConsumerBase_stub_clp (); void push_event( EventBase* evt ); protected: EventConsumerBase_stub_clp (); private: void operator=( const EventConsumerBase_stub_clp & ); }; #endif // MICO_CONF_NO_POA class ConsumerDescription; typedef ConsumerDescription *ConsumerDescription_ptr; typedef ConsumerDescription_ptr ConsumerDescriptionRef; typedef ValueVar< ConsumerDescription > ConsumerDescription_var; typedef ValueOut< ConsumerDescription > ConsumerDescription_out; // Common definitions for valuetype ConsumerDescription class ConsumerDescription : virtual public ::Components::PortDescription { public: static ConsumerDescription* _downcast (CORBA::ValueBase *); static ConsumerDescription* _downcast (CORBA::AbstractBase *); virtual void consumer( EventConsumerBase_ptr _p ) = 0; virtual EventConsumerBase_ptr consumer() const = 0; public: CORBA::ValueBase * _copy_value (); CORBA::ValueDef_ptr get_value_def (); virtual void * _narrow_helper (const char *); void _get_marshal_info (std::vector &, CORBA::Boolean &); void _marshal_members (CORBA::DataEncoder &); CORBA::Boolean _demarshal_members (CORBA::DataDecoder &); protected: ConsumerDescription (); virtual ~ConsumerDescription (); void _copy_members (const ConsumerDescription&); private: ConsumerDescription (const ConsumerDescription &); void operator= (const ConsumerDescription &); }; typedef SequenceTmpl< ConsumerDescription_var,MICO_TID_DEF> ConsumerDescriptions; typedef TSeqVar< SequenceTmpl< ConsumerDescription_var,MICO_TID_DEF> > ConsumerDescriptions_var; typedef TSeqOut< SequenceTmpl< ConsumerDescription_var,MICO_TID_DEF> > ConsumerDescriptions_out; class EmitterDescription; typedef EmitterDescription *EmitterDescription_ptr; typedef EmitterDescription_ptr EmitterDescriptionRef; typedef ValueVar< EmitterDescription > EmitterDescription_var; typedef ValueOut< EmitterDescription > EmitterDescription_out; // Common definitions for valuetype EmitterDescription class EmitterDescription : virtual public ::Components::PortDescription { public: static EmitterDescription* _downcast (CORBA::ValueBase *); static EmitterDescription* _downcast (CORBA::AbstractBase *); virtual void consumer( EventConsumerBase_ptr _p ) = 0; virtual EventConsumerBase_ptr consumer() const = 0; public: CORBA::ValueBase * _copy_value (); CORBA::ValueDef_ptr get_value_def (); virtual void * _narrow_helper (const char *); void _get_marshal_info (std::vector &, CORBA::Boolean &); void _marshal_members (CORBA::DataEncoder &); CORBA::Boolean _demarshal_members (CORBA::DataDecoder &); protected: EmitterDescription (); virtual ~EmitterDescription (); void _copy_members (const EmitterDescription&); private: EmitterDescription (const EmitterDescription &); void operator= (const EmitterDescription &); }; typedef SequenceTmpl< EmitterDescription_var,MICO_TID_DEF> EmitterDescriptions; typedef TSeqVar< SequenceTmpl< EmitterDescription_var,MICO_TID_DEF> > EmitterDescriptions_var; typedef TSeqOut< SequenceTmpl< EmitterDescription_var,MICO_TID_DEF> > EmitterDescriptions_out; class SubscriberDescription; typedef SubscriberDescription *SubscriberDescription_ptr; typedef SubscriberDescription_ptr SubscriberDescriptionRef; typedef ValueVar< SubscriberDescription > SubscriberDescription_var; typedef ValueOut< SubscriberDescription > SubscriberDescription_out; // Common definitions for valuetype SubscriberDescription class SubscriberDescription : virtual public CORBA::ValueBase { public: static SubscriberDescription* _downcast (CORBA::ValueBase *); static SubscriberDescription* _downcast (CORBA::AbstractBase *); virtual void ck( Cookie* _p ) = 0; virtual Cookie* ck() const = 0; virtual void consumer( EventConsumerBase_ptr _p ) = 0; virtual EventConsumerBase_ptr consumer() const = 0; public: CORBA::ValueBase * _copy_value (); CORBA::ValueDef_ptr get_value_def (); virtual void * _narrow_helper (const char *); void _get_marshal_info (std::vector &, CORBA::Boolean &); void _marshal_members (CORBA::DataEncoder &); CORBA::Boolean _demarshal_members (CORBA::DataDecoder &); protected: SubscriberDescription (); virtual ~SubscriberDescription (); void _copy_members (const SubscriberDescription&); private: SubscriberDescription (const SubscriberDescription &); void operator= (const SubscriberDescription &); }; typedef SequenceTmpl< SubscriberDescription_var,MICO_TID_DEF> SubscriberDescriptions; typedef TSeqVar< SequenceTmpl< SubscriberDescription_var,MICO_TID_DEF> > SubscriberDescriptions_var; typedef TSeqOut< SequenceTmpl< SubscriberDescription_var,MICO_TID_DEF> > SubscriberDescriptions_out; class PublisherDescription; typedef PublisherDescription *PublisherDescription_ptr; typedef PublisherDescription_ptr PublisherDescriptionRef; typedef ValueVar< PublisherDescription > PublisherDescription_var; typedef ValueOut< PublisherDescription > PublisherDescription_out; // Common definitions for valuetype PublisherDescription class PublisherDescription : virtual public ::Components::PortDescription { public: static PublisherDescription* _downcast (CORBA::ValueBase *); static PublisherDescription* _downcast (CORBA::AbstractBase *); virtual void consumers( const SubscriberDescriptions& _p ) = 0; virtual const SubscriberDescriptions& consumers() const = 0; virtual SubscriberDescriptions& consumers() = 0; public: CORBA::ValueBase * _copy_value (); CORBA::ValueDef_ptr get_value_def (); virtual void * _narrow_helper (const char *); void _get_marshal_info (std::vector &, CORBA::Boolean &); void _marshal_members (CORBA::DataEncoder &); CORBA::Boolean _demarshal_members (CORBA::DataDecoder &); protected: PublisherDescription (); virtual ~PublisherDescription (); void _copy_members (const PublisherDescription&); private: PublisherDescription (const PublisherDescription &); void operator= (const PublisherDescription &); }; typedef SequenceTmpl< PublisherDescription_var,MICO_TID_DEF> PublisherDescriptions; typedef TSeqVar< SequenceTmpl< PublisherDescription_var,MICO_TID_DEF> > PublisherDescriptions_var; typedef TSeqOut< SequenceTmpl< PublisherDescription_var,MICO_TID_DEF> > PublisherDescriptions_out; /* * Base class and common definitions for interface Events */ class Events : virtual public CORBA::Object { public: virtual ~Events(); #ifdef HAVE_TYPEDEF_OVERLOAD typedef Events_ptr _ptr_type; typedef Events_var _var_type; #endif static Events_ptr _narrow( CORBA::Object_ptr obj ); static Events_ptr _narrow( CORBA::AbstractBase_ptr obj ); static Events_ptr _duplicate( Events_ptr _obj ) { CORBA::Object::_duplicate (_obj); return _obj; } static Events_ptr _nil() { return 0; } virtual void *_narrow_helper( const char *repoid ); virtual EventConsumerBase_ptr get_consumer( const char* sink_name ) = 0; virtual ConsumerDescriptions* get_all_consumers() = 0; virtual ConsumerDescriptions* get_named_consumers( const NameList& names ) = 0; virtual Cookie* subscribe( const char* publisher_name, EventConsumerBase_ptr subscriber ) = 0; virtual void unsubscribe( const char* publisher_name, Cookie* ck ) = 0; virtual PublisherDescriptions* get_all_publishers() = 0; virtual PublisherDescriptions* get_named_publishers( const NameList& names ) = 0; virtual void connect_consumer( const char* emitter_name, EventConsumerBase_ptr consumer ) = 0; virtual EventConsumerBase_ptr disconnect_consumer( const char* source_name ) = 0; virtual EmitterDescriptions* get_all_emitters() = 0; virtual EmitterDescriptions* get_named_emitters( const NameList& names ) = 0; protected: Events() {}; private: Events( const Events& ); void operator=( const Events& ); }; // Stub for interface Events class Events_stub: virtual public Events { public: virtual ~Events_stub(); EventConsumerBase_ptr get_consumer( const char* sink_name ); ConsumerDescriptions* get_all_consumers(); ConsumerDescriptions* get_named_consumers( const NameList& names ); Cookie* subscribe( const char* publisher_name, EventConsumerBase_ptr subscriber ); void unsubscribe( const char* publisher_name, Cookie* ck ); PublisherDescriptions* get_all_publishers(); PublisherDescriptions* get_named_publishers( const NameList& names ); void connect_consumer( const char* emitter_name, EventConsumerBase_ptr consumer ); EventConsumerBase_ptr disconnect_consumer( const char* source_name ); EmitterDescriptions* get_all_emitters(); EmitterDescriptions* get_named_emitters( const NameList& names ); private: void operator=( const Events_stub& ); }; #ifndef MICO_CONF_NO_POA class Events_stub_clp : virtual public Events_stub, virtual public PortableServer::StubBase { public: Events_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr); virtual ~Events_stub_clp (); EventConsumerBase_ptr get_consumer( const char* sink_name ); ConsumerDescriptions* get_all_consumers(); ConsumerDescriptions* get_named_consumers( const NameList& names ); Cookie* subscribe( const char* publisher_name, EventConsumerBase_ptr subscriber ); void unsubscribe( const char* publisher_name, Cookie* ck ); PublisherDescriptions* get_all_publishers(); PublisherDescriptions* get_named_publishers( const NameList& names ); void connect_consumer( const char* emitter_name, EventConsumerBase_ptr consumer ); EventConsumerBase_ptr disconnect_consumer( const char* source_name ); EmitterDescriptions* get_all_emitters(); EmitterDescriptions* get_named_emitters( const NameList& names ); protected: Events_stub_clp (); private: void operator=( const Events_stub_clp & ); }; #endif // MICO_CONF_NO_POA /* * Base class and common definitions for interface CCMHome */ class CCMHome : virtual public CORBA::Object { public: virtual ~CCMHome(); #ifdef HAVE_TYPEDEF_OVERLOAD typedef CCMHome_ptr _ptr_type; typedef CCMHome_var _var_type; #endif static CCMHome_ptr _narrow( CORBA::Object_ptr obj ); static CCMHome_ptr _narrow( CORBA::AbstractBase_ptr obj ); static CCMHome_ptr _duplicate( CCMHome_ptr _obj ) { CORBA::Object::_duplicate (_obj); return _obj; } static CCMHome_ptr _nil() { return 0; } virtual void *_narrow_helper( const char *repoid ); virtual CORBA::Object_ptr get_component_def() = 0; virtual CORBA::Object_ptr get_home_def() = 0; virtual void remove_component( CCMObject_ptr comp ) = 0; protected: CCMHome() {}; private: CCMHome( const CCMHome& ); void operator=( const CCMHome& ); }; // Stub for interface CCMHome class CCMHome_stub: virtual public CCMHome { public: virtual ~CCMHome_stub(); CORBA::Object_ptr get_component_def(); CORBA::Object_ptr get_home_def(); void remove_component( CCMObject_ptr comp ); private: void operator=( const CCMHome_stub& ); }; #ifndef MICO_CONF_NO_POA class CCMHome_stub_clp : virtual public CCMHome_stub, virtual public PortableServer::StubBase { public: CCMHome_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr); virtual ~CCMHome_stub_clp (); CORBA::Object_ptr get_component_def(); CORBA::Object_ptr get_home_def(); void remove_component( CCMObject_ptr comp ); protected: CCMHome_stub_clp (); private: void operator=( const CCMHome_stub_clp & ); }; #endif // MICO_CONF_NO_POA class ComponentPortDescription; typedef ComponentPortDescription *ComponentPortDescription_ptr; typedef ComponentPortDescription_ptr ComponentPortDescriptionRef; typedef ValueVar< ComponentPortDescription > ComponentPortDescription_var; typedef ValueOut< ComponentPortDescription > ComponentPortDescription_out; // Common definitions for valuetype ComponentPortDescription class ComponentPortDescription : virtual public CORBA::ValueBase { public: static ComponentPortDescription* _downcast (CORBA::ValueBase *); static ComponentPortDescription* _downcast (CORBA::AbstractBase *); virtual void facets( const FacetDescriptions& _p ) = 0; virtual const FacetDescriptions& facets() const = 0; virtual FacetDescriptions& facets() = 0; virtual void receptacles( const ReceptacleDescriptions& _p ) = 0; virtual const ReceptacleDescriptions& receptacles() const = 0; virtual ReceptacleDescriptions& receptacles() = 0; virtual void consumers( const ConsumerDescriptions& _p ) = 0; virtual const ConsumerDescriptions& consumers() const = 0; virtual ConsumerDescriptions& consumers() = 0; virtual void emitters( const EmitterDescriptions& _p ) = 0; virtual const EmitterDescriptions& emitters() const = 0; virtual EmitterDescriptions& emitters() = 0; virtual void publishers( const PublisherDescriptions& _p ) = 0; virtual const PublisherDescriptions& publishers() const = 0; virtual PublisherDescriptions& publishers() = 0; public: CORBA::ValueBase * _copy_value (); CORBA::ValueDef_ptr get_value_def (); virtual void * _narrow_helper (const char *); void _get_marshal_info (std::vector &, CORBA::Boolean &); void _marshal_members (CORBA::DataEncoder &); CORBA::Boolean _demarshal_members (CORBA::DataDecoder &); protected: ComponentPortDescription (); virtual ~ComponentPortDescription (); void _copy_members (const ComponentPortDescription&); private: ComponentPortDescription (const ComponentPortDescription &); void operator= (const ComponentPortDescription &); }; /* * Base class and common definitions for interface CCMObject */ class CCMObject : virtual public ::Components::Navigation, virtual public ::Components::Receptacles, virtual public ::Components::Events { public: virtual ~CCMObject(); #ifdef HAVE_TYPEDEF_OVERLOAD typedef CCMObject_ptr _ptr_type; typedef CCMObject_var _var_type; #endif static CCMObject_ptr _narrow( CORBA::Object_ptr obj ); static CCMObject_ptr _narrow( CORBA::AbstractBase_ptr obj ); static CCMObject_ptr _duplicate( CCMObject_ptr _obj ) { CORBA::Object::_duplicate (_obj); return _obj; } static CCMObject_ptr _nil() { return 0; } virtual void *_narrow_helper( const char *repoid ); virtual CORBA::Object_ptr get_component_def() = 0; virtual CCMHome_ptr get_ccm_home() = 0; virtual void configuration_complete() = 0; virtual void remove() = 0; virtual ComponentPortDescription* get_all_ports() = 0; protected: CCMObject() {}; private: CCMObject( const CCMObject& ); void operator=( const CCMObject& ); }; // Stub for interface CCMObject class CCMObject_stub: virtual public CCMObject, virtual public ::Components::Navigation_stub, virtual public ::Components::Receptacles_stub, virtual public ::Components::Events_stub { public: virtual ~CCMObject_stub(); CORBA::Object_ptr get_component_def(); CCMHome_ptr get_ccm_home(); void configuration_complete(); void remove(); ComponentPortDescription* get_all_ports(); private: void operator=( const CCMObject_stub& ); }; #ifndef MICO_CONF_NO_POA class CCMObject_stub_clp : virtual public CCMObject_stub, virtual public ::Components::Navigation_stub_clp, virtual public ::Components::Receptacles_stub_clp, virtual public ::Components::Events_stub_clp { public: CCMObject_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr); virtual ~CCMObject_stub_clp (); CORBA::Object_ptr get_component_def(); CCMHome_ptr get_ccm_home(); void configuration_complete(); void remove(); ComponentPortDescription* get_all_ports(); protected: CCMObject_stub_clp (); private: void operator=( const CCMObject_stub_clp & ); }; #endif // MICO_CONF_NO_POA struct DuplicateKeyValue : public CORBA::UserException { #ifdef HAVE_EXPLICIT_STRUCT_OPS DuplicateKeyValue(); ~DuplicateKeyValue(); DuplicateKeyValue( const DuplicateKeyValue& s ); DuplicateKeyValue& operator=( const DuplicateKeyValue& s ); #endif //HAVE_EXPLICIT_STRUCT_OPS #ifdef HAVE_STD_EH DuplicateKeyValue *operator->() { return this; } DuplicateKeyValue& operator*() { return *this; } operator DuplicateKeyValue*() { 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 DuplicateKeyValue *_downcast( CORBA::Exception *ex ); static const DuplicateKeyValue *_downcast( const CORBA::Exception *ex ); }; #ifdef HAVE_STD_EH typedef DuplicateKeyValue DuplicateKeyValue_catch; #else typedef ExceptVar< DuplicateKeyValue > DuplicateKeyValue_var; typedef TVarOut< DuplicateKeyValue > DuplicateKeyValue_out; typedef DuplicateKeyValue_var DuplicateKeyValue_catch; #endif // HAVE_STD_EH struct UnknownKeyValue : public CORBA::UserException { #ifdef HAVE_EXPLICIT_STRUCT_OPS UnknownKeyValue(); ~UnknownKeyValue(); UnknownKeyValue( const UnknownKeyValue& s ); UnknownKeyValue& operator=( const UnknownKeyValue& s ); #endif //HAVE_EXPLICIT_STRUCT_OPS #ifdef HAVE_STD_EH UnknownKeyValue *operator->() { return this; } UnknownKeyValue& operator*() { return *this; } operator UnknownKeyValue*() { 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 UnknownKeyValue *_downcast( CORBA::Exception *ex ); static const UnknownKeyValue *_downcast( const CORBA::Exception *ex ); }; #ifdef HAVE_STD_EH typedef UnknownKeyValue UnknownKeyValue_catch; #else typedef ExceptVar< UnknownKeyValue > UnknownKeyValue_var; typedef TVarOut< UnknownKeyValue > UnknownKeyValue_out; typedef UnknownKeyValue_var UnknownKeyValue_catch; #endif // HAVE_STD_EH struct InvalidKey : public CORBA::UserException { #ifdef HAVE_EXPLICIT_STRUCT_OPS InvalidKey(); ~InvalidKey(); InvalidKey( const InvalidKey& s ); InvalidKey& operator=( const InvalidKey& s ); #endif //HAVE_EXPLICIT_STRUCT_OPS #ifdef HAVE_STD_EH InvalidKey *operator->() { return this; } InvalidKey& operator*() { return *this; } operator InvalidKey*() { 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 InvalidKey *_downcast( CORBA::Exception *ex ); static const InvalidKey *_downcast( const CORBA::Exception *ex ); }; #ifdef HAVE_STD_EH typedef InvalidKey InvalidKey_catch; #else typedef ExceptVar< InvalidKey > InvalidKey_var; typedef TVarOut< InvalidKey > InvalidKey_out; typedef InvalidKey_var InvalidKey_catch; #endif // HAVE_STD_EH typedef IfaceSequenceTmpl< CCMHome_var,CCMHome_ptr> CCMHomes; typedef TSeqVar< IfaceSequenceTmpl< CCMHome_var,CCMHome_ptr> > CCMHomes_var; typedef TSeqOut< IfaceSequenceTmpl< CCMHome_var,CCMHome_ptr> > CCMHomes_out; /* * Base class and common definitions for interface KeylessCCMHome */ class KeylessCCMHome : virtual public CORBA::Object { public: virtual ~KeylessCCMHome(); #ifdef HAVE_TYPEDEF_OVERLOAD typedef KeylessCCMHome_ptr _ptr_type; typedef KeylessCCMHome_var _var_type; #endif static KeylessCCMHome_ptr _narrow( CORBA::Object_ptr obj ); static KeylessCCMHome_ptr _narrow( CORBA::AbstractBase_ptr obj ); static KeylessCCMHome_ptr _duplicate( KeylessCCMHome_ptr _obj ) { CORBA::Object::_duplicate (_obj); return _obj; } static KeylessCCMHome_ptr _nil() { return 0; } virtual void *_narrow_helper( const char *repoid ); virtual CCMObject_ptr create_component() = 0; protected: KeylessCCMHome() {}; private: KeylessCCMHome( const KeylessCCMHome& ); void operator=( const KeylessCCMHome& ); }; // Stub for interface KeylessCCMHome class KeylessCCMHome_stub: virtual public KeylessCCMHome { public: virtual ~KeylessCCMHome_stub(); CCMObject_ptr create_component(); private: void operator=( const KeylessCCMHome_stub& ); }; #ifndef MICO_CONF_NO_POA class KeylessCCMHome_stub_clp : virtual public KeylessCCMHome_stub, virtual public PortableServer::StubBase { public: KeylessCCMHome_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr); virtual ~KeylessCCMHome_stub_clp (); CCMObject_ptr create_component(); protected: KeylessCCMHome_stub_clp (); private: void operator=( const KeylessCCMHome_stub_clp & ); }; #endif // MICO_CONF_NO_POA struct HomeNotFound : public CORBA::UserException { #ifdef HAVE_EXPLICIT_STRUCT_OPS HomeNotFound(); ~HomeNotFound(); HomeNotFound( const HomeNotFound& s ); HomeNotFound& operator=( const HomeNotFound& s ); #endif //HAVE_EXPLICIT_STRUCT_OPS #ifdef HAVE_STD_EH HomeNotFound *operator->() { return this; } HomeNotFound& operator*() { return *this; } operator HomeNotFound*() { 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 HomeNotFound *_downcast( CORBA::Exception *ex ); static const HomeNotFound *_downcast( const CORBA::Exception *ex ); }; #ifdef HAVE_STD_EH typedef HomeNotFound HomeNotFound_catch; #else typedef ExceptVar< HomeNotFound > HomeNotFound_var; typedef TVarOut< HomeNotFound > HomeNotFound_out; typedef HomeNotFound_var HomeNotFound_catch; #endif // HAVE_STD_EH /* * Base class and common definitions for interface HomeFinder */ class HomeFinder : virtual public CORBA::Object { public: virtual ~HomeFinder(); #ifdef HAVE_TYPEDEF_OVERLOAD typedef HomeFinder_ptr _ptr_type; typedef HomeFinder_var _var_type; #endif static HomeFinder_ptr _narrow( CORBA::Object_ptr obj ); static HomeFinder_ptr _narrow( CORBA::AbstractBase_ptr obj ); static HomeFinder_ptr _duplicate( HomeFinder_ptr _obj ) { CORBA::Object::_duplicate (_obj); return _obj; } static HomeFinder_ptr _nil() { return 0; } virtual void *_narrow_helper( const char *repoid ); virtual CCMHome_ptr find_home_by_component_type( const char* comp_repid ) = 0; virtual CCMHome_ptr find_home_by_home_type( const char* home_repid ) = 0; virtual CCMHome_ptr find_home_by_name( const char* home_name ) = 0; protected: HomeFinder() {}; private: HomeFinder( const HomeFinder& ); void operator=( const HomeFinder& ); }; // Stub for interface HomeFinder class HomeFinder_stub: virtual public HomeFinder { public: virtual ~HomeFinder_stub(); CCMHome_ptr find_home_by_component_type( const char* comp_repid ); CCMHome_ptr find_home_by_home_type( const char* home_repid ); CCMHome_ptr find_home_by_name( const char* home_name ); private: void operator=( const HomeFinder_stub& ); }; #ifndef MICO_CONF_NO_POA class HomeFinder_stub_clp : virtual public HomeFinder_stub, virtual public PortableServer::StubBase { public: HomeFinder_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr); virtual ~HomeFinder_stub_clp (); CCMHome_ptr find_home_by_component_type( const char* comp_repid ); CCMHome_ptr find_home_by_home_type( const char* home_repid ); CCMHome_ptr find_home_by_name( const char* home_name ); protected: HomeFinder_stub_clp (); private: void operator=( const HomeFinder_stub_clp & ); }; #endif // MICO_CONF_NO_POA struct WrongComponentType : public CORBA::UserException { #ifdef HAVE_EXPLICIT_STRUCT_OPS WrongComponentType(); ~WrongComponentType(); WrongComponentType( const WrongComponentType& s ); WrongComponentType& operator=( const WrongComponentType& s ); #endif //HAVE_EXPLICIT_STRUCT_OPS #ifdef HAVE_STD_EH WrongComponentType *operator->() { return this; } WrongComponentType& operator*() { return *this; } operator WrongComponentType*() { 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 WrongComponentType *_downcast( CORBA::Exception *ex ); static const WrongComponentType *_downcast( const CORBA::Exception *ex ); }; #ifdef HAVE_STD_EH typedef WrongComponentType WrongComponentType_catch; #else typedef ExceptVar< WrongComponentType > WrongComponentType_var; typedef TVarOut< WrongComponentType > WrongComponentType_out; typedef WrongComponentType_var WrongComponentType_catch; #endif // HAVE_STD_EH /* * Base class and common definitions for interface Configurator */ class Configurator : virtual public CORBA::Object { public: virtual ~Configurator(); #ifdef HAVE_TYPEDEF_OVERLOAD typedef Configurator_ptr _ptr_type; typedef Configurator_var _var_type; #endif static Configurator_ptr _narrow( CORBA::Object_ptr obj ); static Configurator_ptr _narrow( CORBA::AbstractBase_ptr obj ); static Configurator_ptr _duplicate( Configurator_ptr _obj ) { CORBA::Object::_duplicate (_obj); return _obj; } static Configurator_ptr _nil() { return 0; } virtual void *_narrow_helper( const char *repoid ); virtual void configure( CCMObject_ptr comp ) = 0; protected: Configurator() {}; private: Configurator( const Configurator& ); void operator=( const Configurator& ); }; // Stub for interface Configurator class Configurator_stub: virtual public Configurator { public: virtual ~Configurator_stub(); void configure( CCMObject_ptr comp ); private: void operator=( const Configurator_stub& ); }; #ifndef MICO_CONF_NO_POA class Configurator_stub_clp : virtual public Configurator_stub, virtual public PortableServer::StubBase { public: Configurator_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr); virtual ~Configurator_stub_clp (); void configure( CCMObject_ptr comp ); protected: Configurator_stub_clp (); private: void operator=( const Configurator_stub_clp & ); }; #endif // MICO_CONF_NO_POA class ConfigValue; typedef ConfigValue *ConfigValue_ptr; typedef ConfigValue_ptr ConfigValueRef; typedef ValueVar< ConfigValue > ConfigValue_var; typedef ValueOut< ConfigValue > ConfigValue_out; // Common definitions for valuetype ConfigValue class ConfigValue : virtual public CORBA::ValueBase { public: static ConfigValue* _downcast (CORBA::ValueBase *); static ConfigValue* _downcast (CORBA::AbstractBase *); virtual void name( char *_p ) = 0; virtual void name( const char *_p ) = 0; virtual void name( const CORBA::String_var &_p ) = 0; virtual const char *name() const = 0; virtual void value( const CORBA::Any& _p ) = 0; virtual const CORBA::Any& value() const = 0; virtual CORBA::Any& value() = 0; public: CORBA::ValueBase * _copy_value (); CORBA::ValueDef_ptr get_value_def (); virtual void * _narrow_helper (const char *); void _get_marshal_info (std::vector &, CORBA::Boolean &); void _marshal_members (CORBA::DataEncoder &); CORBA::Boolean _demarshal_members (CORBA::DataDecoder &); protected: ConfigValue (); virtual ~ConfigValue (); void _copy_members (const ConfigValue&); private: ConfigValue (const ConfigValue &); void operator= (const ConfigValue &); }; typedef SequenceTmpl< ConfigValue_var,MICO_TID_DEF> ConfigValues; typedef TSeqVar< SequenceTmpl< ConfigValue_var,MICO_TID_DEF> > ConfigValues_var; typedef TSeqOut< SequenceTmpl< ConfigValue_var,MICO_TID_DEF> > ConfigValues_out; /* * Base class and common definitions for interface StandardConfigurator */ class StandardConfigurator : virtual public ::Components::Configurator { public: virtual ~StandardConfigurator(); #ifdef HAVE_TYPEDEF_OVERLOAD typedef StandardConfigurator_ptr _ptr_type; typedef StandardConfigurator_var _var_type; #endif static StandardConfigurator_ptr _narrow( CORBA::Object_ptr obj ); static StandardConfigurator_ptr _narrow( CORBA::AbstractBase_ptr obj ); static StandardConfigurator_ptr _duplicate( StandardConfigurator_ptr _obj ) { CORBA::Object::_duplicate (_obj); return _obj; } static StandardConfigurator_ptr _nil() { return 0; } virtual void *_narrow_helper( const char *repoid ); virtual void set_configuration( const ConfigValues& descr ) = 0; protected: StandardConfigurator() {}; private: StandardConfigurator( const StandardConfigurator& ); void operator=( const StandardConfigurator& ); }; // Stub for interface StandardConfigurator class StandardConfigurator_stub: virtual public StandardConfigurator, virtual public ::Components::Configurator_stub { public: virtual ~StandardConfigurator_stub(); void set_configuration( const ConfigValues& descr ); private: void operator=( const StandardConfigurator_stub& ); }; #ifndef MICO_CONF_NO_POA class StandardConfigurator_stub_clp : virtual public StandardConfigurator_stub, virtual public ::Components::Configurator_stub_clp { public: StandardConfigurator_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr); virtual ~StandardConfigurator_stub_clp (); void set_configuration( const ConfigValues& descr ); protected: StandardConfigurator_stub_clp (); private: void operator=( const StandardConfigurator_stub_clp & ); }; #endif // MICO_CONF_NO_POA struct IllegalState : public CORBA::UserException { #ifdef HAVE_EXPLICIT_STRUCT_OPS IllegalState(); ~IllegalState(); IllegalState( const IllegalState& s ); IllegalState& operator=( const IllegalState& s ); #endif //HAVE_EXPLICIT_STRUCT_OPS #ifdef HAVE_STD_EH IllegalState *operator->() { return this; } IllegalState& operator*() { return *this; } operator IllegalState*() { 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 IllegalState *_downcast( CORBA::Exception *ex ); static const IllegalState *_downcast( const CORBA::Exception *ex ); }; #ifdef HAVE_STD_EH typedef IllegalState IllegalState_catch; #else typedef ExceptVar< IllegalState > IllegalState_var; typedef TVarOut< IllegalState > IllegalState_out; typedef IllegalState_var IllegalState_catch; #endif // HAVE_STD_EH /* * Base class and common definitions for local interface CCMContext */ class CCMContext : virtual public CORBA::LocalObject { public: virtual ~CCMContext(); #ifdef HAVE_TYPEDEF_OVERLOAD typedef CCMContext_ptr _ptr_type; typedef CCMContext_var _var_type; #endif static CCMContext_ptr _narrow( CORBA::Object_ptr obj ); static CCMContext_ptr _narrow( CORBA::AbstractBase_ptr obj ); static CCMContext_ptr _duplicate( CCMContext_ptr _obj ) { CORBA::Object::_duplicate (_obj); return _obj; } static CCMContext_ptr _nil() { return 0; } virtual void *_narrow_helper( const char *repoid ); virtual CCMHome_ptr get_CCM_home() = 0; protected: CCMContext() {}; private: CCMContext( const CCMContext& ); void operator=( const CCMContext& ); }; /* * Base class and common definitions for local interface SessionContext */ class SessionContext : virtual public ::Components::CCMContext { public: virtual ~SessionContext(); #ifdef HAVE_TYPEDEF_OVERLOAD typedef SessionContext_ptr _ptr_type; typedef SessionContext_var _var_type; #endif static SessionContext_ptr _narrow( CORBA::Object_ptr obj ); static SessionContext_ptr _narrow( CORBA::AbstractBase_ptr obj ); static SessionContext_ptr _duplicate( SessionContext_ptr _obj ) { CORBA::Object::_duplicate (_obj); return _obj; } static SessionContext_ptr _nil() { return 0; } virtual void *_narrow_helper( const char *repoid ); virtual CORBA::Object_ptr get_CCM_object() = 0; protected: SessionContext() {}; private: SessionContext( const SessionContext& ); void operator=( const SessionContext& ); }; enum CCMExceptionReason { SYSTEM_ERROR = 0, CREATE_ERROR, REMOVE_ERROR, DUPLICATE_KEY, FIND_ERROR, OBJECT_NOT_FOUND, NO_SUCH_ENTITY }; typedef CCMExceptionReason& CCMExceptionReason_out; struct CCMException : public CORBA::UserException { #ifdef HAVE_EXPLICIT_STRUCT_OPS CCMException(); ~CCMException(); CCMException( const CCMException& s ); CCMException& operator=( const CCMException& s ); #endif //HAVE_EXPLICIT_STRUCT_OPS #ifndef HAVE_EXPLICIT_STRUCT_OPS CCMException(); #endif //HAVE_EXPLICIT_STRUCT_OPS CCMException( ::Components::CCMExceptionReason _m0 ); #ifdef HAVE_STD_EH CCMException *operator->() { return this; } CCMException& operator*() { return *this; } operator CCMException*() { 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 CCMException *_downcast( CORBA::Exception *ex ); static const CCMException *_downcast( const CORBA::Exception *ex ); CCMExceptionReason reason; }; #ifdef HAVE_STD_EH typedef CCMException CCMException_catch; #else typedef ExceptVar< CCMException > CCMException_var; typedef TVarOut< CCMException > CCMException_out; typedef CCMException_var CCMException_catch; #endif // HAVE_STD_EH /* * Base class and common definitions for local interface EnterpriseComponent */ class EnterpriseComponent : virtual public CORBA::LocalObject { public: virtual ~EnterpriseComponent(); #ifdef HAVE_TYPEDEF_OVERLOAD typedef EnterpriseComponent_ptr _ptr_type; typedef EnterpriseComponent_var _var_type; #endif static EnterpriseComponent_ptr _narrow( CORBA::Object_ptr obj ); static EnterpriseComponent_ptr _narrow( CORBA::AbstractBase_ptr obj ); static EnterpriseComponent_ptr _duplicate( EnterpriseComponent_ptr _obj ) { CORBA::Object::_duplicate (_obj); return _obj; } static EnterpriseComponent_ptr _nil() { return 0; } virtual void *_narrow_helper( const char *repoid ); protected: EnterpriseComponent() {}; private: EnterpriseComponent( const EnterpriseComponent& ); void operator=( const EnterpriseComponent& ); }; /* * Base class and common definitions for local interface SessionComponent */ class SessionComponent : virtual public ::Components::EnterpriseComponent { public: virtual ~SessionComponent(); #ifdef HAVE_TYPEDEF_OVERLOAD typedef SessionComponent_ptr _ptr_type; typedef SessionComponent_var _var_type; #endif static SessionComponent_ptr _narrow( CORBA::Object_ptr obj ); static SessionComponent_ptr _narrow( CORBA::AbstractBase_ptr obj ); static SessionComponent_ptr _duplicate( SessionComponent_ptr _obj ) { CORBA::Object::_duplicate (_obj); return _obj; } static SessionComponent_ptr _nil() { return 0; } virtual void *_narrow_helper( const char *repoid ); virtual void set_session_context( SessionContext_ptr ctx ) = 0; virtual void ccm_activate() = 0; virtual void ccm_passivate() = 0; virtual void ccm_remove() = 0; protected: SessionComponent() {}; private: SessionComponent( const SessionComponent& ); void operator=( const SessionComponent& ); }; /* * Base class and common definitions for local interface HomeExecutorBase */ class HomeExecutorBase : virtual public CORBA::LocalObject { public: virtual ~HomeExecutorBase(); #ifdef HAVE_TYPEDEF_OVERLOAD typedef HomeExecutorBase_ptr _ptr_type; typedef HomeExecutorBase_var _var_type; #endif static HomeExecutorBase_ptr _narrow( CORBA::Object_ptr obj ); static HomeExecutorBase_ptr _narrow( CORBA::AbstractBase_ptr obj ); static HomeExecutorBase_ptr _duplicate( HomeExecutorBase_ptr _obj ) { CORBA::Object::_duplicate (_obj); return _obj; } static HomeExecutorBase_ptr _nil() { return 0; } virtual void *_narrow_helper( const char *repoid ); protected: HomeExecutorBase() {}; private: HomeExecutorBase( const HomeExecutorBase& ); void operator=( const HomeExecutorBase& ); }; /* * Base class and common definitions for local interface ExecutorLocator */ class ExecutorLocator : virtual public ::Components::EnterpriseComponent { public: virtual ~ExecutorLocator(); #ifdef HAVE_TYPEDEF_OVERLOAD typedef ExecutorLocator_ptr _ptr_type; typedef ExecutorLocator_var _var_type; #endif static ExecutorLocator_ptr _narrow( CORBA::Object_ptr obj ); static ExecutorLocator_ptr _narrow( CORBA::AbstractBase_ptr obj ); static ExecutorLocator_ptr _duplicate( ExecutorLocator_ptr _obj ) { CORBA::Object::_duplicate (_obj); return _obj; } static ExecutorLocator_ptr _nil() { return 0; } virtual void *_narrow_helper( const char *repoid ); virtual CORBA::Object_ptr obtain_executor( const char* name ) = 0; virtual void release_executor( CORBA::Object_ptr exc ) = 0; virtual void configurationComplete() = 0; protected: ExecutorLocator() {}; private: ExecutorLocator( const ExecutorLocator& ); void operator=( const ExecutorLocator& ); }; struct UnknownImplId : public CORBA::UserException { #ifdef HAVE_EXPLICIT_STRUCT_OPS UnknownImplId(); ~UnknownImplId(); UnknownImplId( const UnknownImplId& s ); UnknownImplId& operator=( const UnknownImplId& s ); #endif //HAVE_EXPLICIT_STRUCT_OPS #ifdef HAVE_STD_EH UnknownImplId *operator->() { return this; } UnknownImplId& operator*() { return *this; } operator UnknownImplId*() { 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 UnknownImplId *_downcast( CORBA::Exception *ex ); static const UnknownImplId *_downcast( const CORBA::Exception *ex ); }; #ifdef HAVE_STD_EH typedef UnknownImplId UnknownImplId_catch; #else typedef ExceptVar< UnknownImplId > UnknownImplId_var; typedef TVarOut< UnknownImplId > UnknownImplId_out; typedef UnknownImplId_var UnknownImplId_catch; #endif // HAVE_STD_EH struct InvalidLocation : public CORBA::UserException { #ifdef HAVE_EXPLICIT_STRUCT_OPS InvalidLocation(); ~InvalidLocation(); InvalidLocation( const InvalidLocation& s ); InvalidLocation& operator=( const InvalidLocation& s ); #endif //HAVE_EXPLICIT_STRUCT_OPS #ifdef HAVE_STD_EH InvalidLocation *operator->() { return this; } InvalidLocation& operator*() { return *this; } operator InvalidLocation*() { 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 InvalidLocation *_downcast( CORBA::Exception *ex ); static const InvalidLocation *_downcast( const CORBA::Exception *ex ); }; #ifdef HAVE_STD_EH typedef InvalidLocation InvalidLocation_catch; #else typedef ExceptVar< InvalidLocation > InvalidLocation_var; typedef TVarOut< InvalidLocation > InvalidLocation_out; typedef InvalidLocation_var InvalidLocation_catch; #endif // HAVE_STD_EH struct CreateFailure : public CORBA::UserException { #ifdef HAVE_EXPLICIT_STRUCT_OPS CreateFailure(); ~CreateFailure(); CreateFailure( const CreateFailure& s ); CreateFailure& operator=( const CreateFailure& s ); #endif //HAVE_EXPLICIT_STRUCT_OPS #ifdef HAVE_STD_EH CreateFailure *operator->() { return this; } CreateFailure& operator*() { return *this; } operator CreateFailure*() { 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 CreateFailure *_downcast( CORBA::Exception *ex ); static const CreateFailure *_downcast( const CORBA::Exception *ex ); }; #ifdef HAVE_STD_EH typedef CreateFailure CreateFailure_catch; #else typedef ExceptVar< CreateFailure > CreateFailure_var; typedef TVarOut< CreateFailure > CreateFailure_out; typedef CreateFailure_var CreateFailure_catch; #endif // HAVE_STD_EH struct RemoveFailure : public CORBA::UserException { #ifdef HAVE_EXPLICIT_STRUCT_OPS RemoveFailure(); ~RemoveFailure(); RemoveFailure( const RemoveFailure& s ); RemoveFailure& operator=( const RemoveFailure& s ); #endif //HAVE_EXPLICIT_STRUCT_OPS #ifdef HAVE_STD_EH RemoveFailure *operator->() { return this; } RemoveFailure& operator*() { return *this; } operator RemoveFailure*() { 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 RemoveFailure *_downcast( CORBA::Exception *ex ); static const RemoveFailure *_downcast( const CORBA::Exception *ex ); }; #ifdef HAVE_STD_EH typedef RemoveFailure RemoveFailure_catch; #else typedef ExceptVar< RemoveFailure > RemoveFailure_var; typedef TVarOut< RemoveFailure > RemoveFailure_out; typedef RemoveFailure_var RemoveFailure_catch; #endif // HAVE_STD_EH struct InstallationFailure : public CORBA::UserException { #ifdef HAVE_EXPLICIT_STRUCT_OPS InstallationFailure(); ~InstallationFailure(); InstallationFailure( const InstallationFailure& s ); InstallationFailure& operator=( const InstallationFailure& s ); #endif //HAVE_EXPLICIT_STRUCT_OPS #ifdef HAVE_STD_EH InstallationFailure *operator->() { return this; } InstallationFailure& operator*() { return *this; } operator InstallationFailure*() { 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 InstallationFailure *_downcast( CORBA::Exception *ex ); static const InstallationFailure *_downcast( const CORBA::Exception *ex ); }; #ifdef HAVE_STD_EH typedef InstallationFailure InstallationFailure_catch; #else typedef ExceptVar< InstallationFailure > InstallationFailure_var; typedef TVarOut< InstallationFailure > InstallationFailure_out; typedef InstallationFailure_var InstallationFailure_catch; #endif // HAVE_STD_EH struct InvalidAssembly : public CORBA::UserException { #ifdef HAVE_EXPLICIT_STRUCT_OPS InvalidAssembly(); ~InvalidAssembly(); InvalidAssembly( const InvalidAssembly& s ); InvalidAssembly& operator=( const InvalidAssembly& s ); #endif //HAVE_EXPLICIT_STRUCT_OPS #ifdef HAVE_STD_EH InvalidAssembly *operator->() { return this; } InvalidAssembly& operator*() { return *this; } operator InvalidAssembly*() { 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 InvalidAssembly *_downcast( CORBA::Exception *ex ); static const InvalidAssembly *_downcast( const CORBA::Exception *ex ); }; #ifdef HAVE_STD_EH typedef InvalidAssembly InvalidAssembly_catch; #else typedef ExceptVar< InvalidAssembly > InvalidAssembly_var; typedef TVarOut< InvalidAssembly > InvalidAssembly_out; typedef InvalidAssembly_var InvalidAssembly_catch; #endif // HAVE_STD_EH /* * Base class and common definitions for interface Container */ class Container : virtual public CORBA::Object { public: virtual ~Container(); #ifdef HAVE_TYPEDEF_OVERLOAD typedef Container_ptr _ptr_type; typedef Container_var _var_type; #endif static Container_ptr _narrow( CORBA::Object_ptr obj ); static Container_ptr _narrow( CORBA::AbstractBase_ptr obj ); static Container_ptr _duplicate( Container_ptr _obj ) { CORBA::Object::_duplicate (_obj); return _obj; } static Container_ptr _nil() { return 0; } virtual void *_narrow_helper( const char *repoid ); virtual ::Components::ConfigValues* configuration() = 0; virtual ComponentServer_ptr get_component_server() = 0; virtual CCMHome_ptr install_home( const char* id, const char* entrypt, const ConfigValues& config ) = 0; virtual void remove_home( CCMHome_ptr href ) = 0; virtual CCMHomes* get_homes() = 0; virtual void remove() = 0; protected: Container() {}; private: Container( const Container& ); void operator=( const Container& ); }; // Stub for interface Container class Container_stub: virtual public Container { public: virtual ~Container_stub(); ::Components::ConfigValues* configuration(); ComponentServer_ptr get_component_server(); CCMHome_ptr install_home( const char* id, const char* entrypt, const ConfigValues& config ); void remove_home( CCMHome_ptr href ); CCMHomes* get_homes(); void remove(); private: void operator=( const Container_stub& ); }; #ifndef MICO_CONF_NO_POA class Container_stub_clp : virtual public Container_stub, virtual public PortableServer::StubBase { public: Container_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr); virtual ~Container_stub_clp (); ::Components::ConfigValues* configuration(); ComponentServer_ptr get_component_server(); CCMHome_ptr install_home( const char* id, const char* entrypt, const ConfigValues& config ); void remove_home( CCMHome_ptr href ); CCMHomes* get_homes(); void remove(); protected: Container_stub_clp (); private: void operator=( const Container_stub_clp & ); }; #endif // MICO_CONF_NO_POA typedef IfaceSequenceTmpl< Container_var,Container_ptr> Containers; typedef TSeqVar< IfaceSequenceTmpl< Container_var,Container_ptr> > Containers_var; typedef TSeqOut< IfaceSequenceTmpl< Container_var,Container_ptr> > Containers_out; /* * Base class and common definitions for interface ComponentServer */ class ComponentServer : virtual public CORBA::Object { public: virtual ~ComponentServer(); #ifdef HAVE_TYPEDEF_OVERLOAD typedef ComponentServer_ptr _ptr_type; typedef ComponentServer_var _var_type; #endif static ComponentServer_ptr _narrow( CORBA::Object_ptr obj ); static ComponentServer_ptr _narrow( CORBA::AbstractBase_ptr obj ); static ComponentServer_ptr _duplicate( ComponentServer_ptr _obj ) { CORBA::Object::_duplicate (_obj); return _obj; } static ComponentServer_ptr _nil() { return 0; } virtual void *_narrow_helper( const char *repoid ); virtual ::Components::ConfigValues* configuration() = 0; virtual ServerActivator_ptr get_server_activator() = 0; virtual Container_ptr create_container( const ConfigValues& config ) = 0; virtual void remove_container( Container_ptr cref ) = 0; virtual Containers* get_containers() = 0; virtual void remove() = 0; protected: ComponentServer() {}; private: ComponentServer( const ComponentServer& ); void operator=( const ComponentServer& ); }; // Stub for interface ComponentServer class ComponentServer_stub: virtual public ComponentServer { public: virtual ~ComponentServer_stub(); ::Components::ConfigValues* configuration(); ServerActivator_ptr get_server_activator(); Container_ptr create_container( const ConfigValues& config ); void remove_container( Container_ptr cref ); Containers* get_containers(); void remove(); private: void operator=( const ComponentServer_stub& ); }; #ifndef MICO_CONF_NO_POA class ComponentServer_stub_clp : virtual public ComponentServer_stub, virtual public PortableServer::StubBase { public: ComponentServer_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr); virtual ~ComponentServer_stub_clp (); ::Components::ConfigValues* configuration(); ServerActivator_ptr get_server_activator(); Container_ptr create_container( const ConfigValues& config ); void remove_container( Container_ptr cref ); Containers* get_containers(); void remove(); protected: ComponentServer_stub_clp (); private: void operator=( const ComponentServer_stub_clp & ); }; #endif // MICO_CONF_NO_POA typedef IfaceSequenceTmpl< ComponentServer_var,ComponentServer_ptr> ComponentServers; typedef TSeqVar< IfaceSequenceTmpl< ComponentServer_var,ComponentServer_ptr> > ComponentServers_var; typedef TSeqOut< IfaceSequenceTmpl< ComponentServer_var,ComponentServer_ptr> > ComponentServers_out; typedef char* UUID; typedef CORBA::String_var UUID_var; typedef CORBA::String_out UUID_out; typedef char* Location; typedef CORBA::String_var Location_var; typedef CORBA::String_out Location_out; /* * Base class and common definitions for interface ComponentInstallation */ class ComponentInstallation : virtual public CORBA::Object { public: virtual ~ComponentInstallation(); #ifdef HAVE_TYPEDEF_OVERLOAD typedef ComponentInstallation_ptr _ptr_type; typedef ComponentInstallation_var _var_type; #endif static ComponentInstallation_ptr _narrow( CORBA::Object_ptr obj ); static ComponentInstallation_ptr _narrow( CORBA::AbstractBase_ptr obj ); static ComponentInstallation_ptr _duplicate( ComponentInstallation_ptr _obj ) { CORBA::Object::_duplicate (_obj); return _obj; } static ComponentInstallation_ptr _nil() { return 0; } virtual void *_narrow_helper( const char *repoid ); virtual void install( const char* implUUID, const char* component_loc ) = 0; virtual void replace( const char* implUUID, const char* component_loc ) = 0; virtual void remove( const char* implUUID ) = 0; virtual char* get_implementation( const char* implUUID ) = 0; protected: ComponentInstallation() {}; private: ComponentInstallation( const ComponentInstallation& ); void operator=( const ComponentInstallation& ); }; // Stub for interface ComponentInstallation class ComponentInstallation_stub: virtual public ComponentInstallation { public: virtual ~ComponentInstallation_stub(); void install( const char* implUUID, const char* component_loc ); void replace( const char* implUUID, const char* component_loc ); void remove( const char* implUUID ); char* get_implementation( const char* implUUID ); private: void operator=( const ComponentInstallation_stub& ); }; #ifndef MICO_CONF_NO_POA class ComponentInstallation_stub_clp : virtual public ComponentInstallation_stub, virtual public PortableServer::StubBase { public: ComponentInstallation_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr); virtual ~ComponentInstallation_stub_clp (); void install( const char* implUUID, const char* component_loc ); void replace( const char* implUUID, const char* component_loc ); void remove( const char* implUUID ); char* get_implementation( const char* implUUID ); protected: ComponentInstallation_stub_clp (); private: void operator=( const ComponentInstallation_stub_clp & ); }; #endif // MICO_CONF_NO_POA enum AssemblyState { INACTIVE = 0, INSERVICE }; typedef AssemblyState& AssemblyState_out; /* * Base class and common definitions for interface Assembly */ class Assembly : virtual public CORBA::Object { public: virtual ~Assembly(); #ifdef HAVE_TYPEDEF_OVERLOAD typedef Assembly_ptr _ptr_type; typedef Assembly_var _var_type; #endif static Assembly_ptr _narrow( CORBA::Object_ptr obj ); static Assembly_ptr _narrow( CORBA::AbstractBase_ptr obj ); static Assembly_ptr _duplicate( Assembly_ptr _obj ) { CORBA::Object::_duplicate (_obj); return _obj; } static Assembly_ptr _nil() { return 0; } virtual void *_narrow_helper( const char *repoid ); virtual void build() = 0; virtual void tear_down() = 0; virtual AssemblyState get_state() = 0; protected: Assembly() {}; private: Assembly( const Assembly& ); void operator=( const Assembly& ); }; // Stub for interface Assembly class Assembly_stub: virtual public Assembly { public: virtual ~Assembly_stub(); void build(); void tear_down(); AssemblyState get_state(); private: void operator=( const Assembly_stub& ); }; #ifndef MICO_CONF_NO_POA class Assembly_stub_clp : virtual public Assembly_stub, virtual public PortableServer::StubBase { public: Assembly_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr); virtual ~Assembly_stub_clp (); void build(); void tear_down(); AssemblyState get_state(); protected: Assembly_stub_clp (); private: void operator=( const Assembly_stub_clp & ); }; #endif // MICO_CONF_NO_POA /* * Base class and common definitions for interface AssemblyFactory */ class AssemblyFactory : virtual public CORBA::Object { public: virtual ~AssemblyFactory(); #ifdef HAVE_TYPEDEF_OVERLOAD typedef AssemblyFactory_ptr _ptr_type; typedef AssemblyFactory_var _var_type; #endif static AssemblyFactory_ptr _narrow( CORBA::Object_ptr obj ); static AssemblyFactory_ptr _narrow( CORBA::AbstractBase_ptr obj ); static AssemblyFactory_ptr _duplicate( AssemblyFactory_ptr _obj ) { CORBA::Object::_duplicate (_obj); return _obj; } static AssemblyFactory_ptr _nil() { return 0; } virtual void *_narrow_helper( const char *repoid ); virtual Cookie* create( const char* assembly_loc ) = 0; virtual Assembly_ptr lookup( Cookie* c ) = 0; virtual void destroy( Cookie* c ) = 0; protected: AssemblyFactory() {}; private: AssemblyFactory( const AssemblyFactory& ); void operator=( const AssemblyFactory& ); }; // Stub for interface AssemblyFactory class AssemblyFactory_stub: virtual public AssemblyFactory { public: virtual ~AssemblyFactory_stub(); Cookie* create( const char* assembly_loc ); Assembly_ptr lookup( Cookie* c ); void destroy( Cookie* c ); private: void operator=( const AssemblyFactory_stub& ); }; #ifndef MICO_CONF_NO_POA class AssemblyFactory_stub_clp : virtual public AssemblyFactory_stub, virtual public PortableServer::StubBase { public: AssemblyFactory_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr); virtual ~AssemblyFactory_stub_clp (); Cookie* create( const char* assembly_loc ); Assembly_ptr lookup( Cookie* c ); void destroy( Cookie* c ); protected: AssemblyFactory_stub_clp (); private: void operator=( const AssemblyFactory_stub_clp & ); }; #endif // MICO_CONF_NO_POA /* * Base class and common definitions for interface ServerActivator */ class ServerActivator : virtual public CORBA::Object { public: virtual ~ServerActivator(); #ifdef HAVE_TYPEDEF_OVERLOAD typedef ServerActivator_ptr _ptr_type; typedef ServerActivator_var _var_type; #endif static ServerActivator_ptr _narrow( CORBA::Object_ptr obj ); static ServerActivator_ptr _narrow( CORBA::AbstractBase_ptr obj ); static ServerActivator_ptr _duplicate( ServerActivator_ptr _obj ) { CORBA::Object::_duplicate (_obj); return _obj; } static ServerActivator_ptr _nil() { return 0; } virtual void *_narrow_helper( const char *repoid ); virtual ComponentServer_ptr create_component_server( const ConfigValues& config ) = 0; virtual void remove_component_server( ComponentServer_ptr server ) = 0; virtual ComponentServers* get_component_servers() = 0; protected: ServerActivator() {}; private: ServerActivator( const ServerActivator& ); void operator=( const ServerActivator& ); }; // Stub for interface ServerActivator class ServerActivator_stub: virtual public ServerActivator { public: virtual ~ServerActivator_stub(); ComponentServer_ptr create_component_server( const ConfigValues& config ); void remove_component_server( ComponentServer_ptr server ); ComponentServers* get_component_servers(); private: void operator=( const ServerActivator_stub& ); }; #ifndef MICO_CONF_NO_POA class ServerActivator_stub_clp : virtual public ServerActivator_stub, virtual public PortableServer::StubBase { public: ServerActivator_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr); virtual ~ServerActivator_stub_clp (); ComponentServer_ptr create_component_server( const ConfigValues& config ); void remove_component_server( ComponentServer_ptr server ); ComponentServers* get_component_servers(); protected: ServerActivator_stub_clp (); private: void operator=( const ServerActivator_stub_clp & ); }; #endif // MICO_CONF_NO_POA } namespace MICOCCM { /* * Base class and common definitions for interface MicoCCMD */ class MicoCCMD : virtual public ::Components::ServerActivator, virtual public ::Components::ComponentInstallation, virtual public ::Components::AssemblyFactory { public: virtual ~MicoCCMD(); #ifdef HAVE_TYPEDEF_OVERLOAD typedef MicoCCMD_ptr _ptr_type; typedef MicoCCMD_var _var_type; #endif static MicoCCMD_ptr _narrow( CORBA::Object_ptr obj ); static MicoCCMD_ptr _narrow( CORBA::AbstractBase_ptr obj ); static MicoCCMD_ptr _duplicate( MicoCCMD_ptr _obj ) { CORBA::Object::_duplicate (_obj); return _obj; } static MicoCCMD_ptr _nil() { return 0; } virtual void *_narrow_helper( const char *repoid ); virtual CORBA::Object_ptr exec( const char* prog, const ::Components::NameList& args, const char* iorfile ) = 0; virtual void callback( const char* token, CORBA::Object_ptr csref ) = 0; protected: MicoCCMD() {}; private: MicoCCMD( const MicoCCMD& ); void operator=( const MicoCCMD& ); }; // Stub for interface MicoCCMD class MicoCCMD_stub: virtual public MicoCCMD, virtual public ::Components::ServerActivator_stub, virtual public ::Components::ComponentInstallation_stub, virtual public ::Components::AssemblyFactory_stub { public: virtual ~MicoCCMD_stub(); CORBA::Object_ptr exec( const char* prog, const ::Components::NameList& args, const char* iorfile ); void callback( const char* token, CORBA::Object_ptr csref ); private: void operator=( const MicoCCMD_stub& ); }; #ifndef MICO_CONF_NO_POA class MicoCCMD_stub_clp : virtual public MicoCCMD_stub, virtual public ::Components::ServerActivator_stub_clp, virtual public ::Components::ComponentInstallation_stub_clp, virtual public ::Components::AssemblyFactory_stub_clp { public: MicoCCMD_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr); virtual ~MicoCCMD_stub_clp (); CORBA::Object_ptr exec( const char* prog, const ::Components::NameList& args, const char* iorfile ); void callback( const char* token, CORBA::Object_ptr csref ); protected: MicoCCMD_stub_clp (); private: void operator=( const MicoCCMD_stub_clp & ); }; #endif // MICO_CONF_NO_POA /* * Base class and common definitions for interface ComponentServer */ class ComponentServer : virtual public ::Components::ComponentServer { public: virtual ~ComponentServer(); #ifdef HAVE_TYPEDEF_OVERLOAD typedef ComponentServer_ptr _ptr_type; typedef ComponentServer_var _var_type; #endif static ComponentServer_ptr _narrow( CORBA::Object_ptr obj ); static ComponentServer_ptr _narrow( CORBA::AbstractBase_ptr obj ); static ComponentServer_ptr _duplicate( ComponentServer_ptr _obj ) { CORBA::Object::_duplicate (_obj); return _obj; } static ComponentServer_ptr _nil() { return 0; } virtual void *_narrow_helper( const char *repoid ); virtual void set_config_values( const ::Components::ConfigValues& config ) = 0; protected: ComponentServer() {}; private: ComponentServer( const ComponentServer& ); void operator=( const ComponentServer& ); }; // Stub for interface ComponentServer class ComponentServer_stub: virtual public ComponentServer, virtual public ::Components::ComponentServer_stub { public: virtual ~ComponentServer_stub(); void set_config_values( const ::Components::ConfigValues& config ); private: void operator=( const ComponentServer_stub& ); }; #ifndef MICO_CONF_NO_POA class ComponentServer_stub_clp : virtual public ComponentServer_stub, virtual public ::Components::ComponentServer_stub_clp { public: ComponentServer_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr); virtual ~ComponentServer_stub_clp (); void set_config_values( const ::Components::ConfigValues& config ); protected: ComponentServer_stub_clp (); private: void operator=( const ComponentServer_stub_clp & ); }; #endif // MICO_CONF_NO_POA } namespace HPI { /* * Base class and common definitions for interface HomeFinder */ class HomeFinder : virtual public ::Components::HomeFinder { public: virtual ~HomeFinder(); #ifdef HAVE_TYPEDEF_OVERLOAD typedef HomeFinder_ptr _ptr_type; typedef HomeFinder_var _var_type; #endif static HomeFinder_ptr _narrow( CORBA::Object_ptr obj ); static HomeFinder_ptr _narrow( CORBA::AbstractBase_ptr obj ); static HomeFinder_ptr _duplicate( HomeFinder_ptr _obj ) { CORBA::Object::_duplicate (_obj); return _obj; } static HomeFinder_ptr _nil() { return 0; } virtual void *_narrow_helper( const char *repoid ); virtual CORBA::Long _cxx_register( const char* comp_repid, const char* home_repid, ::Components::CCMHome_ptr the_home ) = 0; virtual void unregister( CORBA::Long cookie ) = 0; protected: HomeFinder() {}; private: HomeFinder( const HomeFinder& ); void operator=( const HomeFinder& ); }; // Stub for interface HomeFinder class HomeFinder_stub: virtual public HomeFinder, virtual public ::Components::HomeFinder_stub { public: virtual ~HomeFinder_stub(); CORBA::Long _cxx_register( const char* comp_repid, const char* home_repid, ::Components::CCMHome_ptr the_home ); void unregister( CORBA::Long cookie ); private: void operator=( const HomeFinder_stub& ); }; #ifndef MICO_CONF_NO_POA class HomeFinder_stub_clp : virtual public HomeFinder_stub, virtual public ::Components::HomeFinder_stub_clp { public: HomeFinder_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr); virtual ~HomeFinder_stub_clp (); CORBA::Long _cxx_register( const char* comp_repid, const char* home_repid, ::Components::CCMHome_ptr the_home ); void unregister( CORBA::Long cookie ); protected: HomeFinder_stub_clp (); private: void operator=( const HomeFinder_stub_clp & ); }; #endif // MICO_CONF_NO_POA } #ifndef MICO_CONF_NO_POA namespace POA_Components { class Navigation : virtual public PortableServer::StaticImplementation { public: virtual ~Navigation (); Components::Navigation_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 Navigation * _narrow (PortableServer::Servant); virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr); virtual CORBA::Object_ptr provide_facet( const char* name ) = 0; virtual ::Components::FacetDescriptions* get_all_facets() = 0; virtual ::Components::FacetDescriptions* get_named_facets( const ::Components::NameList& names ) = 0; virtual CORBA::Boolean same_component( CORBA::Object_ptr ref ) = 0; protected: Navigation () {}; private: Navigation (const Navigation &); void operator= (const Navigation &); }; class Receptacles : virtual public PortableServer::StaticImplementation { public: virtual ~Receptacles (); Components::Receptacles_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 Receptacles * _narrow (PortableServer::Servant); virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr); virtual ::Components::Cookie* connect( const char* name, CORBA::Object_ptr connection ) = 0; virtual void disconnect( const char* name, ::Components::Cookie* ck ) = 0; virtual ::Components::ConnectionDescriptions* get_connections( const char* name ) = 0; virtual ::Components::ReceptacleDescriptions* get_all_receptacles() = 0; virtual ::Components::ReceptacleDescriptions* get_named_receptacles( const ::Components::NameList& names ) = 0; protected: Receptacles () {}; private: Receptacles (const Receptacles &); void operator= (const Receptacles &); }; class EventConsumerBase : virtual public PortableServer::StaticImplementation { public: virtual ~EventConsumerBase (); Components::EventConsumerBase_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 EventConsumerBase * _narrow (PortableServer::Servant); virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr); virtual void push_event( ::Components::EventBase* evt ) = 0; protected: EventConsumerBase () {}; private: EventConsumerBase (const EventConsumerBase &); void operator= (const EventConsumerBase &); }; class Events : virtual public PortableServer::StaticImplementation { public: virtual ~Events (); Components::Events_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 Events * _narrow (PortableServer::Servant); virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr); virtual ::Components::EventConsumerBase_ptr get_consumer( const char* sink_name ) = 0; virtual ::Components::ConsumerDescriptions* get_all_consumers() = 0; virtual ::Components::ConsumerDescriptions* get_named_consumers( const ::Components::NameList& names ) = 0; virtual ::Components::Cookie* subscribe( const char* publisher_name, ::Components::EventConsumerBase_ptr subscriber ) = 0; virtual void unsubscribe( const char* publisher_name, ::Components::Cookie* ck ) = 0; virtual ::Components::PublisherDescriptions* get_all_publishers() = 0; virtual ::Components::PublisherDescriptions* get_named_publishers( const ::Components::NameList& names ) = 0; virtual void connect_consumer( const char* emitter_name, ::Components::EventConsumerBase_ptr consumer ) = 0; virtual ::Components::EventConsumerBase_ptr disconnect_consumer( const char* source_name ) = 0; virtual ::Components::EmitterDescriptions* get_all_emitters() = 0; virtual ::Components::EmitterDescriptions* get_named_emitters( const ::Components::NameList& names ) = 0; protected: Events () {}; private: Events (const Events &); void operator= (const Events &); }; class CCMHome : virtual public PortableServer::StaticImplementation { public: virtual ~CCMHome (); Components::CCMHome_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 CCMHome * _narrow (PortableServer::Servant); virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr); virtual CORBA::Object_ptr get_component_def() = 0; virtual CORBA::Object_ptr get_home_def() = 0; virtual void remove_component( ::Components::CCMObject_ptr comp ) = 0; protected: CCMHome () {}; private: CCMHome (const CCMHome &); void operator= (const CCMHome &); }; class CCMObject : virtual public POA_Components::Navigation, virtual public POA_Components::Receptacles, virtual public POA_Components::Events { public: virtual ~CCMObject (); Components::CCMObject_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 CCMObject * _narrow (PortableServer::Servant); virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr); virtual CORBA::Object_ptr get_component_def() = 0; virtual ::Components::CCMHome_ptr get_ccm_home() = 0; virtual void configuration_complete() = 0; virtual void remove() = 0; virtual ::Components::ComponentPortDescription* get_all_ports() = 0; protected: CCMObject () {}; private: CCMObject (const CCMObject &); void operator= (const CCMObject &); }; class KeylessCCMHome : virtual public PortableServer::StaticImplementation { public: virtual ~KeylessCCMHome (); Components::KeylessCCMHome_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 KeylessCCMHome * _narrow (PortableServer::Servant); virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr); virtual ::Components::CCMObject_ptr create_component() = 0; protected: KeylessCCMHome () {}; private: KeylessCCMHome (const KeylessCCMHome &); void operator= (const KeylessCCMHome &); }; class HomeFinder : virtual public PortableServer::StaticImplementation { public: virtual ~HomeFinder (); Components::HomeFinder_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 HomeFinder * _narrow (PortableServer::Servant); virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr); virtual ::Components::CCMHome_ptr find_home_by_component_type( const char* comp_repid ) = 0; virtual ::Components::CCMHome_ptr find_home_by_home_type( const char* home_repid ) = 0; virtual ::Components::CCMHome_ptr find_home_by_name( const char* home_name ) = 0; protected: HomeFinder () {}; private: HomeFinder (const HomeFinder &); void operator= (const HomeFinder &); }; class Configurator : virtual public PortableServer::StaticImplementation { public: virtual ~Configurator (); Components::Configurator_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 Configurator * _narrow (PortableServer::Servant); virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr); virtual void configure( ::Components::CCMObject_ptr comp ) = 0; protected: Configurator () {}; private: Configurator (const Configurator &); void operator= (const Configurator &); }; class StandardConfigurator : virtual public POA_Components::Configurator { public: virtual ~StandardConfigurator (); Components::StandardConfigurator_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 StandardConfigurator * _narrow (PortableServer::Servant); virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr); virtual void set_configuration( const ::Components::ConfigValues& descr ) = 0; protected: StandardConfigurator () {}; private: StandardConfigurator (const StandardConfigurator &); void operator= (const StandardConfigurator &); }; class Container : virtual public PortableServer::StaticImplementation { public: virtual ~Container (); Components::Container_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 Container * _narrow (PortableServer::Servant); virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr); virtual ::Components::ConfigValues* configuration() = 0; virtual ::Components::ComponentServer_ptr get_component_server() = 0; virtual ::Components::CCMHome_ptr install_home( const char* id, const char* entrypt, const ::Components::ConfigValues& config ) = 0; virtual void remove_home( ::Components::CCMHome_ptr href ) = 0; virtual ::Components::CCMHomes* get_homes() = 0; virtual void remove() = 0; protected: Container () {}; private: Container (const Container &); void operator= (const Container &); }; class ComponentServer : virtual public PortableServer::StaticImplementation { public: virtual ~ComponentServer (); Components::ComponentServer_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 ComponentServer * _narrow (PortableServer::Servant); virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr); virtual ::Components::ConfigValues* configuration() = 0; virtual ::Components::ServerActivator_ptr get_server_activator() = 0; virtual ::Components::Container_ptr create_container( const ::Components::ConfigValues& config ) = 0; virtual void remove_container( ::Components::Container_ptr cref ) = 0; virtual ::Components::Containers* get_containers() = 0; virtual void remove() = 0; protected: ComponentServer () {}; private: ComponentServer (const ComponentServer &); void operator= (const ComponentServer &); }; class ComponentInstallation : virtual public PortableServer::StaticImplementation { public: virtual ~ComponentInstallation (); Components::ComponentInstallation_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 ComponentInstallation * _narrow (PortableServer::Servant); virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr); virtual void install( const char* implUUID, const char* component_loc ) = 0; virtual void replace( const char* implUUID, const char* component_loc ) = 0; virtual void remove( const char* implUUID ) = 0; virtual char* get_implementation( const char* implUUID ) = 0; protected: ComponentInstallation () {}; private: ComponentInstallation (const ComponentInstallation &); void operator= (const ComponentInstallation &); }; class Assembly : virtual public PortableServer::StaticImplementation { public: virtual ~Assembly (); Components::Assembly_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 Assembly * _narrow (PortableServer::Servant); virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr); virtual void build() = 0; virtual void tear_down() = 0; virtual ::Components::AssemblyState get_state() = 0; protected: Assembly () {}; private: Assembly (const Assembly &); void operator= (const Assembly &); }; class AssemblyFactory : virtual public PortableServer::StaticImplementation { public: virtual ~AssemblyFactory (); Components::AssemblyFactory_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 AssemblyFactory * _narrow (PortableServer::Servant); virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr); virtual ::Components::Cookie* create( const char* assembly_loc ) = 0; virtual ::Components::Assembly_ptr lookup( ::Components::Cookie* c ) = 0; virtual void destroy( ::Components::Cookie* c ) = 0; protected: AssemblyFactory () {}; private: AssemblyFactory (const AssemblyFactory &); void operator= (const AssemblyFactory &); }; class ServerActivator : virtual public PortableServer::StaticImplementation { public: virtual ~ServerActivator (); Components::ServerActivator_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 ServerActivator * _narrow (PortableServer::Servant); virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr); virtual ::Components::ComponentServer_ptr create_component_server( const ::Components::ConfigValues& config ) = 0; virtual void remove_component_server( ::Components::ComponentServer_ptr server ) = 0; virtual ::Components::ComponentServers* get_component_servers() = 0; protected: ServerActivator () {}; private: ServerActivator (const ServerActivator &); void operator= (const ServerActivator &); }; } namespace POA_MICOCCM { class MicoCCMD : virtual public POA_Components::ServerActivator, virtual public POA_Components::ComponentInstallation, virtual public POA_Components::AssemblyFactory { public: virtual ~MicoCCMD (); MICOCCM::MicoCCMD_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 MicoCCMD * _narrow (PortableServer::Servant); virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr); virtual CORBA::Object_ptr exec( const char* prog, const ::Components::NameList& args, const char* iorfile ) = 0; virtual void callback( const char* token, CORBA::Object_ptr csref ) = 0; protected: MicoCCMD () {}; private: MicoCCMD (const MicoCCMD &); void operator= (const MicoCCMD &); }; class ComponentServer : virtual public POA_Components::ComponentServer { public: virtual ~ComponentServer (); MICOCCM::ComponentServer_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 ComponentServer * _narrow (PortableServer::Servant); virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr); virtual void set_config_values( const ::Components::ConfigValues& config ) = 0; protected: ComponentServer () {}; private: ComponentServer (const ComponentServer &); void operator= (const ComponentServer &); }; } namespace POA_HPI { class HomeFinder : virtual public POA_Components::HomeFinder { public: virtual ~HomeFinder (); HPI::HomeFinder_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 HomeFinder * _narrow (PortableServer::Servant); virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr); virtual CORBA::Long _cxx_register( const char* comp_repid, const char* home_repid, ::Components::CCMHome_ptr the_home ) = 0; virtual void unregister( CORBA::Long cookie ) = 0; protected: HomeFinder () {}; private: HomeFinder (const HomeFinder &); void operator= (const HomeFinder &); }; } #endif // MICO_CONF_NO_POA namespace OBV_Components { // OBV class for valuetype PortDescription class PortDescription : virtual public Components::PortDescription { protected: PortDescription (); PortDescription (const char* _name, const char* _type_id); virtual ~PortDescription(); public: void name( char *_p ); void name( const char *_p ); void name( const CORBA::String_var &_p ); const char *name() const; void type_id( char *_p ); void type_id( const char *_p ); void type_id( const CORBA::String_var &_p ); const char *type_id() const; private: struct _M { ::Components::FeatureName_var name; CORBA::String_var type_id; } _m; }; // OBV class for valuetype Cookie class Cookie : virtual public Components::Cookie { protected: Cookie (); Cookie (const SequenceTmpl< CORBA::Octet,MICO_TID_OCTET>& _CookieValue); virtual ~Cookie(); public: typedef SequenceTmpl< CORBA::Octet,MICO_TID_OCTET> _CookieValue_seq; void CookieValue( const _CookieValue_seq & _p); const _CookieValue_seq & CookieValue() const; _CookieValue_seq & CookieValue(); private: struct _M { SequenceTmpl< CORBA::Octet,MICO_TID_OCTET> CookieValue; } _m; }; // OBV class for valuetype FacetDescription class FacetDescription : virtual public Components::FacetDescription, virtual public OBV_Components::PortDescription { protected: FacetDescription (); FacetDescription (CORBA::Object_ptr _facet_ref); virtual ~FacetDescription(); public: void facet_ref( CORBA::Object_ptr _p ); CORBA::Object_ptr facet_ref() const; private: struct _M { CORBA::Object_var facet_ref; } _m; }; // OBV class for valuetype ConnectionDescription class ConnectionDescription : virtual public Components::ConnectionDescription { protected: ConnectionDescription (); ConnectionDescription (::Components::Cookie* _ck, CORBA::Object_ptr _objref); virtual ~ConnectionDescription(); public: void ck( ::Components::Cookie* _p ); ::Components::Cookie* ck() const; void objref( CORBA::Object_ptr _p ); CORBA::Object_ptr objref() const; private: struct _M { ::Components::Cookie_var ck; CORBA::Object_var objref; } _m; }; // OBV class for valuetype ReceptacleDescription class ReceptacleDescription : virtual public Components::ReceptacleDescription, virtual public OBV_Components::PortDescription { protected: ReceptacleDescription (); ReceptacleDescription (CORBA::Boolean _is_multiplex, const ::Components::ConnectionDescriptions& _connections); virtual ~ReceptacleDescription(); public: void is_multiplex( CORBA::Boolean _p ); CORBA::Boolean is_multiplex() const; void connections( const ::Components::ConnectionDescriptions& _p ); const ::Components::ConnectionDescriptions& connections() const; ::Components::ConnectionDescriptions& connections(); private: struct _M { CORBA::Boolean is_multiplex; ::Components::ConnectionDescriptions connections; } _m; }; // OBV class for valuetype ConsumerDescription class ConsumerDescription : virtual public Components::ConsumerDescription, virtual public OBV_Components::PortDescription { protected: ConsumerDescription (); ConsumerDescription (::Components::EventConsumerBase_ptr _consumer); virtual ~ConsumerDescription(); public: void consumer( ::Components::EventConsumerBase_ptr _p ); ::Components::EventConsumerBase_ptr consumer() const; private: struct _M { ::Components::EventConsumerBase_var consumer; } _m; }; // OBV class for valuetype EmitterDescription class EmitterDescription : virtual public Components::EmitterDescription, virtual public OBV_Components::PortDescription { protected: EmitterDescription (); EmitterDescription (::Components::EventConsumerBase_ptr _consumer); virtual ~EmitterDescription(); public: void consumer( ::Components::EventConsumerBase_ptr _p ); ::Components::EventConsumerBase_ptr consumer() const; private: struct _M { ::Components::EventConsumerBase_var consumer; } _m; }; // OBV class for valuetype SubscriberDescription class SubscriberDescription : virtual public Components::SubscriberDescription { protected: SubscriberDescription (); SubscriberDescription (::Components::Cookie* _ck, ::Components::EventConsumerBase_ptr _consumer); virtual ~SubscriberDescription(); public: void ck( ::Components::Cookie* _p ); ::Components::Cookie* ck() const; void consumer( ::Components::EventConsumerBase_ptr _p ); ::Components::EventConsumerBase_ptr consumer() const; private: struct _M { ::Components::Cookie_var ck; ::Components::EventConsumerBase_var consumer; } _m; }; // OBV class for valuetype PublisherDescription class PublisherDescription : virtual public Components::PublisherDescription, virtual public OBV_Components::PortDescription { protected: PublisherDescription (); PublisherDescription (const ::Components::SubscriberDescriptions& _consumers); virtual ~PublisherDescription(); public: void consumers( const ::Components::SubscriberDescriptions& _p ); const ::Components::SubscriberDescriptions& consumers() const; ::Components::SubscriberDescriptions& consumers(); private: struct _M { ::Components::SubscriberDescriptions consumers; } _m; }; // OBV class for valuetype ComponentPortDescription class ComponentPortDescription : virtual public Components::ComponentPortDescription { protected: ComponentPortDescription (); ComponentPortDescription (const ::Components::FacetDescriptions& _facets, const ::Components::ReceptacleDescriptions& _receptacles, const ::Components::ConsumerDescriptions& _consumers, const ::Components::EmitterDescriptions& _emitters, const ::Components::PublisherDescriptions& _publishers); virtual ~ComponentPortDescription(); public: void facets( const ::Components::FacetDescriptions& _p ); const ::Components::FacetDescriptions& facets() const; ::Components::FacetDescriptions& facets(); void receptacles( const ::Components::ReceptacleDescriptions& _p ); const ::Components::ReceptacleDescriptions& receptacles() const; ::Components::ReceptacleDescriptions& receptacles(); void consumers( const ::Components::ConsumerDescriptions& _p ); const ::Components::ConsumerDescriptions& consumers() const; ::Components::ConsumerDescriptions& consumers(); void emitters( const ::Components::EmitterDescriptions& _p ); const ::Components::EmitterDescriptions& emitters() const; ::Components::EmitterDescriptions& emitters(); void publishers( const ::Components::PublisherDescriptions& _p ); const ::Components::PublisherDescriptions& publishers() const; ::Components::PublisherDescriptions& publishers(); private: struct _M { ::Components::FacetDescriptions facets; ::Components::ReceptacleDescriptions receptacles; ::Components::ConsumerDescriptions consumers; ::Components::EmitterDescriptions emitters; ::Components::PublisherDescriptions publishers; } _m; }; // OBV class for valuetype ConfigValue class ConfigValue : virtual public Components::ConfigValue { protected: ConfigValue (); ConfigValue (const char* _name, const CORBA::Any& _value); virtual ~ConfigValue(); public: void name( char *_p ); void name( const char *_p ); void name( const CORBA::String_var &_p ); const char *name() const; void value( const CORBA::Any& _p ); const CORBA::Any& value() const; CORBA::Any& value(); private: struct _M { ::Components::FeatureName_var name; CORBA::Any value; } _m; }; } extern CORBA::StaticTypeInfo *_marshaller_Components_InvalidName; extern CORBA::StaticTypeInfo *_marshaller_Components_InvalidConfiguration; extern CORBA::StaticTypeInfo *_marshaller_Components_AlreadyConnected; extern CORBA::StaticTypeInfo *_marshaller_Components_InvalidConnection; extern CORBA::StaticTypeInfo *_marshaller_Components_NoConnection; extern CORBA::StaticTypeInfo *_marshaller_Components_ExceededConnectionLimit; extern CORBA::StaticTypeInfo *_marshaller_Components_CookieRequired; extern CORBA::StaticTypeInfo *_marshaller_Components_PortDescription; extern CORBA::StaticTypeInfo *_marshaller_Components_Cookie; extern CORBA::StaticTypeInfo *_marshaller_Components_EventBase; extern CORBA::StaticTypeInfo *_marshaller_Components_FacetDescription; extern CORBA::StaticTypeInfo *_marshaller_Components_Navigation; extern CORBA::StaticTypeInfo *_marshaller_Components_ConnectionDescription; extern CORBA::StaticTypeInfo *_marshaller_Components_ReceptacleDescription; extern CORBA::StaticTypeInfo *_marshaller_Components_Receptacles; extern CORBA::StaticTypeInfo *_marshaller_Components_BadEventType; extern CORBA::StaticTypeInfo *_marshaller_Components_EventConsumerBase; extern CORBA::StaticTypeInfo *_marshaller_Components_ConsumerDescription; extern CORBA::StaticTypeInfo *_marshaller_Components_EmitterDescription; extern CORBA::StaticTypeInfo *_marshaller_Components_SubscriberDescription; extern CORBA::StaticTypeInfo *_marshaller_Components_PublisherDescription; extern CORBA::StaticTypeInfo *_marshaller_Components_Events; extern CORBA::StaticTypeInfo *_marshaller_Components_CCMHome; extern CORBA::StaticTypeInfo *_marshaller_Components_ComponentPortDescription; extern CORBA::StaticTypeInfo *_marshaller_Components_CCMObject; extern CORBA::StaticTypeInfo *_marshaller_Components_DuplicateKeyValue; extern CORBA::StaticTypeInfo *_marshaller_Components_UnknownKeyValue; extern CORBA::StaticTypeInfo *_marshaller_Components_InvalidKey; extern CORBA::StaticTypeInfo *_marshaller_Components_KeylessCCMHome; extern CORBA::StaticTypeInfo *_marshaller_Components_HomeNotFound; extern CORBA::StaticTypeInfo *_marshaller_Components_HomeFinder; extern CORBA::StaticTypeInfo *_marshaller_Components_WrongComponentType; extern CORBA::StaticTypeInfo *_marshaller_Components_Configurator; extern CORBA::StaticTypeInfo *_marshaller_Components_ConfigValue; extern CORBA::StaticTypeInfo *_marshaller_Components_StandardConfigurator; extern CORBA::StaticTypeInfo *_marshaller_Components_IllegalState; extern CORBA::StaticTypeInfo *_marshaller_Components_CCMExceptionReason; extern CORBA::StaticTypeInfo *_marshaller_Components_CCMException; extern CORBA::StaticTypeInfo *_marshaller_Components_UnknownImplId; extern CORBA::StaticTypeInfo *_marshaller_Components_InvalidLocation; extern CORBA::StaticTypeInfo *_marshaller_Components_CreateFailure; extern CORBA::StaticTypeInfo *_marshaller_Components_RemoveFailure; extern CORBA::StaticTypeInfo *_marshaller_Components_InstallationFailure; extern CORBA::StaticTypeInfo *_marshaller_Components_InvalidAssembly; extern CORBA::StaticTypeInfo *_marshaller_Components_Container; extern CORBA::StaticTypeInfo *_marshaller_Components_ComponentServer; extern CORBA::StaticTypeInfo *_marshaller_Components_ComponentInstallation; extern CORBA::StaticTypeInfo *_marshaller_Components_AssemblyState; extern CORBA::StaticTypeInfo *_marshaller_Components_Assembly; extern CORBA::StaticTypeInfo *_marshaller_Components_AssemblyFactory; extern CORBA::StaticTypeInfo *_marshaller_Components_ServerActivator; extern CORBA::StaticTypeInfo *_marshaller_MICOCCM_MicoCCMD; extern CORBA::StaticTypeInfo *_marshaller_MICOCCM_ComponentServer; extern CORBA::StaticTypeInfo *_marshaller_HPI_HomeFinder; extern CORBA::StaticTypeInfo *_marshaller__seq_Components_FacetDescription; extern CORBA::StaticTypeInfo *_marshaller__seq_Components_ConnectionDescription; extern CORBA::StaticTypeInfo *_marshaller__seq_Components_ReceptacleDescription; extern CORBA::StaticTypeInfo *_marshaller__seq_Components_ConsumerDescription; extern CORBA::StaticTypeInfo *_marshaller__seq_Components_EmitterDescription; extern CORBA::StaticTypeInfo *_marshaller__seq_Components_SubscriberDescription; extern CORBA::StaticTypeInfo *_marshaller__seq_Components_PublisherDescription; extern CORBA::StaticTypeInfo *_marshaller__seq_Components_CCMHome; extern CORBA::StaticTypeInfo *_marshaller__seq_Components_ConfigValue; extern CORBA::StaticTypeInfo *_marshaller__seq_Components_Container; extern CORBA::StaticTypeInfo *_marshaller__seq_Components_ComponentServer; #endif