diff options
Diffstat (limited to 'TAO/tao/PortableServer/ImplRepoC.h')
| -rw-r--r-- | TAO/tao/PortableServer/ImplRepoC.h | 1696 |
1 files changed, 1696 insertions, 0 deletions
diff --git a/TAO/tao/PortableServer/ImplRepoC.h b/TAO/tao/PortableServer/ImplRepoC.h new file mode 100644 index 00000000000..98eb947a86b --- /dev/null +++ b/TAO/tao/PortableServer/ImplRepoC.h @@ -0,0 +1,1696 @@ +/* -*- C++ -*- $Id$ */ + +// ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* +// TAO and the TAO IDL Compiler have been developed by the Center for +// Distributed Object Computing at Washington University, St. Louis. +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + +#ifndef _TAO_IDL_IMPLREPOC_H_ +#define _TAO_IDL_IMPLREPOC_H_ +#include "ace/pre.h" + +#include "portableserver_export.h" +#include "tao/Object.h" +#include "tao/Managed_Types.h" +#include "tao/Sequence.h" +#include "tao/Exception.h" +#include "tao/Environment.h" +#include "tao/CDR.h" +#include "tao/Any.h" +#include "tao/Typecode.h" +#include "tao/TAO_Singleton.h" + +#if defined (ACE_HAS_MINIMUM_IOSTREAMH_INCLUSION) +#include "ace/streams.h" +#endif /* ACE_HAS_MINIMUM_IOSTREAMH_INCLUSION */ + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + + +#if defined (TAO_EXPORT_MACRO) +#undef TAO_EXPORT_MACRO +#endif +#define TAO_EXPORT_MACRO TAO_PortableServer_Export + +#if defined (TAO_EXPORT_NESTED_CLASSES) +# if defined (TAO_EXPORT_NESTED_MACRO) +# undef TAO_EXPORT_NESTED_MACRO +# endif /* defined (TAO_EXPORT_NESTED_MACRO) */ +# define TAO_EXPORT_NESTED_MACRO TAO_PortableServer_Export +#endif /* TAO_EXPORT_NESTED_CLASSES */ + +#if defined(_MSC_VER) +#if (_MSC_VER >= 1200) +#pragma warning(push) +#endif /* _MSC_VER >= 1200 */ +#pragma warning(disable:4250) +#endif /* _MSC_VER */ + +TAO_NAMESPACE ImplementationRepository +{ + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVEROBJECT___PTR_CH_) +#define _IMPLEMENTATIONREPOSITORY_SERVEROBJECT___PTR_CH_ + + class ServerObject; + typedef ServerObject *ServerObject_ptr; + +#endif /* end #if !defined */ + + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVEROBJECT___VAR_CH_) +#define _IMPLEMENTATIONREPOSITORY_SERVEROBJECT___VAR_CH_ + + class TAO_PortableServer_Export ServerObject_var : public TAO_Base_var + { + public: + ServerObject_var (void); // default constructor + ServerObject_var (ServerObject_ptr); + ServerObject_var (const ServerObject_var &); // copy constructor + ~ServerObject_var (void); // destructor + + ServerObject_var &operator= (ServerObject_ptr); + ServerObject_var &operator= (const ServerObject_var &); + ServerObject_ptr operator-> (void) const; + + operator const ServerObject_ptr &() const; + operator ServerObject_ptr &(); + // in, inout, out, _retn + ServerObject_ptr in (void) const; + ServerObject_ptr &inout (void); + ServerObject_ptr &out (void); + ServerObject_ptr _retn (void); + ServerObject_ptr ptr (void) const; + + private: + ServerObject_ptr ptr_; + // Unimplemented - prevents widening assignment. + ServerObject_var (const TAO_Base_var &rhs); + ServerObject_var &operator= (const TAO_Base_var &rhs); + }; + + +#endif /* end #if !defined */ + + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVEROBJECT___OUT_CH_) +#define _IMPLEMENTATIONREPOSITORY_SERVEROBJECT___OUT_CH_ + + class TAO_PortableServer_Export ServerObject_out + { + public: + ServerObject_out (ServerObject_ptr &); + ServerObject_out (ServerObject_var &); + ServerObject_out (const ServerObject_out &); + ServerObject_out &operator= (const ServerObject_out &); + ServerObject_out &operator= (const ServerObject_var &); + ServerObject_out &operator= (ServerObject_ptr); + operator ServerObject_ptr &(); + ServerObject_ptr &ptr (void); + ServerObject_ptr operator-> (void); + + private: + ServerObject_ptr &ptr_; + }; + + +#endif /* end #if !defined */ + + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVEROBJECT_CH_) +#define _IMPLEMENTATIONREPOSITORY_SERVEROBJECT_CH_ + +class TAO_PortableServer_Export ServerObject : public virtual ACE_CORBA_1 (Object) + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef ServerObject_ptr _ptr_type; + typedef ServerObject_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations + static ServerObject_ptr _duplicate (ServerObject_ptr obj); + static ServerObject_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &env = + TAO_default_environment () + ); + static ServerObject_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &env = + TAO_default_environment () + ); + static ServerObject_ptr _nil (void) + { + return (ServerObject_ptr)0; + } + + static void _tao_any_destructor (void*); + + virtual void ping ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + virtual void shutdown ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + virtual CORBA::Boolean _is_a ( + const CORBA::Char *type_id, + CORBA::Environment &env = + TAO_default_environment () + ); + virtual const char* _interface_repository_id (void) const; + + protected: + ServerObject (void); + ServerObject (TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0 + ); + virtual ~ServerObject (void); + private: + ServerObject (const ServerObject &); + void operator= (const ServerObject &); +}; + +class TAO_ImplementationRepository_ServerObject_Default_Proxy_Factory +{ +public: + + TAO_ImplementationRepository_ServerObject_Default_Proxy_Factory (int register_proxy_factory = 1); + + virtual ~TAO_ImplementationRepository_ServerObject_Default_Proxy_Factory (void); + + virtual ServerObject_ptr create_proxy ( + ServerObject_ptr proxy, + CORBA::Environment &env = + TAO_default_environment () + ); +}; + +class TAO_ImplementationRepository_ServerObject_Proxy_Factory_Adapter +{ +public: + + friend class TAO_Singleton<TAO_ImplementationRepository_ServerObject_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>; + + int register_proxy_factory ( + TAO_ImplementationRepository_ServerObject_Default_Proxy_Factory *df, + CORBA::Environment &env = + TAO_default_environment () + ); + + int unregister_proxy_factory ( + CORBA::Environment &env = + TAO_default_environment () + ); + + ServerObject_ptr create_proxy ( + ServerObject_ptr proxy, + CORBA::Environment &env = + TAO_default_environment () + ); + +protected: + TAO_ImplementationRepository_ServerObject_Proxy_Factory_Adapter (void); + ~TAO_ImplementationRepository_ServerObject_Proxy_Factory_Adapter (void); + TAO_ImplementationRepository_ServerObject_Proxy_Factory_Adapter &operator= ( + const TAO_ImplementationRepository_ServerObject_Proxy_Factory_Adapter & + ); + TAO_ImplementationRepository_ServerObject_Default_Proxy_Factory *proxy_factory_; + int delete_proxy_factory_; + ACE_SYNCH_RECURSIVE_MUTEX lock_; + }; + + typedef TAO_Singleton<TAO_ImplementationRepository_ServerObject_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_ImplementationRepository_ServerObject_PROXY_FACTORY_ADAPTER; + class TAO_ImplementationRepository_ServerObject_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (ImplementationRepository, ServerObject) + { + public: + TAO_ImplementationRepository_ServerObject_Smart_Proxy_Base (::ImplementationRepository::ServerObject_ptr proxy); + ~TAO_ImplementationRepository_ServerObject_Smart_Proxy_Base (void); + virtual void ping ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + virtual void shutdown ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +private: + ::ImplementationRepository::ServerObject_var base_proxy_; +}; + + +#endif /* end #if !defined */ + +TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ServerObject; + +struct EnvironmentVariable; +class EnvironmentVariable_var; + +struct TAO_PortableServer_Export EnvironmentVariable +{ + +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef EnvironmentVariable_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + static void _tao_any_destructor (void*); + + TAO_String_Manager name; + TAO_String_Manager value; +}; + +class TAO_PortableServer_Export EnvironmentVariable_var +{ +public: + EnvironmentVariable_var (void); // default constructor + EnvironmentVariable_var (EnvironmentVariable *); + EnvironmentVariable_var (const EnvironmentVariable_var &); // copy constructor + ~EnvironmentVariable_var (void); // destructor + + EnvironmentVariable_var &operator= (EnvironmentVariable *); + EnvironmentVariable_var &operator= (const EnvironmentVariable_var &); + EnvironmentVariable *operator-> (void); + const EnvironmentVariable *operator-> (void) const; + + operator const EnvironmentVariable &() const; + operator EnvironmentVariable &(); + operator EnvironmentVariable &() const; + operator EnvironmentVariable *&(); // variable-size types only + + // in, inout, out, _retn + const EnvironmentVariable &in (void) const; + EnvironmentVariable &inout (void); + EnvironmentVariable *&out (void); + EnvironmentVariable *_retn (void); + EnvironmentVariable *ptr (void) const; + +private: + EnvironmentVariable *ptr_; +}; + +class TAO_PortableServer_Export EnvironmentVariable_out +{ +public: + EnvironmentVariable_out (EnvironmentVariable *&); + EnvironmentVariable_out (EnvironmentVariable_var &); + EnvironmentVariable_out (const EnvironmentVariable_out &); + EnvironmentVariable_out &operator= (const EnvironmentVariable_out &); + EnvironmentVariable_out &operator= (EnvironmentVariable *); + operator EnvironmentVariable *&(); + EnvironmentVariable *&ptr (void); + EnvironmentVariable *operator-> (void); + +private: + EnvironmentVariable *&ptr_; + // assignment from T_var not allowed + void operator= (const EnvironmentVariable_var &); +}; + +TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_EnvironmentVariable; + +typedef char * Address; +typedef CORBA::String_var Address_var; +typedef CORBA::String_out Address_out; +TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Address; + + +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +#if !defined (__TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CH_) +#define __TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CH_ + + class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList : public TAO_Unbounded_Base_Sequence + { + public: + // = Initialization and termination methods. + + _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList (void); // Default constructor. + _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList (CORBA::ULong maximum); + _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList (CORBA::ULong maximum, + CORBA::ULong length, + EnvironmentVariable *data, + CORBA::Boolean release = 0); + _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList (const _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList &rhs); + _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList &operator= (const _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList &rhs); + virtual ~_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList (void); // Dtor. + // = Accessors. + EnvironmentVariable &operator[] (CORBA::ULong i); + const EnvironmentVariable &operator[] (CORBA::ULong i) const; + // = Static operations. + static EnvironmentVariable *allocbuf (CORBA::ULong size); + static void freebuf (EnvironmentVariable *buffer); + virtual void _allocate_buffer (CORBA::ULong length); + virtual void _deallocate_buffer (void); + // Implement the TAO_Base_Sequence methods (see Sequence.h) + + EnvironmentVariable *get_buffer (CORBA::Boolean orphan = 0); + const EnvironmentVariable *get_buffer (void) const; + void replace (CORBA::ULong max, + CORBA::ULong length, + EnvironmentVariable *data, + CORBA::Boolean release); + }; + +#endif /* end #if !defined */ + + +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +#if !defined (_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CH_) +#define _IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CH_ + +class EnvironmentList; +class EnvironmentList_var; + +// ************************************************************* +// EnvironmentList +// ************************************************************* + +class TAO_PortableServer_Export EnvironmentList : public +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList +#else /* TAO_USE_SEQUENCE_TEMPLATES */ + TAO_Unbounded_Sequence<EnvironmentVariable> +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ +{ +public: + EnvironmentList (void); // default ctor + EnvironmentList (CORBA::ULong max); // uses max size + EnvironmentList ( + CORBA::ULong max, + CORBA::ULong length, + EnvironmentVariable *buffer, + CORBA::Boolean release=0 + ); + EnvironmentList (const EnvironmentList &); // copy ctor + ~EnvironmentList (void); + static void _tao_any_destructor (void*); + +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef EnvironmentList_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + +}; + +#endif /* end #if !defined */ + + +#if !defined (_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST___VAR_CH_) +#define _IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST___VAR_CH_ + +// ************************************************************* +// class ImplementationRepository::EnvironmentList_var +// ************************************************************* + +class TAO_PortableServer_Export EnvironmentList_var +{ +public: + EnvironmentList_var (void); // default constructor + EnvironmentList_var (EnvironmentList *); + EnvironmentList_var (const EnvironmentList_var &); // copy constructor + ~EnvironmentList_var (void); // destructor + + EnvironmentList_var &operator= (EnvironmentList *); + EnvironmentList_var &operator= (const EnvironmentList_var &); + EnvironmentList *operator-> (void); + const EnvironmentList *operator-> (void) const; + + operator const EnvironmentList &() const; + operator EnvironmentList &(); + operator EnvironmentList &() const; + operator EnvironmentList *&(); // variable-size base types only + + EnvironmentVariable &operator[] (CORBA::ULong index); + // in, inout, out, _retn + const EnvironmentList &in (void) const; + EnvironmentList &inout (void); + EnvironmentList *&out (void); + EnvironmentList *_retn (void); + EnvironmentList *ptr (void) const; + +private: + EnvironmentList *ptr_; +}; + + +#endif /* end #if !defined */ + + +#if !defined (_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST___OUT_CH_) +#define _IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST___OUT_CH_ + +class TAO_PortableServer_Export EnvironmentList_out +{ +public: + EnvironmentList_out (EnvironmentList *&); + EnvironmentList_out (EnvironmentList_var &); + EnvironmentList_out (const EnvironmentList_out &); + EnvironmentList_out &operator= (const EnvironmentList_out &); + EnvironmentList_out &operator= (EnvironmentList *); + operator EnvironmentList *&(); + EnvironmentList *&ptr (void); + EnvironmentList *operator-> (void); + EnvironmentVariable &operator[] (CORBA::ULong index); + +private: + EnvironmentList *&ptr_; + // assignment from T_var not allowed + void operator= (const EnvironmentList_var &); +}; + + +#endif /* end #if !defined */ + +TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_EnvironmentList; + +enum ActivationMode +{ + NORMAL, + MANUAL, + PER_CLIENT, + AUTO_START +}; +typedef ActivationMode &ActivationMode_out; +TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ActivationMode; + +struct StartupOptions; +class StartupOptions_var; + +struct TAO_PortableServer_Export StartupOptions +{ + +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef StartupOptions_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + static void _tao_any_destructor (void*); + + TAO_String_Manager command_line; + ACE_NESTED_CLASS (ImplementationRepository, EnvironmentList) environment; + TAO_String_Manager working_directory; + ACE_NESTED_CLASS (ImplementationRepository, ActivationMode) activation; +}; + +class TAO_PortableServer_Export StartupOptions_var +{ +public: + StartupOptions_var (void); // default constructor + StartupOptions_var (StartupOptions *); + StartupOptions_var (const StartupOptions_var &); // copy constructor + ~StartupOptions_var (void); // destructor + + StartupOptions_var &operator= (StartupOptions *); + StartupOptions_var &operator= (const StartupOptions_var &); + StartupOptions *operator-> (void); + const StartupOptions *operator-> (void) const; + + operator const StartupOptions &() const; + operator StartupOptions &(); + operator StartupOptions &() const; + operator StartupOptions *&(); // variable-size types only + + // in, inout, out, _retn + const StartupOptions &in (void) const; + StartupOptions &inout (void); + StartupOptions *&out (void); + StartupOptions *_retn (void); + StartupOptions *ptr (void) const; + +private: + StartupOptions *ptr_; +}; + +class TAO_PortableServer_Export StartupOptions_out +{ +public: + StartupOptions_out (StartupOptions *&); + StartupOptions_out (StartupOptions_var &); + StartupOptions_out (const StartupOptions_out &); + StartupOptions_out &operator= (const StartupOptions_out &); + StartupOptions_out &operator= (StartupOptions *); + operator StartupOptions *&(); + StartupOptions *&ptr (void); + StartupOptions *operator-> (void); + +private: + StartupOptions *&ptr_; + // assignment from T_var not allowed + void operator= (const StartupOptions_var &); +}; + +TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_StartupOptions; + +struct ServerInformation; +class ServerInformation_var; + +struct TAO_PortableServer_Export ServerInformation +{ + +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef ServerInformation_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + static void _tao_any_destructor (void*); + + TAO_String_Manager logical_server; + TAO_String_Manager server; + ACE_NESTED_CLASS (ImplementationRepository, StartupOptions) startup; + TAO_String_Manager location; +}; + +class TAO_PortableServer_Export ServerInformation_var +{ +public: + ServerInformation_var (void); // default constructor + ServerInformation_var (ServerInformation *); + ServerInformation_var (const ServerInformation_var &); // copy constructor + ~ServerInformation_var (void); // destructor + + ServerInformation_var &operator= (ServerInformation *); + ServerInformation_var &operator= (const ServerInformation_var &); + ServerInformation *operator-> (void); + const ServerInformation *operator-> (void) const; + + operator const ServerInformation &() const; + operator ServerInformation &(); + operator ServerInformation &() const; + operator ServerInformation *&(); // variable-size types only + + // in, inout, out, _retn + const ServerInformation &in (void) const; + ServerInformation &inout (void); + ServerInformation *&out (void); + ServerInformation *_retn (void); + ServerInformation *ptr (void) const; + +private: + ServerInformation *ptr_; +}; + +class TAO_PortableServer_Export ServerInformation_out +{ +public: + ServerInformation_out (ServerInformation *&); + ServerInformation_out (ServerInformation_var &); + ServerInformation_out (const ServerInformation_out &); + ServerInformation_out &operator= (const ServerInformation_out &); + ServerInformation_out &operator= (ServerInformation *); + operator ServerInformation *&(); + ServerInformation *&ptr (void); + ServerInformation *operator-> (void); + +private: + ServerInformation *&ptr_; + // assignment from T_var not allowed + void operator= (const ServerInformation_var &); +}; + +TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ServerInformation; + + +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +#if !defined (__TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CH_) +#define __TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CH_ + + class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList : public TAO_Unbounded_Base_Sequence + { + public: + // = Initialization and termination methods. + + _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList (void); // Default constructor. + _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList (CORBA::ULong maximum); + _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList (CORBA::ULong maximum, + CORBA::ULong length, + ServerInformation *data, + CORBA::Boolean release = 0); + _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList (const _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList &rhs); + _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList &operator= (const _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList &rhs); + virtual ~_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList (void); // Dtor. + // = Accessors. + ServerInformation &operator[] (CORBA::ULong i); + const ServerInformation &operator[] (CORBA::ULong i) const; + // = Static operations. + static ServerInformation *allocbuf (CORBA::ULong size); + static void freebuf (ServerInformation *buffer); + virtual void _allocate_buffer (CORBA::ULong length); + virtual void _deallocate_buffer (void); + // Implement the TAO_Base_Sequence methods (see Sequence.h) + + ServerInformation *get_buffer (CORBA::Boolean orphan = 0); + const ServerInformation *get_buffer (void) const; + void replace (CORBA::ULong max, + CORBA::ULong length, + ServerInformation *data, + CORBA::Boolean release); + }; + +#endif /* end #if !defined */ + + +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CH_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CH_ + +class ServerInformationList; +class ServerInformationList_var; + +// ************************************************************* +// ServerInformationList +// ************************************************************* + +class TAO_PortableServer_Export ServerInformationList : public +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList +#else /* TAO_USE_SEQUENCE_TEMPLATES */ + TAO_Unbounded_Sequence<ServerInformation> +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ +{ +public: + ServerInformationList (void); // default ctor + ServerInformationList (CORBA::ULong max); // uses max size + ServerInformationList ( + CORBA::ULong max, + CORBA::ULong length, + ServerInformation *buffer, + CORBA::Boolean release=0 + ); + ServerInformationList (const ServerInformationList &); // copy ctor + ~ServerInformationList (void); + static void _tao_any_destructor (void*); + +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef ServerInformationList_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + +}; + +#endif /* end #if !defined */ + + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST___VAR_CH_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST___VAR_CH_ + +// ************************************************************* +// class ImplementationRepository::ServerInformationList_var +// ************************************************************* + +class TAO_PortableServer_Export ServerInformationList_var +{ +public: + ServerInformationList_var (void); // default constructor + ServerInformationList_var (ServerInformationList *); + ServerInformationList_var (const ServerInformationList_var &); // copy constructor + ~ServerInformationList_var (void); // destructor + + ServerInformationList_var &operator= (ServerInformationList *); + ServerInformationList_var &operator= (const ServerInformationList_var &); + ServerInformationList *operator-> (void); + const ServerInformationList *operator-> (void) const; + + operator const ServerInformationList &() const; + operator ServerInformationList &(); + operator ServerInformationList &() const; + operator ServerInformationList *&(); // variable-size base types only + + ServerInformation &operator[] (CORBA::ULong index); + // in, inout, out, _retn + const ServerInformationList &in (void) const; + ServerInformationList &inout (void); + ServerInformationList *&out (void); + ServerInformationList *_retn (void); + ServerInformationList *ptr (void) const; + +private: + ServerInformationList *ptr_; +}; + + +#endif /* end #if !defined */ + + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST___OUT_CH_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST___OUT_CH_ + +class TAO_PortableServer_Export ServerInformationList_out +{ +public: + ServerInformationList_out (ServerInformationList *&); + ServerInformationList_out (ServerInformationList_var &); + ServerInformationList_out (const ServerInformationList_out &); + ServerInformationList_out &operator= (const ServerInformationList_out &); + ServerInformationList_out &operator= (ServerInformationList *); + operator ServerInformationList *&(); + ServerInformationList *&ptr (void); + ServerInformationList *operator-> (void); + ServerInformation &operator[] (CORBA::ULong index); + +private: + ServerInformationList *&ptr_; + // assignment from T_var not allowed + void operator= (const ServerInformationList_var &); +}; + + +#endif /* end #if !defined */ + +TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ServerInformationList; + +class ServerInformationIterator; + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR___PTR_CH_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR___PTR_CH_ + +typedef ServerInformationIterator *ServerInformationIterator_ptr; + +#endif /* end #if !defined */ + + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR___VAR_CH_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR___VAR_CH_ + +class TAO_PortableServer_Export ServerInformationIterator_var : public TAO_Base_var +{ +public: + ServerInformationIterator_var (void); // default constructor + ServerInformationIterator_var (ServerInformationIterator_ptr); + ServerInformationIterator_var (const ServerInformationIterator_var &); // copy constructor + ~ServerInformationIterator_var (void); // destructor + + ServerInformationIterator_var &operator= (ServerInformationIterator_ptr); + ServerInformationIterator_var &operator= (const ServerInformationIterator_var &); + ServerInformationIterator_ptr operator-> (void) const; + + operator const ServerInformationIterator_ptr &() const; + operator ServerInformationIterator_ptr &(); + // in, inout, out, _retn + ServerInformationIterator_ptr in (void) const; + ServerInformationIterator_ptr &inout (void); + ServerInformationIterator_ptr &out (void); + ServerInformationIterator_ptr _retn (void); + ServerInformationIterator_ptr ptr (void) const; + +private: + ServerInformationIterator_ptr ptr_; + // Unimplemented - prevents widening assignment. + ServerInformationIterator_var (const TAO_Base_var &rhs); + ServerInformationIterator_var &operator= (const TAO_Base_var &rhs); +}; + + +#endif /* end #if !defined */ + + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR___OUT_CH_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR___OUT_CH_ + +class TAO_PortableServer_Export ServerInformationIterator_out +{ +public: + ServerInformationIterator_out (ServerInformationIterator_ptr &); + ServerInformationIterator_out (ServerInformationIterator_var &); + ServerInformationIterator_out (const ServerInformationIterator_out &); + ServerInformationIterator_out &operator= (const ServerInformationIterator_out &); + ServerInformationIterator_out &operator= (const ServerInformationIterator_var &); + ServerInformationIterator_out &operator= (ServerInformationIterator_ptr); + operator ServerInformationIterator_ptr &(); + ServerInformationIterator_ptr &ptr (void); + ServerInformationIterator_ptr operator-> (void); + +private: + ServerInformationIterator_ptr &ptr_; +}; + + +#endif /* end #if !defined */ + + +#if !defined (_IMPLEMENTATIONREPOSITORY_ADMINISTRATION___PTR_CH_) +#define _IMPLEMENTATIONREPOSITORY_ADMINISTRATION___PTR_CH_ + +class Administration; +typedef Administration *Administration_ptr; + +#endif /* end #if !defined */ + + +#if !defined (_IMPLEMENTATIONREPOSITORY_ADMINISTRATION___VAR_CH_) +#define _IMPLEMENTATIONREPOSITORY_ADMINISTRATION___VAR_CH_ + +class TAO_PortableServer_Export Administration_var : public TAO_Base_var +{ +public: + Administration_var (void); // default constructor + Administration_var (Administration_ptr); + Administration_var (const Administration_var &); // copy constructor + ~Administration_var (void); // destructor + + Administration_var &operator= (Administration_ptr); + Administration_var &operator= (const Administration_var &); + Administration_ptr operator-> (void) const; + + operator const Administration_ptr &() const; + operator Administration_ptr &(); + // in, inout, out, _retn + Administration_ptr in (void) const; + Administration_ptr &inout (void); + Administration_ptr &out (void); + Administration_ptr _retn (void); + Administration_ptr ptr (void) const; + +private: + Administration_ptr ptr_; + // Unimplemented - prevents widening assignment. + Administration_var (const TAO_Base_var &rhs); + Administration_var &operator= (const TAO_Base_var &rhs); +}; + + +#endif /* end #if !defined */ + + +#if !defined (_IMPLEMENTATIONREPOSITORY_ADMINISTRATION___OUT_CH_) +#define _IMPLEMENTATIONREPOSITORY_ADMINISTRATION___OUT_CH_ + +class TAO_PortableServer_Export Administration_out +{ +public: + Administration_out (Administration_ptr &); + Administration_out (Administration_var &); + Administration_out (const Administration_out &); + Administration_out &operator= (const Administration_out &); + Administration_out &operator= (const Administration_var &); + Administration_out &operator= (Administration_ptr); + operator Administration_ptr &(); + Administration_ptr &ptr (void); + Administration_ptr operator-> (void); + +private: + Administration_ptr &ptr_; +}; + + +#endif /* end #if !defined */ + + +#if !defined (_IMPLEMENTATIONREPOSITORY_ADMINISTRATION_CH_) +#define _IMPLEMENTATIONREPOSITORY_ADMINISTRATION_CH_ + +class TAO_PortableServer_Export Administration : public virtual ACE_CORBA_1 (Object) +{ +public: +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef Administration_ptr _ptr_type; + typedef Administration_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations + static Administration_ptr _duplicate (Administration_ptr obj); + static Administration_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &env = + TAO_default_environment () + ); + static Administration_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &env = + TAO_default_environment () + ); + static Administration_ptr _nil (void) + { + return (Administration_ptr)0; + } + + static void _tao_any_destructor (void*); + +#if !defined (_IMPLEMENTATIONREPOSITORY_ADMINISTRATION_ALREADYREGISTERED_CH_) +#define _IMPLEMENTATIONREPOSITORY_ADMINISTRATION_ALREADYREGISTERED_CH_ + + class TAO_PortableServer_Export AlreadyRegistered : public CORBA::UserException + { + public: + + AlreadyRegistered (void); // default ctor + AlreadyRegistered (const AlreadyRegistered &); // copy ctor + ~AlreadyRegistered (void); + static void _tao_any_destructor (void*); + AlreadyRegistered &operator= (const AlreadyRegistered &); + + + virtual void _raise (void); + + virtual void _tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &) const; + virtual void _tao_decode ( + TAO_InputCDR &, + CORBA::Environment &); + + static AlreadyRegistered *_downcast (CORBA::Exception *); + + + // = TAO extension + static CORBA::Exception *_alloc (void); + virtual CORBA::TypeCode_ptr _type (void) const; + + }; // exception ImplementationRepository::Administration::AlreadyRegistered + + static CORBA::TypeCode_ptr _tc_AlreadyRegistered; + + +#endif /* end #if !defined */ + +#if !defined (_IMPLEMENTATIONREPOSITORY_ADMINISTRATION_CANNOTACTIVATE_CH_) +#define _IMPLEMENTATIONREPOSITORY_ADMINISTRATION_CANNOTACTIVATE_CH_ + + class TAO_PortableServer_Export CannotActivate : public CORBA::UserException + { + public: + + TAO_String_Manager reason; + + CannotActivate (void); // default ctor + CannotActivate (const CannotActivate &); // copy ctor + ~CannotActivate (void); + static void _tao_any_destructor (void*); + CannotActivate &operator= (const CannotActivate &); + + + virtual void _raise (void); + + virtual void _tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &) const; + virtual void _tao_decode ( + TAO_InputCDR &, + CORBA::Environment &); + + static CannotActivate *_downcast (CORBA::Exception *); + + CannotActivate ( + const char * _tao_reason + ); + + // = TAO extension + static CORBA::Exception *_alloc (void); + virtual CORBA::TypeCode_ptr _type (void) const; + + }; // exception ImplementationRepository::Administration::CannotActivate + + static CORBA::TypeCode_ptr _tc_CannotActivate; + + +#endif /* end #if !defined */ + +#if !defined (_IMPLEMENTATIONREPOSITORY_ADMINISTRATION_NOTFOUND_CH_) +#define _IMPLEMENTATIONREPOSITORY_ADMINISTRATION_NOTFOUND_CH_ + + class TAO_PortableServer_Export NotFound : public CORBA::UserException + { + public: + + NotFound (void); // default ctor + NotFound (const NotFound &); // copy ctor + ~NotFound (void); + static void _tao_any_destructor (void*); + NotFound &operator= (const NotFound &); + + + virtual void _raise (void); + + virtual void _tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &) const; + virtual void _tao_decode ( + TAO_InputCDR &, + CORBA::Environment &); + + static NotFound *_downcast (CORBA::Exception *); + + + // = TAO extension + static CORBA::Exception *_alloc (void); + virtual CORBA::TypeCode_ptr _type (void) const; + + }; // exception ImplementationRepository::Administration::NotFound + + static CORBA::TypeCode_ptr _tc_NotFound; + + +#endif /* end #if !defined */ + + virtual void activate_server ( + const char * server, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ImplementationRepository::Administration::NotFound, + ImplementationRepository::Administration::CannotActivate + )); + + virtual void register_server ( + const char * server, + const ImplementationRepository::StartupOptions & options, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ImplementationRepository::Administration::AlreadyRegistered + )); + + virtual void reregister_server ( + const char * server, + const ImplementationRepository::StartupOptions & options, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + virtual void remove_server ( + const char * server, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ImplementationRepository::Administration::NotFound + )); + + virtual void shutdown_server ( + const char * server, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ImplementationRepository::Administration::NotFound + )); + + virtual char * server_is_running ( + const char * server, + const char * addr, + ImplementationRepository::ServerObject_ptr server_object, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ImplementationRepository::Administration::NotFound + )); + + virtual void server_is_shutting_down ( + const char * server, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ImplementationRepository::Administration::NotFound + )); + + virtual void find ( + const char * server, + ImplementationRepository::ServerInformation_out info, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ImplementationRepository::Administration::NotFound + )); + + virtual void list ( + CORBA::ULong how_many, + ImplementationRepository::ServerInformationList_out server_list, + ImplementationRepository::ServerInformationIterator_out server_iterator, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + virtual CORBA::Boolean _is_a ( + const CORBA::Char *type_id, + CORBA::Environment &env = + TAO_default_environment () + ); + virtual const char* _interface_repository_id (void) const; + +protected: + Administration (void); + Administration (TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0 + ); + virtual ~Administration (void); +private: + Administration (const Administration &); + void operator= (const Administration &); +}; + +class TAO_ImplementationRepository_Administration_Default_Proxy_Factory +{ +public: + + TAO_ImplementationRepository_Administration_Default_Proxy_Factory (int register_proxy_factory = 1); + + virtual ~TAO_ImplementationRepository_Administration_Default_Proxy_Factory (void); + + virtual Administration_ptr create_proxy ( + Administration_ptr proxy, + CORBA::Environment &env = + TAO_default_environment () + ); +}; + +class TAO_ImplementationRepository_Administration_Proxy_Factory_Adapter +{ +public: + + friend class TAO_Singleton<TAO_ImplementationRepository_Administration_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>; + + int register_proxy_factory ( + TAO_ImplementationRepository_Administration_Default_Proxy_Factory *df, + CORBA::Environment &env = + TAO_default_environment () + ); + + int unregister_proxy_factory ( + CORBA::Environment &env = + TAO_default_environment () + ); + + Administration_ptr create_proxy ( + Administration_ptr proxy, + CORBA::Environment &env = + TAO_default_environment () + ); + +protected: + TAO_ImplementationRepository_Administration_Proxy_Factory_Adapter (void); + ~TAO_ImplementationRepository_Administration_Proxy_Factory_Adapter (void); + TAO_ImplementationRepository_Administration_Proxy_Factory_Adapter &operator= ( + const TAO_ImplementationRepository_Administration_Proxy_Factory_Adapter & + ); + TAO_ImplementationRepository_Administration_Default_Proxy_Factory *proxy_factory_; + int delete_proxy_factory_; + ACE_SYNCH_RECURSIVE_MUTEX lock_; + }; + + typedef TAO_Singleton<TAO_ImplementationRepository_Administration_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_ImplementationRepository_Administration_PROXY_FACTORY_ADAPTER; + class TAO_ImplementationRepository_Administration_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (ImplementationRepository, Administration) + { + public: + TAO_ImplementationRepository_Administration_Smart_Proxy_Base (::ImplementationRepository::Administration_ptr proxy); + ~TAO_ImplementationRepository_Administration_Smart_Proxy_Base (void); + virtual void activate_server ( + const char * server, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ImplementationRepository::Administration::NotFound, + ImplementationRepository::Administration::CannotActivate + )); + + virtual void register_server ( + const char * server, + const ImplementationRepository::StartupOptions & options, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ImplementationRepository::Administration::AlreadyRegistered + )); + + virtual void reregister_server ( + const char * server, + const ImplementationRepository::StartupOptions & options, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + virtual void remove_server ( + const char * server, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ImplementationRepository::Administration::NotFound + )); + + virtual void shutdown_server ( + const char * server, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ImplementationRepository::Administration::NotFound + )); + + virtual char * server_is_running ( + const char * server, + const char * addr, + ImplementationRepository::ServerObject_ptr server_object, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ImplementationRepository::Administration::NotFound + )); + + virtual void server_is_shutting_down ( + const char * server, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ImplementationRepository::Administration::NotFound + )); + + virtual void find ( + const char * server, + ImplementationRepository::ServerInformation_out info, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + ImplementationRepository::Administration::NotFound + )); + + virtual void list ( + CORBA::ULong how_many, + ImplementationRepository::ServerInformationList_out server_list, + ImplementationRepository::ServerInformationIterator_out server_iterator, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +private: + ::ImplementationRepository::Administration_var base_proxy_; +}; + + +#endif /* end #if !defined */ + +TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Administration; + + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR___PTR_CH_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR___PTR_CH_ + +class ServerInformationIterator; +typedef ServerInformationIterator *ServerInformationIterator_ptr; + +#endif /* end #if !defined */ + + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR___VAR_CH_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR___VAR_CH_ + +class TAO_PortableServer_Export ServerInformationIterator_var : public TAO_Base_var +{ +public: + ServerInformationIterator_var (void); // default constructor + ServerInformationIterator_var (ServerInformationIterator_ptr); + ServerInformationIterator_var (const ServerInformationIterator_var &); // copy constructor + ~ServerInformationIterator_var (void); // destructor + + ServerInformationIterator_var &operator= (ServerInformationIterator_ptr); + ServerInformationIterator_var &operator= (const ServerInformationIterator_var &); + ServerInformationIterator_ptr operator-> (void) const; + + operator const ServerInformationIterator_ptr &() const; + operator ServerInformationIterator_ptr &(); + // in, inout, out, _retn + ServerInformationIterator_ptr in (void) const; + ServerInformationIterator_ptr &inout (void); + ServerInformationIterator_ptr &out (void); + ServerInformationIterator_ptr _retn (void); + ServerInformationIterator_ptr ptr (void) const; + +private: + ServerInformationIterator_ptr ptr_; + // Unimplemented - prevents widening assignment. + ServerInformationIterator_var (const TAO_Base_var &rhs); + ServerInformationIterator_var &operator= (const TAO_Base_var &rhs); +}; + + +#endif /* end #if !defined */ + + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR___OUT_CH_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR___OUT_CH_ + +class TAO_PortableServer_Export ServerInformationIterator_out +{ +public: + ServerInformationIterator_out (ServerInformationIterator_ptr &); + ServerInformationIterator_out (ServerInformationIterator_var &); + ServerInformationIterator_out (const ServerInformationIterator_out &); + ServerInformationIterator_out &operator= (const ServerInformationIterator_out &); + ServerInformationIterator_out &operator= (const ServerInformationIterator_var &); + ServerInformationIterator_out &operator= (ServerInformationIterator_ptr); + operator ServerInformationIterator_ptr &(); + ServerInformationIterator_ptr &ptr (void); + ServerInformationIterator_ptr operator-> (void); + +private: + ServerInformationIterator_ptr &ptr_; +}; + + +#endif /* end #if !defined */ + + +#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR_CH_) +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR_CH_ + +class TAO_PortableServer_Export ServerInformationIterator : public virtual ACE_CORBA_1 (Object) +{ +public: +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef ServerInformationIterator_ptr _ptr_type; + typedef ServerInformationIterator_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations + static ServerInformationIterator_ptr _duplicate (ServerInformationIterator_ptr obj); + static ServerInformationIterator_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &env = + TAO_default_environment () + ); + static ServerInformationIterator_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &env = + TAO_default_environment () + ); + static ServerInformationIterator_ptr _nil (void) + { + return (ServerInformationIterator_ptr)0; + } + + static void _tao_any_destructor (void*); + + virtual CORBA::Boolean next_n ( + CORBA::ULong how_many, + ImplementationRepository::ServerInformationList_out server_list, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + virtual void destroy ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + virtual CORBA::Boolean _is_a ( + const CORBA::Char *type_id, + CORBA::Environment &env = + TAO_default_environment () + ); + virtual const char* _interface_repository_id (void) const; + +protected: + ServerInformationIterator (void); + ServerInformationIterator (TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0 + ); + virtual ~ServerInformationIterator (void); +private: + ServerInformationIterator (const ServerInformationIterator &); + void operator= (const ServerInformationIterator &); +}; + +class TAO_ImplementationRepository_ServerInformationIterator_Default_Proxy_Factory +{ +public: + + TAO_ImplementationRepository_ServerInformationIterator_Default_Proxy_Factory (int register_proxy_factory = 1); + + virtual ~TAO_ImplementationRepository_ServerInformationIterator_Default_Proxy_Factory (void); + + virtual ServerInformationIterator_ptr create_proxy ( + ServerInformationIterator_ptr proxy, + CORBA::Environment &env = + TAO_default_environment () + ); +}; + +class TAO_ImplementationRepository_ServerInformationIterator_Proxy_Factory_Adapter +{ +public: + + friend class TAO_Singleton<TAO_ImplementationRepository_ServerInformationIterator_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>; + + int register_proxy_factory ( + TAO_ImplementationRepository_ServerInformationIterator_Default_Proxy_Factory *df, + CORBA::Environment &env = + TAO_default_environment () + ); + + int unregister_proxy_factory ( + CORBA::Environment &env = + TAO_default_environment () + ); + + ServerInformationIterator_ptr create_proxy ( + ServerInformationIterator_ptr proxy, + CORBA::Environment &env = + TAO_default_environment () + ); + +protected: + TAO_ImplementationRepository_ServerInformationIterator_Proxy_Factory_Adapter (void); + ~TAO_ImplementationRepository_ServerInformationIterator_Proxy_Factory_Adapter (void); + TAO_ImplementationRepository_ServerInformationIterator_Proxy_Factory_Adapter &operator= ( + const TAO_ImplementationRepository_ServerInformationIterator_Proxy_Factory_Adapter & + ); + TAO_ImplementationRepository_ServerInformationIterator_Default_Proxy_Factory *proxy_factory_; + int delete_proxy_factory_; + ACE_SYNCH_RECURSIVE_MUTEX lock_; + }; + + typedef TAO_Singleton<TAO_ImplementationRepository_ServerInformationIterator_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_ImplementationRepository_ServerInformationIterator_PROXY_FACTORY_ADAPTER; + class TAO_ImplementationRepository_ServerInformationIterator_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (ImplementationRepository, ServerInformationIterator) + { + public: + TAO_ImplementationRepository_ServerInformationIterator_Smart_Proxy_Base (::ImplementationRepository::ServerInformationIterator_ptr proxy); + ~TAO_ImplementationRepository_ServerInformationIterator_Smart_Proxy_Base (void); + virtual CORBA::Boolean next_n ( + CORBA::ULong how_many, + ImplementationRepository::ServerInformationList_out server_list, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + virtual void destroy ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +private: + ::ImplementationRepository::ServerInformationIterator_var base_proxy_; +}; + + +#endif /* end #if !defined */ + +TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ServerInformationIterator; + + +} +TAO_NAMESPACE_CLOSE // module ImplementationRepository + +extern TAO_PortableServer_Export ImplementationRepository::ServerObject_ptr (*_TAO_collocation_ImplementationRepository_ServerObject_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +// Any operators for interface ImplementationRepository::ServerObject +TAO_PortableServer_Export void operator<<= (CORBA::Any &, ImplementationRepository::ServerObject_ptr); +TAO_PortableServer_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::ServerObject *&); +TAO_PortableServer_Export void operator<<= (CORBA::Any &, const ImplementationRepository::EnvironmentVariable &); // copying version +TAO_PortableServer_Export void operator<<= (CORBA::Any &, ImplementationRepository::EnvironmentVariable*); // noncopying version +TAO_PortableServer_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::EnvironmentVariable *&); // deprecated +TAO_PortableServer_Export CORBA::Boolean operator>>= (const CORBA::Any &, const ImplementationRepository::EnvironmentVariable *&); +TAO_PortableServer_Export void operator<<= (CORBA::Any &, const ImplementationRepository::EnvironmentList &); // copying version +TAO_PortableServer_Export void operator<<= (CORBA::Any &, ImplementationRepository::EnvironmentList*); // noncopying version +TAO_PortableServer_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::EnvironmentList *&); // deprecated +TAO_PortableServer_Export CORBA::Boolean operator>>= (const CORBA::Any &, const ImplementationRepository::EnvironmentList *&); +TAO_PortableServer_Export void operator<<= (CORBA::Any &, ImplementationRepository::ActivationMode); +TAO_PortableServer_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::ActivationMode &); +TAO_PortableServer_Export void operator<<= (CORBA::Any &, const ImplementationRepository::StartupOptions &); // copying version +TAO_PortableServer_Export void operator<<= (CORBA::Any &, ImplementationRepository::StartupOptions*); // noncopying version +TAO_PortableServer_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::StartupOptions *&); // deprecated +TAO_PortableServer_Export CORBA::Boolean operator>>= (const CORBA::Any &, const ImplementationRepository::StartupOptions *&); +TAO_PortableServer_Export void operator<<= (CORBA::Any &, const ImplementationRepository::ServerInformation &); // copying version +TAO_PortableServer_Export void operator<<= (CORBA::Any &, ImplementationRepository::ServerInformation*); // noncopying version +TAO_PortableServer_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::ServerInformation *&); // deprecated +TAO_PortableServer_Export CORBA::Boolean operator>>= (const CORBA::Any &, const ImplementationRepository::ServerInformation *&); +TAO_PortableServer_Export void operator<<= (CORBA::Any &, const ImplementationRepository::ServerInformationList &); // copying version +TAO_PortableServer_Export void operator<<= (CORBA::Any &, ImplementationRepository::ServerInformationList*); // noncopying version +TAO_PortableServer_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::ServerInformationList *&); // deprecated +TAO_PortableServer_Export CORBA::Boolean operator>>= (const CORBA::Any &, const ImplementationRepository::ServerInformationList *&); +extern TAO_PortableServer_Export ImplementationRepository::Administration_ptr (*_TAO_collocation_ImplementationRepository_Administration_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +// Any operators for interface ImplementationRepository::Administration +TAO_PortableServer_Export void operator<<= (CORBA::Any &, ImplementationRepository::Administration_ptr); +TAO_PortableServer_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::Administration *&); +TAO_PortableServer_Export void operator<<= (CORBA::Any &, const ImplementationRepository::Administration::AlreadyRegistered &); // copying version +TAO_PortableServer_Export void operator<<= (CORBA::Any &, ImplementationRepository::Administration::AlreadyRegistered*); // noncopying version +TAO_PortableServer_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::Administration::AlreadyRegistered *&); // deprecated +TAO_PortableServer_Export CORBA::Boolean operator>>= (const CORBA::Any &, const ImplementationRepository::Administration::AlreadyRegistered *&); +TAO_PortableServer_Export void operator<<= (CORBA::Any &, const ImplementationRepository::Administration::CannotActivate &); // copying version +TAO_PortableServer_Export void operator<<= (CORBA::Any &, ImplementationRepository::Administration::CannotActivate*); // noncopying version +TAO_PortableServer_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::Administration::CannotActivate *&); // deprecated +TAO_PortableServer_Export CORBA::Boolean operator>>= (const CORBA::Any &, const ImplementationRepository::Administration::CannotActivate *&); +TAO_PortableServer_Export void operator<<= (CORBA::Any &, const ImplementationRepository::Administration::NotFound &); // copying version +TAO_PortableServer_Export void operator<<= (CORBA::Any &, ImplementationRepository::Administration::NotFound*); // noncopying version +TAO_PortableServer_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::Administration::NotFound *&); // deprecated +TAO_PortableServer_Export CORBA::Boolean operator>>= (const CORBA::Any &, const ImplementationRepository::Administration::NotFound *&); +extern TAO_PortableServer_Export ImplementationRepository::ServerInformationIterator_ptr (*_TAO_collocation_ImplementationRepository_ServerInformationIterator_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +// Any operators for interface ImplementationRepository::ServerInformationIterator +TAO_PortableServer_Export void operator<<= (CORBA::Any &, ImplementationRepository::ServerInformationIterator_ptr); +TAO_PortableServer_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::ServerInformationIterator *&); + +#ifndef __ACE_INLINE__ + +TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const ImplementationRepository::ServerObject_ptr ); +TAO_PortableServer_Export CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::ServerObject_ptr &); +TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const ImplementationRepository::EnvironmentVariable &); +TAO_PortableServer_Export CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::EnvironmentVariable &); + +#if !defined _TAO_CDR_OP_ImplementationRepository_EnvironmentList_H_ +#define _TAO_CDR_OP_ImplementationRepository_EnvironmentList_H_ + +TAO_PortableServer_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, + const ImplementationRepository::EnvironmentList & + ); +TAO_PortableServer_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, + ImplementationRepository::EnvironmentList & + ); + +#endif /* _TAO_CDR_OP_ImplementationRepository_EnvironmentList_H_ */ + +TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const ImplementationRepository::ActivationMode &); // +TAO_PortableServer_Export CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::ActivationMode &); +TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const ImplementationRepository::StartupOptions &); +TAO_PortableServer_Export CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::StartupOptions &); +TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const ImplementationRepository::ServerInformation &); +TAO_PortableServer_Export CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::ServerInformation &); + +#if !defined _TAO_CDR_OP_ImplementationRepository_ServerInformationList_H_ +#define _TAO_CDR_OP_ImplementationRepository_ServerInformationList_H_ + +TAO_PortableServer_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, + const ImplementationRepository::ServerInformationList & + ); +TAO_PortableServer_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, + ImplementationRepository::ServerInformationList & + ); + +#endif /* _TAO_CDR_OP_ImplementationRepository_ServerInformationList_H_ */ + +TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const ImplementationRepository::Administration_ptr ); +TAO_PortableServer_Export CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::Administration_ptr &); +TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const ImplementationRepository::Administration::AlreadyRegistered &); +TAO_PortableServer_Export CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::Administration::AlreadyRegistered &); + +# if !defined (ACE_LACKS_IOSTREAM_TOTALLY) + +TAO_PortableServer_Export ostream& operator<< (ostream &, const ImplementationRepository::Administration::AlreadyRegistered &); + +# endif /* ACE_LACKS_IOSTREAM_TOTALLY */ +TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const ImplementationRepository::Administration::CannotActivate &); +TAO_PortableServer_Export CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::Administration::CannotActivate &); + +# if !defined (ACE_LACKS_IOSTREAM_TOTALLY) + +TAO_PortableServer_Export ostream& operator<< (ostream &, const ImplementationRepository::Administration::CannotActivate &); + +# endif /* ACE_LACKS_IOSTREAM_TOTALLY */ +TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const ImplementationRepository::Administration::NotFound &); +TAO_PortableServer_Export CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::Administration::NotFound &); + +# if !defined (ACE_LACKS_IOSTREAM_TOTALLY) + +TAO_PortableServer_Export ostream& operator<< (ostream &, const ImplementationRepository::Administration::NotFound &); + +# endif /* ACE_LACKS_IOSTREAM_TOTALLY */ +TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const ImplementationRepository::ServerInformationIterator_ptr ); +TAO_PortableServer_Export CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::ServerInformationIterator_ptr &); + +#endif /* __ACE_INLINE__ */ + + +#if defined (__ACE_INLINE__) +#include "ImplRepoC.i" +#endif /* defined INLINE */ + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#pragma warning(pop) +#endif /* _MSC_VER */ + +#include "ace/post.h" +#endif /* ifndef */ |