diff options
Diffstat (limited to 'TAO/tao/PortableServer/PortableServerC.h')
| -rw-r--r-- | TAO/tao/PortableServer/PortableServerC.h | 3186 |
1 files changed, 3186 insertions, 0 deletions
diff --git a/TAO/tao/PortableServer/PortableServerC.h b/TAO/tao/PortableServer/PortableServerC.h new file mode 100644 index 00000000000..95ae83ba283 --- /dev/null +++ b/TAO/tao/PortableServer/PortableServerC.h @@ -0,0 +1,3186 @@ +/* -*- 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_PORTABLESERVERC_H_ +#define _TAO_IDL_PORTABLESERVERC_H_ + +#include "ace/pre.h" + +#include "tao/corbafwd.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 */ + +#include "tao/CurrentC.h" +#include "tao/PolicyC.h" +#include "tao/Typecode.h" +#include "tao/Any.h" + +#if defined (TAO_EXPORT_MACRO) +#undef TAO_EXPORT_MACRO +#endif +#define TAO_EXPORT_MACRO TAO_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_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 */ + +class TAO_ServantBase; +class TAO_ServantBase_var; +class TAO_RefCountServantBase; +class TAO_Local_ServantBase; +class TAO_DynamicImplementation; + +TAO_NAMESPACE PortableServer +{ + typedef TAO_ServantBase ServantBase; + typedef TAO_ServantBase_var ServantBase_var; + typedef TAO_RefCountServantBase RefCountServantBase; + typedef ServantBase *Servant; + + typedef TAO_Local_ServantBase LocalServantBase; + typedef TAO_DynamicImplementation DynamicImplementation; + + class POA; + +#if !defined (_PORTABLESERVER_POA___PTR_CH_) +#define _PORTABLESERVER_POA___PTR_CH_ + +typedef POA *POA_ptr; + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_POA___VAR_CH_) +#define _PORTABLESERVER_POA___VAR_CH_ + + class TAO_Export POA_var : public TAO_Base_var + { + public: + POA_var (void); // default constructor + POA_var (POA_ptr p) : ptr_ (p) {} + POA_var (const POA_var &); // copy constructor + ~POA_var (void); // destructor + + POA_var &operator= (POA_ptr); + POA_var &operator= (const POA_var &); + POA_ptr operator-> (void) const; + + operator const POA_ptr &() const; + operator POA_ptr &(); + // in, inout, out, _retn + POA_ptr in (void) const; + POA_ptr &inout (void); + POA_ptr &out (void); + POA_ptr _retn (void); + POA_ptr ptr (void) const; + + private: + POA_ptr ptr_; + // Unimplemented - prevents widening assignment. + POA_var (const TAO_Base_var &rhs); + POA_var &operator= (const TAO_Base_var &rhs); + }; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_POA___OUT_CH_) +#define _PORTABLESERVER_POA___OUT_CH_ + + class TAO_Export POA_out + { + public: + POA_out (POA_ptr &); + POA_out (POA_var &); + POA_out (const POA_out &); + POA_out &operator= (const POA_out &); + POA_out &operator= (const POA_var &); + POA_out &operator= (POA_ptr); + operator POA_ptr &(); + POA_ptr &ptr (void); + POA_ptr operator-> (void); + + private: + POA_ptr &ptr_; + }; + + +#endif /* end #if !defined */ + + +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_PORTABLESERVER_POALIST_CH_) +#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_PORTABLESERVER_POALIST_CH_ + + class _TAO_Unbounded_Object_Sequence_PortableServer_POAList : public TAO_Unbounded_Base_Sequence + { + public: + // = Initialization and termination methods. + + _TAO_Unbounded_Object_Sequence_PortableServer_POAList (void); + _TAO_Unbounded_Object_Sequence_PortableServer_POAList (CORBA::ULong maximum); + _TAO_Unbounded_Object_Sequence_PortableServer_POAList (CORBA::ULong maximum, + CORBA::ULong length, + POA* *value, + CORBA::Boolean release = 0); + _TAO_Unbounded_Object_Sequence_PortableServer_POAList(const _TAO_Unbounded_Object_Sequence_PortableServer_POAList &rhs); + virtual ~_TAO_Unbounded_Object_Sequence_PortableServer_POAList (void); + _TAO_Unbounded_Object_Sequence_PortableServer_POAList &operator= (const _TAO_Unbounded_Object_Sequence_PortableServer_POAList &rhs); + TAO_Object_Manager<PortableServer::POA,PortableServer::POA_var> operator[] (CORBA::ULong index) const; + static POA **allocbuf (CORBA::ULong nelems); + static void freebuf (POA **buffer); + // The Base_Sequence functions, please see tao/Sequence.h + virtual void _allocate_buffer (CORBA::ULong length); + virtual void _deallocate_buffer (void); + POA* *get_buffer (CORBA::Boolean orphan = 0); + const POA* *get_buffer (void) const; + virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol); + virtual void _downcast ( + void* target, + CORBA_Object *src, + CORBA_Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + virtual CORBA_Object* _upcast (void *src) const; + + }; + +#endif /* end #if !defined */ + + +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +#if !defined (_PORTABLESERVER_POALIST_CH_) +#define _PORTABLESERVER_POALIST_CH_ + + class POAList; + class POAList_var; + + // ************************************************************* + // POAList + // ************************************************************* + + class TAO_Export POAList : public +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Object_Sequence_PortableServer_POAList +#else /* TAO_USE_SEQUENCE_TEMPLATES */ + TAO_Unbounded_Object_Sequence<POA,POA_var> +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: + POAList (void); // default ctor + POAList (CORBA::ULong max); // uses max size + POAList ( + CORBA::ULong max, + CORBA::ULong length, + POA_ptr *buffer, + CORBA::Boolean release=0 + ); + POAList (const POAList &); // copy ctor + ~POAList (void); + static void _tao_any_destructor (void*); + +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef POAList_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + }; + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_POALIST___VAR_CH_) +#define _PORTABLESERVER_POALIST___VAR_CH_ + + // ************************************************************* + // class PortableServer::POAList_var + // ************************************************************* + + class TAO_Export POAList_var + { + public: + POAList_var (void); // default constructor + POAList_var (POAList *); + POAList_var (const POAList_var &); // copy constructor + ~POAList_var (void); // destructor + + POAList_var &operator= (POAList *); + POAList_var &operator= (const POAList_var &); + POAList *operator-> (void); + const POAList *operator-> (void) const; + + operator const POAList &() const; + operator POAList &(); + operator POAList &() const; + operator POAList *&(); // variable-size base types only + + TAO_Object_Manager<POA, POA_var> operator[] (CORBA::ULong index); + // in, inout, out, _retn + const POAList &in (void) const; + POAList &inout (void); + POAList *&out (void); + POAList *_retn (void); + POAList *ptr (void) const; + + private: + POAList *ptr_; + }; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_POALIST___OUT_CH_) +#define _PORTABLESERVER_POALIST___OUT_CH_ + + class TAO_Export POAList_out + { + public: + POAList_out (POAList *&); + POAList_out (POAList_var &); + POAList_out (const POAList_out &); + POAList_out &operator= (const POAList_out &); + POAList_out &operator= (POAList *); + operator POAList *&(); + POAList *&ptr (void); + POAList *operator-> (void); + TAO_Object_Manager<POA, POA_var> operator[] (CORBA::ULong index); + + private: + POAList *&ptr_; + // assignment from T_var not allowed + void operator= (const POAList_var &); + }; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_OBJECTID_CH_) +#define _PORTABLESERVER_OBJECTID_CH_ + + class ObjectId; + class ObjectId_var; + + // ************************************************************* + // ObjectId + // ************************************************************* + + class TAO_Export ObjectId : public +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + TAO_Unbounded_Sequence<CORBA::Octet> +#else /* TAO_USE_SEQUENCE_TEMPLATES */ + TAO_Unbounded_Sequence<CORBA::Octet> +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: + ObjectId (void); // default ctor + ObjectId (CORBA::ULong max); // uses max size + ObjectId ( + CORBA::ULong max, + CORBA::ULong length, + CORBA::Octet *buffer, + CORBA::Boolean release=0 + ); + ObjectId (const ObjectId &); // copy ctor + ~ObjectId (void); + static void _tao_any_destructor (void*); + +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef ObjectId_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + +#if defined(TAO_NO_COPY_OCTET_SEQUENCES) + ObjectId ( + CORBA::ULong length, + const ACE_Message_Block* mb + ) + : TAO_Unbounded_Sequence<CORBA::Octet> (length, mb) {} +#endif /* TAO_NO_COPY_OCTET_SEQUENCE */ + + }; + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_OBJECTID___VAR_CH_) +#define _PORTABLESERVER_OBJECTID___VAR_CH_ + + // ************************************************************* + // class PortableServer::ObjectId_var + // ************************************************************* + + class TAO_Export ObjectId_var + { + public: + ObjectId_var (void); // default constructor + ObjectId_var (ObjectId *); + ObjectId_var (const ObjectId_var &); // copy constructor + ObjectId_var (const ObjectId &); // fixed-size base types only + ~ObjectId_var (void); // destructor + + ObjectId_var &operator= (ObjectId *); + ObjectId_var &operator= (const ObjectId_var &); + ObjectId_var &operator= (const ObjectId &); // fixed-size base types only + ObjectId *operator-> (void); + const ObjectId *operator-> (void) const; + + operator const ObjectId &() const; + operator ObjectId &(); + operator ObjectId &() const; + + CORBA::Octet &operator[] (CORBA::ULong index); + // in, inout, out, _retn + const ObjectId &in (void) const; + ObjectId &inout (void); + ObjectId *&out (void); + ObjectId *_retn (void); + ObjectId *ptr (void) const; + + private: + ObjectId *ptr_; + }; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_OBJECTID___OUT_CH_) +#define _PORTABLESERVER_OBJECTID___OUT_CH_ + + class TAO_Export ObjectId_out + { + public: + ObjectId_out (ObjectId *&); + ObjectId_out (ObjectId_var &); + ObjectId_out (const ObjectId_out &); + ObjectId_out &operator= (const ObjectId_out &); + ObjectId_out &operator= (ObjectId *); + operator ObjectId *&(); + ObjectId *&ptr (void); + ObjectId *operator-> (void); + CORBA::Octet &operator[] (CORBA::ULong index); + + private: + ObjectId *&ptr_; + // assignment from T_var not allowed + void operator= (const ObjectId_var &); + }; + + +#endif /* end #if !defined */ + + TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ObjectId; + + +#if (TAO_HAS_MINIMUM_CORBA == 0) + +#if !defined (_PORTABLESERVER_FORWARDREQUEST_CH_) +#define _PORTABLESERVER_FORWARDREQUEST_CH_ + + class TAO_Export ForwardRequest : public CORBA::UserException + { + public: + + CORBA::Object_var forward_reference; + + ForwardRequest (void); // default ctor + ForwardRequest (const ForwardRequest &); // copy ctor + ~ForwardRequest (void); + static void _tao_any_destructor (void*); + ForwardRequest &operator= (const ForwardRequest &); + + + virtual void _raise (void); + + virtual void _tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &) const; + virtual void _tao_decode ( + TAO_InputCDR &, + CORBA::Environment &); + + static ForwardRequest *_downcast (CORBA::Exception *); + + ForwardRequest ( + const CORBA::Object_ptr _tao_forward_reference + ); + + // = TAO extension + static CORBA::Exception *_alloc (void); + virtual CORBA::TypeCode_ptr _type (void) const; + +}; // exception PortableServer::ForwardRequest + +TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ForwardRequest; + + +#endif /* end #if !defined */ + +#endif /* TAO_HAS_MINIMUM_CORBA == 0 */ + +TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong THREAD_POLICY_ID; + +TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong LIFESPAN_POLICY_ID; + +TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong ID_UNIQUENESS_POLICY_ID; + +TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong ID_ASSIGNMENT_POLICY_ID; + +TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong IMPLICIT_ACTIVATION_POLICY_ID; + +TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong SERVANT_RETENTION_POLICY_ID; + +TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong REQUEST_PROCESSING_POLICY_ID; + +enum ThreadPolicyValue +{ + ORB_CTRL_MODEL, + SINGLE_THREAD_MODEL, + ThreadPolicyValue_TAO_ENUM_32BIT_ENFORCER = 0x7FFFFFFF +}; + +#if (TAO_HAS_MINIMUM_POA == 0) + +typedef ThreadPolicyValue &ThreadPolicyValue_out; +TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ThreadPolicyValue; + + +#if !defined (_PORTABLESERVER_THREADPOLICY___PTR_CH_) +#define _PORTABLESERVER_THREADPOLICY___PTR_CH_ + +class ThreadPolicy; +typedef ThreadPolicy *ThreadPolicy_ptr; + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_THREADPOLICY___VAR_CH_) +#define _PORTABLESERVER_THREADPOLICY___VAR_CH_ + +class TAO_Export ThreadPolicy_var : public TAO_Base_var +{ +public: + ThreadPolicy_var (void); // default constructor + ThreadPolicy_var (ThreadPolicy_ptr p) : ptr_ (p) {} + ThreadPolicy_var (const ThreadPolicy_var &); // copy constructor + ~ThreadPolicy_var (void); // destructor + + ThreadPolicy_var &operator= (ThreadPolicy_ptr); + ThreadPolicy_var &operator= (const ThreadPolicy_var &); + ThreadPolicy_ptr operator-> (void) const; + + operator const ThreadPolicy_ptr &() const; + operator ThreadPolicy_ptr &(); + // in, inout, out, _retn + ThreadPolicy_ptr in (void) const; + ThreadPolicy_ptr &inout (void); + ThreadPolicy_ptr &out (void); + ThreadPolicy_ptr _retn (void); + ThreadPolicy_ptr ptr (void) const; + +private: + ThreadPolicy_ptr ptr_; + // Unimplemented - prevents widening assignment. + ThreadPolicy_var (const TAO_Base_var &rhs); + ThreadPolicy_var &operator= (const TAO_Base_var &rhs); +}; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_THREADPOLICY___OUT_CH_) +#define _PORTABLESERVER_THREADPOLICY___OUT_CH_ + +class TAO_Export ThreadPolicy_out +{ +public: + ThreadPolicy_out (ThreadPolicy_ptr &); + ThreadPolicy_out (ThreadPolicy_var &); + ThreadPolicy_out (const ThreadPolicy_out &); + ThreadPolicy_out &operator= (const ThreadPolicy_out &); + ThreadPolicy_out &operator= (const ThreadPolicy_var &); + ThreadPolicy_out &operator= (ThreadPolicy_ptr); + operator ThreadPolicy_ptr &(); + ThreadPolicy_ptr &ptr (void); + ThreadPolicy_ptr operator-> (void); + +private: + ThreadPolicy_ptr &ptr_; +}; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_THREADPOLICY_CH_) +#define _PORTABLESERVER_THREADPOLICY_CH_ + +class TAO_Export ThreadPolicy: public virtual CORBA::Policy +{ +public: +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef ThreadPolicy_ptr _ptr_type; + typedef ThreadPolicy_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations + static ThreadPolicy_ptr _duplicate (ThreadPolicy_ptr obj); + static ThreadPolicy_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static ThreadPolicy_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static ThreadPolicy_ptr _nil (void) + { + return (ThreadPolicy_ptr)0; + } + + virtual PortableServer::ThreadPolicyValue value ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + virtual void *_tao_QueryInterface (ptr_arith_t type); + + virtual const char* _interface_repository_id (void) const; + +protected: + ThreadPolicy (void); + virtual ~ThreadPolicy (void); +private: + ThreadPolicy (const ThreadPolicy &); + void operator= (const ThreadPolicy &); +}; + + +#endif /* end #if !defined */ + +#endif /* TAO_HAS_MINIMUM_POA == 0 */ + +enum LifespanPolicyValue +{ + TRANSIENT, + PERSISTENT, + LifespanPolicyValue_TAO_ENUM_32BIT_ENFORCER = 0x7FFFFFFF +}; +typedef LifespanPolicyValue &LifespanPolicyValue_out; +TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_LifespanPolicyValue; + + +#if !defined (_PORTABLESERVER_LIFESPANPOLICY___PTR_CH_) +#define _PORTABLESERVER_LIFESPANPOLICY___PTR_CH_ + +class LifespanPolicy; +typedef LifespanPolicy *LifespanPolicy_ptr; + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_LIFESPANPOLICY___VAR_CH_) +#define _PORTABLESERVER_LIFESPANPOLICY___VAR_CH_ + +class TAO_Export LifespanPolicy_var : public TAO_Base_var +{ +public: + LifespanPolicy_var (void); // default constructor + LifespanPolicy_var (LifespanPolicy_ptr p) : ptr_ (p) {} + LifespanPolicy_var (const LifespanPolicy_var &); // copy constructor + ~LifespanPolicy_var (void); // destructor + + LifespanPolicy_var &operator= (LifespanPolicy_ptr); + LifespanPolicy_var &operator= (const LifespanPolicy_var &); + LifespanPolicy_ptr operator-> (void) const; + + operator const LifespanPolicy_ptr &() const; + operator LifespanPolicy_ptr &(); + // in, inout, out, _retn + LifespanPolicy_ptr in (void) const; + LifespanPolicy_ptr &inout (void); + LifespanPolicy_ptr &out (void); + LifespanPolicy_ptr _retn (void); + LifespanPolicy_ptr ptr (void) const; + +private: + LifespanPolicy_ptr ptr_; + // Unimplemented - prevents widening assignment. + LifespanPolicy_var (const TAO_Base_var &rhs); + LifespanPolicy_var &operator= (const TAO_Base_var &rhs); +}; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_LIFESPANPOLICY___OUT_CH_) +#define _PORTABLESERVER_LIFESPANPOLICY___OUT_CH_ + +class TAO_Export LifespanPolicy_out +{ +public: + LifespanPolicy_out (LifespanPolicy_ptr &); + LifespanPolicy_out (LifespanPolicy_var &); + LifespanPolicy_out (const LifespanPolicy_out &); + LifespanPolicy_out &operator= (const LifespanPolicy_out &); + LifespanPolicy_out &operator= (const LifespanPolicy_var &); + LifespanPolicy_out &operator= (LifespanPolicy_ptr); + operator LifespanPolicy_ptr &(); + LifespanPolicy_ptr &ptr (void); + LifespanPolicy_ptr operator-> (void); + +private: + LifespanPolicy_ptr &ptr_; +}; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_LIFESPANPOLICY_CH_) +#define _PORTABLESERVER_LIFESPANPOLICY_CH_ + +class TAO_Export LifespanPolicy: public virtual CORBA::Policy +{ +public: +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef LifespanPolicy_ptr _ptr_type; + typedef LifespanPolicy_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations + static LifespanPolicy_ptr _duplicate (LifespanPolicy_ptr obj); + static LifespanPolicy_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static LifespanPolicy_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static LifespanPolicy_ptr _nil (void) + { + return (LifespanPolicy_ptr)0; + } + + virtual PortableServer::LifespanPolicyValue value ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + virtual void *_tao_QueryInterface (ptr_arith_t type); + + virtual const char* _interface_repository_id (void) const; + +protected: + LifespanPolicy (void); + virtual ~LifespanPolicy (void); +private: + LifespanPolicy (const LifespanPolicy &); + void operator= (const LifespanPolicy &); +}; + + +#endif /* end #if !defined */ + +enum IdUniquenessPolicyValue +{ + UNIQUE_ID, + MULTIPLE_ID, + IdUniquenessPolicyValue_TAO_ENUM_32BIT_ENFORCER = 0x7FFFFFFF +}; +typedef IdUniquenessPolicyValue &IdUniquenessPolicyValue_out; +TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_IdUniquenessPolicyValue; + + +#if !defined (_PORTABLESERVER_IDUNIQUENESSPOLICY___PTR_CH_) +#define _PORTABLESERVER_IDUNIQUENESSPOLICY___PTR_CH_ + +class IdUniquenessPolicy; +typedef IdUniquenessPolicy *IdUniquenessPolicy_ptr; + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_IDUNIQUENESSPOLICY___VAR_CH_) +#define _PORTABLESERVER_IDUNIQUENESSPOLICY___VAR_CH_ + +class TAO_Export IdUniquenessPolicy_var : public TAO_Base_var +{ +public: + IdUniquenessPolicy_var (void); // default constructor + IdUniquenessPolicy_var (IdUniquenessPolicy_ptr p) : ptr_ (p) {} + IdUniquenessPolicy_var (const IdUniquenessPolicy_var &); // copy constructor + ~IdUniquenessPolicy_var (void); // destructor + + IdUniquenessPolicy_var &operator= (IdUniquenessPolicy_ptr); + IdUniquenessPolicy_var &operator= (const IdUniquenessPolicy_var &); + IdUniquenessPolicy_ptr operator-> (void) const; + + operator const IdUniquenessPolicy_ptr &() const; + operator IdUniquenessPolicy_ptr &(); + // in, inout, out, _retn + IdUniquenessPolicy_ptr in (void) const; + IdUniquenessPolicy_ptr &inout (void); + IdUniquenessPolicy_ptr &out (void); + IdUniquenessPolicy_ptr _retn (void); + IdUniquenessPolicy_ptr ptr (void) const; + +private: + IdUniquenessPolicy_ptr ptr_; + // Unimplemented - prevents widening assignment. + IdUniquenessPolicy_var (const TAO_Base_var &rhs); + IdUniquenessPolicy_var &operator= (const TAO_Base_var &rhs); +}; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_IDUNIQUENESSPOLICY___OUT_CH_) +#define _PORTABLESERVER_IDUNIQUENESSPOLICY___OUT_CH_ + +class TAO_Export IdUniquenessPolicy_out +{ +public: + IdUniquenessPolicy_out (IdUniquenessPolicy_ptr &); + IdUniquenessPolicy_out (IdUniquenessPolicy_var &); + IdUniquenessPolicy_out (const IdUniquenessPolicy_out &); + IdUniquenessPolicy_out &operator= (const IdUniquenessPolicy_out &); + IdUniquenessPolicy_out &operator= (const IdUniquenessPolicy_var &); + IdUniquenessPolicy_out &operator= (IdUniquenessPolicy_ptr); + operator IdUniquenessPolicy_ptr &(); + IdUniquenessPolicy_ptr &ptr (void); + IdUniquenessPolicy_ptr operator-> (void); + +private: + IdUniquenessPolicy_ptr &ptr_; +}; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_IDUNIQUENESSPOLICY_CH_) +#define _PORTABLESERVER_IDUNIQUENESSPOLICY_CH_ + +class TAO_Export IdUniquenessPolicy: public virtual CORBA::Policy +{ +public: +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef IdUniquenessPolicy_ptr _ptr_type; + typedef IdUniquenessPolicy_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations + static IdUniquenessPolicy_ptr _duplicate (IdUniquenessPolicy_ptr obj); + static IdUniquenessPolicy_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static IdUniquenessPolicy_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static IdUniquenessPolicy_ptr _nil (void) + { + return (IdUniquenessPolicy_ptr)0; + } + + virtual PortableServer::IdUniquenessPolicyValue value ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + virtual void *_tao_QueryInterface (ptr_arith_t type); + + virtual const char* _interface_repository_id (void) const; + +protected: + IdUniquenessPolicy (void); + virtual ~IdUniquenessPolicy (void); +private: + IdUniquenessPolicy (const IdUniquenessPolicy &); + void operator= (const IdUniquenessPolicy &); +}; + + +#endif /* end #if !defined */ + +enum IdAssignmentPolicyValue +{ + USER_ID, + SYSTEM_ID, + IdAssignmentPolicyValue_TAO_ENUM_32BIT_ENFORCER = 0x7FFFFFFF +}; +typedef IdAssignmentPolicyValue &IdAssignmentPolicyValue_out; +TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_IdAssignmentPolicyValue; + + +#if !defined (_PORTABLESERVER_IDASSIGNMENTPOLICY___PTR_CH_) +#define _PORTABLESERVER_IDASSIGNMENTPOLICY___PTR_CH_ + +class IdAssignmentPolicy; +typedef IdAssignmentPolicy *IdAssignmentPolicy_ptr; + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_IDASSIGNMENTPOLICY___VAR_CH_) +#define _PORTABLESERVER_IDASSIGNMENTPOLICY___VAR_CH_ + +class TAO_Export IdAssignmentPolicy_var : public TAO_Base_var +{ +public: + IdAssignmentPolicy_var (void); // default constructor + IdAssignmentPolicy_var (IdAssignmentPolicy_ptr p) : ptr_ (p) {} + IdAssignmentPolicy_var (const IdAssignmentPolicy_var &); // copy constructor + ~IdAssignmentPolicy_var (void); // destructor + + IdAssignmentPolicy_var &operator= (IdAssignmentPolicy_ptr); + IdAssignmentPolicy_var &operator= (const IdAssignmentPolicy_var &); + IdAssignmentPolicy_ptr operator-> (void) const; + + operator const IdAssignmentPolicy_ptr &() const; + operator IdAssignmentPolicy_ptr &(); + // in, inout, out, _retn + IdAssignmentPolicy_ptr in (void) const; + IdAssignmentPolicy_ptr &inout (void); + IdAssignmentPolicy_ptr &out (void); + IdAssignmentPolicy_ptr _retn (void); + IdAssignmentPolicy_ptr ptr (void) const; + +private: + IdAssignmentPolicy_ptr ptr_; + // Unimplemented - prevents widening assignment. + IdAssignmentPolicy_var (const TAO_Base_var &rhs); + IdAssignmentPolicy_var &operator= (const TAO_Base_var &rhs); +}; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_IDASSIGNMENTPOLICY___OUT_CH_) +#define _PORTABLESERVER_IDASSIGNMENTPOLICY___OUT_CH_ + +class TAO_Export IdAssignmentPolicy_out +{ +public: + IdAssignmentPolicy_out (IdAssignmentPolicy_ptr &); + IdAssignmentPolicy_out (IdAssignmentPolicy_var &); + IdAssignmentPolicy_out (const IdAssignmentPolicy_out &); + IdAssignmentPolicy_out &operator= (const IdAssignmentPolicy_out &); + IdAssignmentPolicy_out &operator= (const IdAssignmentPolicy_var &); + IdAssignmentPolicy_out &operator= (IdAssignmentPolicy_ptr); + operator IdAssignmentPolicy_ptr &(); + IdAssignmentPolicy_ptr &ptr (void); + IdAssignmentPolicy_ptr operator-> (void); + +private: + IdAssignmentPolicy_ptr &ptr_; +}; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_IDASSIGNMENTPOLICY_CH_) +#define _PORTABLESERVER_IDASSIGNMENTPOLICY_CH_ + +class TAO_Export IdAssignmentPolicy: public virtual CORBA::Policy +{ +public: +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef IdAssignmentPolicy_ptr _ptr_type; + typedef IdAssignmentPolicy_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations + static IdAssignmentPolicy_ptr _duplicate (IdAssignmentPolicy_ptr obj); + static IdAssignmentPolicy_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static IdAssignmentPolicy_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static IdAssignmentPolicy_ptr _nil (void) + { + return (IdAssignmentPolicy_ptr)0; + } + + virtual PortableServer::IdAssignmentPolicyValue value ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + virtual void *_tao_QueryInterface (ptr_arith_t type); + + virtual const char* _interface_repository_id (void) const; + +protected: + IdAssignmentPolicy (void); + virtual ~IdAssignmentPolicy (void); +private: + IdAssignmentPolicy (const IdAssignmentPolicy &); + void operator= (const IdAssignmentPolicy &); +}; + + +#endif /* end #if !defined */ + +enum ImplicitActivationPolicyValue +{ + IMPLICIT_ACTIVATION, + NO_IMPLICIT_ACTIVATION, + ImplicitActivationPolicyValue_TAO_ENUM_32BIT_ENFORCER = 0x7FFFFFFF +}; + +#if (TAO_HAS_MINIMUM_POA == 0) + +typedef ImplicitActivationPolicyValue &ImplicitActivationPolicyValue_out; +TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ImplicitActivationPolicyValue; + + +#if !defined (_PORTABLESERVER_IMPLICITACTIVATIONPOLICY___PTR_CH_) +#define _PORTABLESERVER_IMPLICITACTIVATIONPOLICY___PTR_CH_ + +class ImplicitActivationPolicy; +typedef ImplicitActivationPolicy *ImplicitActivationPolicy_ptr; + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_IMPLICITACTIVATIONPOLICY___VAR_CH_) +#define _PORTABLESERVER_IMPLICITACTIVATIONPOLICY___VAR_CH_ + +class TAO_Export ImplicitActivationPolicy_var : public TAO_Base_var +{ +public: + ImplicitActivationPolicy_var (void); // default constructor + ImplicitActivationPolicy_var (ImplicitActivationPolicy_ptr p) : ptr_ (p) {} + ImplicitActivationPolicy_var (const ImplicitActivationPolicy_var &); // copy constructor + ~ImplicitActivationPolicy_var (void); // destructor + + ImplicitActivationPolicy_var &operator= (ImplicitActivationPolicy_ptr); + ImplicitActivationPolicy_var &operator= (const ImplicitActivationPolicy_var &); + ImplicitActivationPolicy_ptr operator-> (void) const; + + operator const ImplicitActivationPolicy_ptr &() const; + operator ImplicitActivationPolicy_ptr &(); + // in, inout, out, _retn + ImplicitActivationPolicy_ptr in (void) const; + ImplicitActivationPolicy_ptr &inout (void); + ImplicitActivationPolicy_ptr &out (void); + ImplicitActivationPolicy_ptr _retn (void); + ImplicitActivationPolicy_ptr ptr (void) const; + +private: + ImplicitActivationPolicy_ptr ptr_; + // Unimplemented - prevents widening assignment. + ImplicitActivationPolicy_var (const TAO_Base_var &rhs); + ImplicitActivationPolicy_var &operator= (const TAO_Base_var &rhs); +}; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_IMPLICITACTIVATIONPOLICY___OUT_CH_) +#define _PORTABLESERVER_IMPLICITACTIVATIONPOLICY___OUT_CH_ + +class TAO_Export ImplicitActivationPolicy_out +{ +public: + ImplicitActivationPolicy_out (ImplicitActivationPolicy_ptr &); + ImplicitActivationPolicy_out (ImplicitActivationPolicy_var &); + ImplicitActivationPolicy_out (const ImplicitActivationPolicy_out &); + ImplicitActivationPolicy_out &operator= (const ImplicitActivationPolicy_out &); + ImplicitActivationPolicy_out &operator= (const ImplicitActivationPolicy_var &); + ImplicitActivationPolicy_out &operator= (ImplicitActivationPolicy_ptr); + operator ImplicitActivationPolicy_ptr &(); + ImplicitActivationPolicy_ptr &ptr (void); + ImplicitActivationPolicy_ptr operator-> (void); + +private: + ImplicitActivationPolicy_ptr &ptr_; +}; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_IMPLICITACTIVATIONPOLICY_CH_) +#define _PORTABLESERVER_IMPLICITACTIVATIONPOLICY_CH_ + +class TAO_Export ImplicitActivationPolicy: public virtual CORBA::Policy +{ +public: +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef ImplicitActivationPolicy_ptr _ptr_type; + typedef ImplicitActivationPolicy_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations + static ImplicitActivationPolicy_ptr _duplicate (ImplicitActivationPolicy_ptr obj); + static ImplicitActivationPolicy_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static ImplicitActivationPolicy_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static ImplicitActivationPolicy_ptr _nil (void) + { + return (ImplicitActivationPolicy_ptr)0; + } + + virtual PortableServer::ImplicitActivationPolicyValue value ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + virtual void *_tao_QueryInterface (ptr_arith_t type); + + virtual const char* _interface_repository_id (void) const; + +protected: + ImplicitActivationPolicy (void); + virtual ~ImplicitActivationPolicy (void); +private: + ImplicitActivationPolicy (const ImplicitActivationPolicy &); + void operator= (const ImplicitActivationPolicy &); +}; + + +#endif /* end #if !defined */ + +#endif /* TAO_HAS_MINIMUM_POA == 0 */ + +enum ServantRetentionPolicyValue +{ + RETAIN, + NON_RETAIN, + ServantRetentionPolicyValue_TAO_ENUM_32BIT_ENFORCER = 0x7FFFFFFF +}; + +#if (TAO_HAS_MINIMUM_POA == 0) + +typedef ServantRetentionPolicyValue &ServantRetentionPolicyValue_out; +TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ServantRetentionPolicyValue; + + +#if !defined (_PORTABLESERVER_SERVANTRETENTIONPOLICY___PTR_CH_) +#define _PORTABLESERVER_SERVANTRETENTIONPOLICY___PTR_CH_ + +class ServantRetentionPolicy; +typedef ServantRetentionPolicy *ServantRetentionPolicy_ptr; + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_SERVANTRETENTIONPOLICY___VAR_CH_) +#define _PORTABLESERVER_SERVANTRETENTIONPOLICY___VAR_CH_ + +class TAO_Export ServantRetentionPolicy_var : public TAO_Base_var +{ +public: + ServantRetentionPolicy_var (void); // default constructor + ServantRetentionPolicy_var (ServantRetentionPolicy_ptr p) : ptr_ (p) {} + ServantRetentionPolicy_var (const ServantRetentionPolicy_var &); // copy constructor + ~ServantRetentionPolicy_var (void); // destructor + + ServantRetentionPolicy_var &operator= (ServantRetentionPolicy_ptr); + ServantRetentionPolicy_var &operator= (const ServantRetentionPolicy_var &); + ServantRetentionPolicy_ptr operator-> (void) const; + + operator const ServantRetentionPolicy_ptr &() const; + operator ServantRetentionPolicy_ptr &(); + // in, inout, out, _retn + ServantRetentionPolicy_ptr in (void) const; + ServantRetentionPolicy_ptr &inout (void); + ServantRetentionPolicy_ptr &out (void); + ServantRetentionPolicy_ptr _retn (void); + ServantRetentionPolicy_ptr ptr (void) const; + +private: + ServantRetentionPolicy_ptr ptr_; + // Unimplemented - prevents widening assignment. + ServantRetentionPolicy_var (const TAO_Base_var &rhs); + ServantRetentionPolicy_var &operator= (const TAO_Base_var &rhs); +}; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_SERVANTRETENTIONPOLICY___OUT_CH_) +#define _PORTABLESERVER_SERVANTRETENTIONPOLICY___OUT_CH_ + +class TAO_Export ServantRetentionPolicy_out +{ +public: + ServantRetentionPolicy_out (ServantRetentionPolicy_ptr &); + ServantRetentionPolicy_out (ServantRetentionPolicy_var &); + ServantRetentionPolicy_out (const ServantRetentionPolicy_out &); + ServantRetentionPolicy_out &operator= (const ServantRetentionPolicy_out &); + ServantRetentionPolicy_out &operator= (const ServantRetentionPolicy_var &); + ServantRetentionPolicy_out &operator= (ServantRetentionPolicy_ptr); + operator ServantRetentionPolicy_ptr &(); + ServantRetentionPolicy_ptr &ptr (void); + ServantRetentionPolicy_ptr operator-> (void); + +private: + ServantRetentionPolicy_ptr &ptr_; +}; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_SERVANTRETENTIONPOLICY_CH_) +#define _PORTABLESERVER_SERVANTRETENTIONPOLICY_CH_ + +class TAO_Export ServantRetentionPolicy: public virtual CORBA::Policy +{ +public: +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef ServantRetentionPolicy_ptr _ptr_type; + typedef ServantRetentionPolicy_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations + static ServantRetentionPolicy_ptr _duplicate (ServantRetentionPolicy_ptr obj); + static ServantRetentionPolicy_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static ServantRetentionPolicy_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static ServantRetentionPolicy_ptr _nil (void) + { + return (ServantRetentionPolicy_ptr)0; + } + + virtual PortableServer::ServantRetentionPolicyValue value ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + virtual void *_tao_QueryInterface (ptr_arith_t type); + + virtual const char* _interface_repository_id (void) const; + +protected: + ServantRetentionPolicy (void); + virtual ~ServantRetentionPolicy (void); +private: + ServantRetentionPolicy (const ServantRetentionPolicy &); + void operator= (const ServantRetentionPolicy &); +}; + + +#endif /* end #if !defined */ + +#endif /* TAO_HAS_MINIMUM_POA == 0 */ + +enum RequestProcessingPolicyValue +{ + USE_ACTIVE_OBJECT_MAP_ONLY, + USE_DEFAULT_SERVANT, + USE_SERVANT_MANAGER, + RequestProcessingPolicyValue_TAO_ENUM_32BIT_ENFORCER = 0x7FFFFFFF +}; + +#if (TAO_HAS_MINIMUM_POA == 0) + +typedef RequestProcessingPolicyValue &RequestProcessingPolicyValue_out; +TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_RequestProcessingPolicyValue; + + +#if !defined (_PORTABLESERVER_REQUESTPROCESSINGPOLICY___PTR_CH_) +#define _PORTABLESERVER_REQUESTPROCESSINGPOLICY___PTR_CH_ + +class RequestProcessingPolicy; +typedef RequestProcessingPolicy *RequestProcessingPolicy_ptr; + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_REQUESTPROCESSINGPOLICY___VAR_CH_) +#define _PORTABLESERVER_REQUESTPROCESSINGPOLICY___VAR_CH_ + +class TAO_Export RequestProcessingPolicy_var : public TAO_Base_var +{ +public: + RequestProcessingPolicy_var (void); // default constructor + RequestProcessingPolicy_var (RequestProcessingPolicy_ptr p) : ptr_ (p) {} + RequestProcessingPolicy_var (const RequestProcessingPolicy_var &); // copy constructor + ~RequestProcessingPolicy_var (void); // destructor + + RequestProcessingPolicy_var &operator= (RequestProcessingPolicy_ptr); + RequestProcessingPolicy_var &operator= (const RequestProcessingPolicy_var &); + RequestProcessingPolicy_ptr operator-> (void) const; + + operator const RequestProcessingPolicy_ptr &() const; + operator RequestProcessingPolicy_ptr &(); + // in, inout, out, _retn + RequestProcessingPolicy_ptr in (void) const; + RequestProcessingPolicy_ptr &inout (void); + RequestProcessingPolicy_ptr &out (void); + RequestProcessingPolicy_ptr _retn (void); + RequestProcessingPolicy_ptr ptr (void) const; + +private: + RequestProcessingPolicy_ptr ptr_; + // Unimplemented - prevents widening assignment. + RequestProcessingPolicy_var (const TAO_Base_var &rhs); + RequestProcessingPolicy_var &operator= (const TAO_Base_var &rhs); +}; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_REQUESTPROCESSINGPOLICY___OUT_CH_) +#define _PORTABLESERVER_REQUESTPROCESSINGPOLICY___OUT_CH_ + +class TAO_Export RequestProcessingPolicy_out +{ +public: + RequestProcessingPolicy_out (RequestProcessingPolicy_ptr &); + RequestProcessingPolicy_out (RequestProcessingPolicy_var &); + RequestProcessingPolicy_out (const RequestProcessingPolicy_out &); + RequestProcessingPolicy_out &operator= (const RequestProcessingPolicy_out &); + RequestProcessingPolicy_out &operator= (const RequestProcessingPolicy_var &); + RequestProcessingPolicy_out &operator= (RequestProcessingPolicy_ptr); + operator RequestProcessingPolicy_ptr &(); + RequestProcessingPolicy_ptr &ptr (void); + RequestProcessingPolicy_ptr operator-> (void); + +private: + RequestProcessingPolicy_ptr &ptr_; +}; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_REQUESTPROCESSINGPOLICY_CH_) +#define _PORTABLESERVER_REQUESTPROCESSINGPOLICY_CH_ + +class TAO_Export RequestProcessingPolicy: public virtual CORBA::Policy +{ +public: +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef RequestProcessingPolicy_ptr _ptr_type; + typedef RequestProcessingPolicy_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations + static RequestProcessingPolicy_ptr _duplicate (RequestProcessingPolicy_ptr obj); + static RequestProcessingPolicy_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static RequestProcessingPolicy_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static RequestProcessingPolicy_ptr _nil (void) + { + return (RequestProcessingPolicy_ptr)0; + } + + virtual PortableServer::RequestProcessingPolicyValue value ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + virtual void *_tao_QueryInterface (ptr_arith_t type); + + virtual const char* _interface_repository_id (void) const; + +protected: + RequestProcessingPolicy (void); + virtual ~RequestProcessingPolicy (void); +private: + RequestProcessingPolicy (const RequestProcessingPolicy &); + void operator= (const RequestProcessingPolicy &); +}; + + +#endif /* end #if !defined */ + +#endif /* TAO_HAS_MINIMUM_POA == 0 */ + +#if !defined (_PORTABLESERVER_POAMANAGER___PTR_CH_) +#define _PORTABLESERVER_POAMANAGER___PTR_CH_ + +class POAManager; +typedef POAManager *POAManager_ptr; + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_POAMANAGER___VAR_CH_) +#define _PORTABLESERVER_POAMANAGER___VAR_CH_ + +class TAO_Export POAManager_var : public TAO_Base_var +{ +public: + POAManager_var (void); // default constructor + POAManager_var (POAManager_ptr p) : ptr_ (p) {} + POAManager_var (const POAManager_var &); // copy constructor + ~POAManager_var (void); // destructor + + POAManager_var &operator= (POAManager_ptr); + POAManager_var &operator= (const POAManager_var &); + POAManager_ptr operator-> (void) const; + + operator const POAManager_ptr &() const; + operator POAManager_ptr &(); + // in, inout, out, _retn + POAManager_ptr in (void) const; + POAManager_ptr &inout (void); + POAManager_ptr &out (void); + POAManager_ptr _retn (void); + POAManager_ptr ptr (void) const; + +private: + POAManager_ptr ptr_; + // Unimplemented - prevents widening assignment. + POAManager_var (const TAO_Base_var &rhs); + POAManager_var &operator= (const TAO_Base_var &rhs); +}; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_POAMANAGER___OUT_CH_) +#define _PORTABLESERVER_POAMANAGER___OUT_CH_ + +class TAO_Export POAManager_out +{ +public: + POAManager_out (POAManager_ptr &); + POAManager_out (POAManager_var &); + POAManager_out (const POAManager_out &); + POAManager_out &operator= (const POAManager_out &); + POAManager_out &operator= (const POAManager_var &); + POAManager_out &operator= (POAManager_ptr); + operator POAManager_ptr &(); + POAManager_ptr &ptr (void); + POAManager_ptr operator-> (void); + +private: + POAManager_ptr &ptr_; +}; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_POAMANAGER_CH_) +#define _PORTABLESERVER_POAMANAGER_CH_ + +class TAO_Export POAManager : public virtual CORBA_Object +{ +public: +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef POAManager_ptr _ptr_type; + typedef POAManager_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations + static POAManager_ptr _duplicate (POAManager_ptr obj); + static POAManager_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static POAManager_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static POAManager_ptr _nil (void) + { + return (POAManager_ptr)0; + } + + +#if !defined (_PORTABLESERVER_POAMANAGER_ADAPTERINACTIVE_CH_) +#define _PORTABLESERVER_POAMANAGER_ADAPTERINACTIVE_CH_ + + class TAO_Export AdapterInactive : public CORBA::UserException + { + public: + + + AdapterInactive (void); // default ctor + AdapterInactive (const AdapterInactive &); // copy ctor + ~AdapterInactive (void); + AdapterInactive &operator= (const AdapterInactive &); + + + virtual void _raise (void); + + virtual void _tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &) const; + virtual void _tao_decode ( + TAO_InputCDR &, + CORBA::Environment &); + + static AdapterInactive *_downcast (CORBA::Exception *); + + + // = TAO extension + static CORBA::Exception *_alloc (void); + +}; // exception PortableServer::POAManager::AdapterInactive + + +#endif /* end #if !defined */ + +enum State +{ + HOLDING, + ACTIVE, + DISCARDING, + INACTIVE, + State_TAO_ENUM_32BIT_ENFORCER = 0x7FFFFFFF +}; +typedef State &State_out; +virtual void activate ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + PortableServer::POAManager::AdapterInactive + )) = 0; + +#if (TAO_HAS_MINIMUM_POA == 0) + +virtual void hold_requests ( + CORBA::Boolean wait_for_completion, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + PortableServer::POAManager::AdapterInactive + )) = 0; + +virtual void discard_requests ( + CORBA::Boolean wait_for_completion, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + PortableServer::POAManager::AdapterInactive + )) = 0; + +virtual void deactivate ( + CORBA::Boolean etherealize_objects, + CORBA::Boolean wait_for_completion, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + PortableServer::POAManager::AdapterInactive + )) = 0; + +#endif /* TAO_HAS_MINIMUM_POA == 0 */ + +virtual PortableServer::POAManager::State get_state ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +virtual void *_tao_QueryInterface (ptr_arith_t type); + +virtual const char* _interface_repository_id (void) const; + +protected: + POAManager (void); + virtual ~POAManager (void); +private: + POAManager (const POAManager &); + void operator= (const POAManager &); +}; + + +#endif /* end #if !defined */ + + +#if (TAO_HAS_MINIMUM_POA == 0) + +#if !defined (_PORTABLESERVER_ADAPTERACTIVATOR___PTR_CH_) +#define _PORTABLESERVER_ADAPTERACTIVATOR___PTR_CH_ + +class AdapterActivator; +typedef AdapterActivator *AdapterActivator_ptr; + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_ADAPTERACTIVATOR___VAR_CH_) +#define _PORTABLESERVER_ADAPTERACTIVATOR___VAR_CH_ + +class TAO_Export AdapterActivator_var : public TAO_Base_var +{ +public: + AdapterActivator_var (void); // default constructor + AdapterActivator_var (AdapterActivator_ptr p) : ptr_ (p) {} + AdapterActivator_var (const AdapterActivator_var &); // copy constructor + ~AdapterActivator_var (void); // destructor + + AdapterActivator_var &operator= (AdapterActivator_ptr); + AdapterActivator_var &operator= (const AdapterActivator_var &); + AdapterActivator_ptr operator-> (void) const; + + operator const AdapterActivator_ptr &() const; + operator AdapterActivator_ptr &(); + // in, inout, out, _retn + AdapterActivator_ptr in (void) const; + AdapterActivator_ptr &inout (void); + AdapterActivator_ptr &out (void); + AdapterActivator_ptr _retn (void); + AdapterActivator_ptr ptr (void) const; + +private: + AdapterActivator_ptr ptr_; + // Unimplemented - prevents widening assignment. + AdapterActivator_var (const TAO_Base_var &rhs); + AdapterActivator_var &operator= (const TAO_Base_var &rhs); +}; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_ADAPTERACTIVATOR___OUT_CH_) +#define _PORTABLESERVER_ADAPTERACTIVATOR___OUT_CH_ + +class TAO_Export AdapterActivator_out +{ +public: + AdapterActivator_out (AdapterActivator_ptr &); + AdapterActivator_out (AdapterActivator_var &); + AdapterActivator_out (const AdapterActivator_out &); + AdapterActivator_out &operator= (const AdapterActivator_out &); + AdapterActivator_out &operator= (const AdapterActivator_var &); + AdapterActivator_out &operator= (AdapterActivator_ptr); + operator AdapterActivator_ptr &(); + AdapterActivator_ptr &ptr (void); + AdapterActivator_ptr operator-> (void); + +private: + AdapterActivator_ptr &ptr_; +}; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_ADAPTERACTIVATOR_CH_) +#define _PORTABLESERVER_ADAPTERACTIVATOR_CH_ + +class TAO_Export AdapterActivator : public virtual CORBA_Object +{ +public: +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef AdapterActivator_ptr _ptr_type; + typedef AdapterActivator_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations + static AdapterActivator_ptr _duplicate (AdapterActivator_ptr obj); + static AdapterActivator_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static AdapterActivator_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static AdapterActivator_ptr _nil (void) + { + return (AdapterActivator_ptr)0; + } + + virtual CORBA::Boolean unknown_adapter ( + PortableServer::POA_ptr parent, + const char * name, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + virtual void *_tao_QueryInterface (ptr_arith_t type); + + virtual const char* _interface_repository_id (void) const; + +protected: + AdapterActivator (void); + virtual ~AdapterActivator (void); +private: + AdapterActivator (const AdapterActivator &); + void operator= (const AdapterActivator &); +}; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_SERVANTMANAGER___PTR_CH_) +#define _PORTABLESERVER_SERVANTMANAGER___PTR_CH_ + +class ServantManager; +typedef ServantManager *ServantManager_ptr; + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_SERVANTMANAGER___VAR_CH_) +#define _PORTABLESERVER_SERVANTMANAGER___VAR_CH_ + +class TAO_Export ServantManager_var : public TAO_Base_var +{ +public: + ServantManager_var (void); // default constructor + ServantManager_var (ServantManager_ptr p) : ptr_ (p) {} + ServantManager_var (const ServantManager_var &); // copy constructor + ~ServantManager_var (void); // destructor + + ServantManager_var &operator= (ServantManager_ptr); + ServantManager_var &operator= (const ServantManager_var &); + ServantManager_ptr operator-> (void) const; + + operator const ServantManager_ptr &() const; + operator ServantManager_ptr &(); + // in, inout, out, _retn + ServantManager_ptr in (void) const; + ServantManager_ptr &inout (void); + ServantManager_ptr &out (void); + ServantManager_ptr _retn (void); + ServantManager_ptr ptr (void) const; + +private: + ServantManager_ptr ptr_; + // Unimplemented - prevents widening assignment. + ServantManager_var (const TAO_Base_var &rhs); + ServantManager_var &operator= (const TAO_Base_var &rhs); +}; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_SERVANTMANAGER___OUT_CH_) +#define _PORTABLESERVER_SERVANTMANAGER___OUT_CH_ + +class TAO_Export ServantManager_out +{ +public: + ServantManager_out (ServantManager_ptr &); + ServantManager_out (ServantManager_var &); + ServantManager_out (const ServantManager_out &); + ServantManager_out &operator= (const ServantManager_out &); + ServantManager_out &operator= (const ServantManager_var &); + ServantManager_out &operator= (ServantManager_ptr); + operator ServantManager_ptr &(); + ServantManager_ptr &ptr (void); + ServantManager_ptr operator-> (void); + +private: + ServantManager_ptr &ptr_; +}; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_SERVANTMANAGER_CH_) +#define _PORTABLESERVER_SERVANTMANAGER_CH_ + +class TAO_Export ServantManager : public virtual CORBA_Object +{ +public: +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef ServantManager_ptr _ptr_type; + typedef ServantManager_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations + static ServantManager_ptr _duplicate (ServantManager_ptr obj); + static ServantManager_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static ServantManager_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static ServantManager_ptr _nil (void) + { + return (ServantManager_ptr)0; + } + + virtual void *_tao_QueryInterface (ptr_arith_t type); + + virtual const char* _interface_repository_id (void) const; + +protected: + ServantManager (void); + virtual ~ServantManager (void); +private: + ServantManager (const ServantManager &); + void operator= (const ServantManager &); +}; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_SERVANTACTIVATOR___PTR_CH_) +#define _PORTABLESERVER_SERVANTACTIVATOR___PTR_CH_ + +class ServantActivator; +typedef ServantActivator *ServantActivator_ptr; + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_SERVANTACTIVATOR___VAR_CH_) +#define _PORTABLESERVER_SERVANTACTIVATOR___VAR_CH_ + +class TAO_Export ServantActivator_var : public TAO_Base_var +{ +public: + ServantActivator_var (void); // default constructor + ServantActivator_var (ServantActivator_ptr p) : ptr_ (p) {} + ServantActivator_var (const ServantActivator_var &); // copy constructor + ~ServantActivator_var (void); // destructor + + ServantActivator_var &operator= (ServantActivator_ptr); + ServantActivator_var &operator= (const ServantActivator_var &); + ServantActivator_ptr operator-> (void) const; + + operator const ServantActivator_ptr &() const; + operator ServantActivator_ptr &(); + // in, inout, out, _retn + ServantActivator_ptr in (void) const; + ServantActivator_ptr &inout (void); + ServantActivator_ptr &out (void); + ServantActivator_ptr _retn (void); + ServantActivator_ptr ptr (void) const; + +private: + ServantActivator_ptr ptr_; + // Unimplemented - prevents widening assignment. + ServantActivator_var (const TAO_Base_var &rhs); + ServantActivator_var &operator= (const TAO_Base_var &rhs); +}; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_SERVANTACTIVATOR___OUT_CH_) +#define _PORTABLESERVER_SERVANTACTIVATOR___OUT_CH_ + +class TAO_Export ServantActivator_out +{ +public: + ServantActivator_out (ServantActivator_ptr &); + ServantActivator_out (ServantActivator_var &); + ServantActivator_out (const ServantActivator_out &); + ServantActivator_out &operator= (const ServantActivator_out &); + ServantActivator_out &operator= (const ServantActivator_var &); + ServantActivator_out &operator= (ServantActivator_ptr); + operator ServantActivator_ptr &(); + ServantActivator_ptr &ptr (void); + ServantActivator_ptr operator-> (void); + +private: + ServantActivator_ptr &ptr_; +}; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_SERVANTACTIVATOR_CH_) +#define _PORTABLESERVER_SERVANTACTIVATOR_CH_ + +class TAO_Export ServantActivator: public virtual ServantManager +{ +public: +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef ServantActivator_ptr _ptr_type; + typedef ServantActivator_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations + static ServantActivator_ptr _duplicate (ServantActivator_ptr obj); + static ServantActivator_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static ServantActivator_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static ServantActivator_ptr _nil (void) + { + return (ServantActivator_ptr)0; + } + + virtual PortableServer::Servant incarnate ( + const PortableServer::ObjectId & oid, + PortableServer::POA_ptr adapter + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) +#if (TAO_HAS_MINIMUM_CORBA == 0) + ACE_THROW_SPEC (( + CORBA::SystemException, + PortableServer::ForwardRequest + )) = 0; +#else + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; +#endif /* TAO_HAS_MINIMUM_CORBA == 0 */ + + virtual void etherealize ( + const PortableServer::ObjectId & oid, + PortableServer::POA_ptr adapter, + PortableServer::Servant serv, + CORBA::Boolean cleanup_in_progress, + CORBA::Boolean remaining_activations + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + virtual void *_tao_QueryInterface (ptr_arith_t type); + + virtual const char* _interface_repository_id (void) const; + +protected: + ServantActivator (void); + virtual ~ServantActivator (void); +private: + ServantActivator (const ServantActivator &); + void operator= (const ServantActivator &); +}; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_SERVANTLOCATOR___PTR_CH_) +#define _PORTABLESERVER_SERVANTLOCATOR___PTR_CH_ + +class ServantLocator; +typedef ServantLocator *ServantLocator_ptr; + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_SERVANTLOCATOR___VAR_CH_) +#define _PORTABLESERVER_SERVANTLOCATOR___VAR_CH_ + +class TAO_Export ServantLocator_var : public TAO_Base_var +{ +public: + ServantLocator_var (void); // default constructor + ServantLocator_var (ServantLocator_ptr p) : ptr_ (p) {} + ServantLocator_var (const ServantLocator_var &); // copy constructor + ~ServantLocator_var (void); // destructor + + ServantLocator_var &operator= (ServantLocator_ptr); + ServantLocator_var &operator= (const ServantLocator_var &); + ServantLocator_ptr operator-> (void) const; + + operator const ServantLocator_ptr &() const; + operator ServantLocator_ptr &(); + // in, inout, out, _retn + ServantLocator_ptr in (void) const; + ServantLocator_ptr &inout (void); + ServantLocator_ptr &out (void); + ServantLocator_ptr _retn (void); + ServantLocator_ptr ptr (void) const; + +private: + ServantLocator_ptr ptr_; + // Unimplemented - prevents widening assignment. + ServantLocator_var (const TAO_Base_var &rhs); + ServantLocator_var &operator= (const TAO_Base_var &rhs); +}; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_SERVANTLOCATOR___OUT_CH_) +#define _PORTABLESERVER_SERVANTLOCATOR___OUT_CH_ + +class TAO_Export ServantLocator_out +{ +public: + ServantLocator_out (ServantLocator_ptr &); + ServantLocator_out (ServantLocator_var &); + ServantLocator_out (const ServantLocator_out &); + ServantLocator_out &operator= (const ServantLocator_out &); + ServantLocator_out &operator= (const ServantLocator_var &); + ServantLocator_out &operator= (ServantLocator_ptr); + operator ServantLocator_ptr &(); + ServantLocator_ptr &ptr (void); + ServantLocator_ptr operator-> (void); + +private: + ServantLocator_ptr &ptr_; +}; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_SERVANTLOCATOR_CH_) +#define _PORTABLESERVER_SERVANTLOCATOR_CH_ + +class TAO_Export ServantLocator: public virtual ServantManager +{ +public: + + typedef void *Cookie; + +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef ServantLocator_ptr _ptr_type; + typedef ServantLocator_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations + static ServantLocator_ptr _duplicate (ServantLocator_ptr obj); + static ServantLocator_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static ServantLocator_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static ServantLocator_ptr _nil (void) + { + return (ServantLocator_ptr)0; + } + + virtual PortableServer::Servant preinvoke ( + const PortableServer::ObjectId & oid, + PortableServer::POA_ptr adapter, + const char * operation, + PortableServer::ServantLocator::Cookie & the_cookie + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) +#if (TAO_HAS_MINIMUM_CORBA == 0) + ACE_THROW_SPEC (( + CORBA::SystemException, + PortableServer::ForwardRequest + )) = 0; +#else + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; +#endif /* TAO_HAS_MINIMUM_CORBA == 0 */ + + virtual void postinvoke ( + const PortableServer::ObjectId & oid, + PortableServer::POA_ptr adapter, + const char * operation, + PortableServer::ServantLocator::Cookie the_cookie, + PortableServer::Servant the_servant + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + virtual void *_tao_QueryInterface (ptr_arith_t type); + + virtual const char* _interface_repository_id (void) const; + +protected: + ServantLocator (void); + virtual ~ServantLocator (void); +private: + ServantLocator (const ServantLocator &); + void operator= (const ServantLocator &); +}; + + +#endif /* end #if !defined */ + + +#endif /* TAO_HAS_MINIMUM_POA == 0 */ + +#if !defined (_PORTABLESERVER_POA___PTR_CH_) +#define _PORTABLESERVER_POA___PTR_CH_ + +class POA; +typedef POA *POA_ptr; + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_POA___VAR_CH_) +#define _PORTABLESERVER_POA___VAR_CH_ + +class TAO_Export POA_var : public TAO_Base_var +{ +public: + POA_var (void); // default constructor + POA_var (POA_ptr p) : ptr_ (p) {} + POA_var (const POA_var &); // copy constructor + ~POA_var (void); // destructor + + POA_var &operator= (POA_ptr); + POA_var &operator= (const POA_var &); + POA_ptr operator-> (void) const; + + operator const POA_ptr &() const; + operator POA_ptr &(); + // in, inout, out, _retn + POA_ptr in (void) const; + POA_ptr &inout (void); + POA_ptr &out (void); + POA_ptr _retn (void); + POA_ptr ptr (void) const; + +private: + POA_ptr ptr_; + // Unimplemented - prevents widening assignment. + POA_var (const TAO_Base_var &rhs); + POA_var &operator= (const TAO_Base_var &rhs); +}; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_POA___OUT_CH_) +#define _PORTABLESERVER_POA___OUT_CH_ + +class TAO_Export POA_out +{ +public: + POA_out (POA_ptr &); + POA_out (POA_var &); + POA_out (const POA_out &); + POA_out &operator= (const POA_out &); + POA_out &operator= (const POA_var &); + POA_out &operator= (POA_ptr); + operator POA_ptr &(); + POA_ptr &ptr (void); + POA_ptr operator-> (void); + +private: + POA_ptr &ptr_; +}; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_POA_CH_) +#define _PORTABLESERVER_POA_CH_ + +class TAO_Export POA : public virtual CORBA_Object +{ +public: +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef POA_ptr _ptr_type; + typedef POA_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations + static POA_ptr _duplicate (POA_ptr obj); + static POA_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static POA_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static POA_ptr _nil (void) + { + return (POA_ptr)0; + } + + +#if !defined (_PORTABLESERVER_POA_ADAPTERALREADYEXISTS_CH_) +#define _PORTABLESERVER_POA_ADAPTERALREADYEXISTS_CH_ + + class TAO_Export AdapterAlreadyExists : public CORBA::UserException + { + public: + + + AdapterAlreadyExists (void); // default ctor + AdapterAlreadyExists (const AdapterAlreadyExists &); // copy ctor + ~AdapterAlreadyExists (void); + AdapterAlreadyExists &operator= (const AdapterAlreadyExists &); + + + virtual void _raise (void); + + virtual void _tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &) const; + virtual void _tao_decode ( + TAO_InputCDR &, + CORBA::Environment &); + + static AdapterAlreadyExists *_downcast (CORBA::Exception *); + + + // = TAO extension + static CORBA::Exception *_alloc (void); + +}; // exception PortableServer::POA::AdapterAlreadyExists + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_POA_ADAPTERNONEXISTENT_CH_) +#define _PORTABLESERVER_POA_ADAPTERNONEXISTENT_CH_ + +class TAO_Export AdapterNonExistent : public CORBA::UserException +{ +public: + + +AdapterNonExistent (void); // default ctor +AdapterNonExistent (const AdapterNonExistent &); // copy ctor +~AdapterNonExistent (void); +AdapterNonExistent &operator= (const AdapterNonExistent &); + + +virtual void _raise (void); + +virtual void _tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &) const; +virtual void _tao_decode ( + TAO_InputCDR &, + CORBA::Environment &); + +static AdapterNonExistent *_downcast (CORBA::Exception *); + + +// = TAO extension +static CORBA::Exception *_alloc (void); + +}; // exception PortableServer::POA::AdapterNonExistent + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_POA_INVALIDPOLICY_CH_) +#define _PORTABLESERVER_POA_INVALIDPOLICY_CH_ + +class TAO_Export InvalidPolicy : public CORBA::UserException +{ +public: + +CORBA::UShort index; + +InvalidPolicy (void); // default ctor +InvalidPolicy (const InvalidPolicy &); // copy ctor +~InvalidPolicy (void); +InvalidPolicy &operator= (const InvalidPolicy &); + + +virtual void _raise (void); + +virtual void _tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &) const; +virtual void _tao_decode ( + TAO_InputCDR &, + CORBA::Environment &); + +static InvalidPolicy *_downcast (CORBA::Exception *); + +InvalidPolicy ( + CORBA::UShort _tao_index +); + +// = TAO extension +static CORBA::Exception *_alloc (void); + +}; // exception PortableServer::POA::InvalidPolicy + + +#endif /* end #if !defined */ + + +#if (TAO_HAS_MINIMUM_POA == 0) + +#if !defined (_PORTABLESERVER_POA_NOSERVANT_CH_) +#define _PORTABLESERVER_POA_NOSERVANT_CH_ + +class TAO_Export NoServant : public CORBA::UserException +{ +public: + + +NoServant (void); // default ctor +NoServant (const NoServant &); // copy ctor +~NoServant (void); +NoServant &operator= (const NoServant &); + + +virtual void _raise (void); + +virtual void _tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &) const; +virtual void _tao_decode ( + TAO_InputCDR &, + CORBA::Environment &); + +static NoServant *_downcast (CORBA::Exception *); + + +// = TAO extension +static CORBA::Exception *_alloc (void); + +}; // exception PortableServer::POA::NoServant + + +#endif /* end #if !defined */ + +#endif /* TAO_HAS_MINIMUM_POA == 0 */ + +#if !defined (_PORTABLESERVER_POA_OBJECTALREADYACTIVE_CH_) +#define _PORTABLESERVER_POA_OBJECTALREADYACTIVE_CH_ + +class TAO_Export ObjectAlreadyActive : public CORBA::UserException +{ +public: + + +ObjectAlreadyActive (void); // default ctor +ObjectAlreadyActive (const ObjectAlreadyActive &); // copy ctor +~ObjectAlreadyActive (void); +ObjectAlreadyActive &operator= (const ObjectAlreadyActive &); + + +virtual void _raise (void); + +virtual void _tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &) const; +virtual void _tao_decode ( + TAO_InputCDR &, + CORBA::Environment &); + +static ObjectAlreadyActive *_downcast (CORBA::Exception *); + + +// = TAO extension +static CORBA::Exception *_alloc (void); + +}; // exception PortableServer::POA::ObjectAlreadyActive + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_POA_OBJECTNOTACTIVE_CH_) +#define _PORTABLESERVER_POA_OBJECTNOTACTIVE_CH_ + +class TAO_Export ObjectNotActive : public CORBA::UserException +{ +public: + + +ObjectNotActive (void); // default ctor +ObjectNotActive (const ObjectNotActive &); // copy ctor +~ObjectNotActive (void); +ObjectNotActive &operator= (const ObjectNotActive &); + + +virtual void _raise (void); + +virtual void _tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &) const; +virtual void _tao_decode ( + TAO_InputCDR &, + CORBA::Environment &); + +static ObjectNotActive *_downcast (CORBA::Exception *); + + +// = TAO extension +static CORBA::Exception *_alloc (void); + +}; // exception PortableServer::POA::ObjectNotActive + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_POA_SERVANTALREADYACTIVE_CH_) +#define _PORTABLESERVER_POA_SERVANTALREADYACTIVE_CH_ + +class TAO_Export ServantAlreadyActive : public CORBA::UserException +{ +public: + + +ServantAlreadyActive (void); // default ctor +ServantAlreadyActive (const ServantAlreadyActive &); // copy ctor +~ServantAlreadyActive (void); +ServantAlreadyActive &operator= (const ServantAlreadyActive &); + + +virtual void _raise (void); + +virtual void _tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &) const; +virtual void _tao_decode ( + TAO_InputCDR &, + CORBA::Environment &); + +static ServantAlreadyActive *_downcast (CORBA::Exception *); + + +// = TAO extension +static CORBA::Exception *_alloc (void); + +}; // exception PortableServer::POA::ServantAlreadyActive + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_POA_SERVANTNOTACTIVE_CH_) +#define _PORTABLESERVER_POA_SERVANTNOTACTIVE_CH_ + +class TAO_Export ServantNotActive : public CORBA::UserException +{ +public: + + +ServantNotActive (void); // default ctor +ServantNotActive (const ServantNotActive &); // copy ctor +~ServantNotActive (void); +ServantNotActive &operator= (const ServantNotActive &); + + +virtual void _raise (void); + +virtual void _tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &) const; +virtual void _tao_decode ( + TAO_InputCDR &, + CORBA::Environment &); + +static ServantNotActive *_downcast (CORBA::Exception *); + + +// = TAO extension +static CORBA::Exception *_alloc (void); + +}; // exception PortableServer::POA::ServantNotActive + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_POA_WRONGADAPTER_CH_) +#define _PORTABLESERVER_POA_WRONGADAPTER_CH_ + +class TAO_Export WrongAdapter : public CORBA::UserException +{ +public: + + +WrongAdapter (void); // default ctor +WrongAdapter (const WrongAdapter &); // copy ctor +~WrongAdapter (void); +WrongAdapter &operator= (const WrongAdapter &); + + +virtual void _raise (void); + +virtual void _tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &) const; +virtual void _tao_decode ( + TAO_InputCDR &, + CORBA::Environment &); + +static WrongAdapter *_downcast (CORBA::Exception *); + + +// = TAO extension +static CORBA::Exception *_alloc (void); + +}; // exception PortableServer::POA::WrongAdapter + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_POA_WRONGPOLICY_CH_) +#define _PORTABLESERVER_POA_WRONGPOLICY_CH_ + +class TAO_Export WrongPolicy : public CORBA::UserException +{ +public: + + +WrongPolicy (void); // default ctor +WrongPolicy (const WrongPolicy &); // copy ctor +~WrongPolicy (void); +WrongPolicy &operator= (const WrongPolicy &); + + +virtual void _raise (void); + +virtual void _tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &) const; +virtual void _tao_decode ( + TAO_InputCDR &, + CORBA::Environment &); + +static WrongPolicy *_downcast (CORBA::Exception *); + + +// = TAO extension +static CORBA::Exception *_alloc (void); + +}; // exception PortableServer::POA::WrongPolicy + + +#endif /* end #if !defined */ + +virtual PortableServer::POA_ptr create_POA ( + const char * adapter_name, + PortableServer::POAManager_ptr a_POAManager, + const CORBA::PolicyList & policies, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + PortableServer::POA::AdapterAlreadyExists, + PortableServer::POA::InvalidPolicy + )) = 0; + +virtual PortableServer::POA_ptr find_POA ( + const char * adapter_name, + CORBA::Boolean activate_it, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + PortableServer::POA::AdapterNonExistent + )) = 0; + +virtual void destroy ( + CORBA::Boolean etherealize_objects, + CORBA::Boolean wait_for_completion, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +#if (TAO_HAS_MINIMUM_POA == 0) + +virtual PortableServer::ThreadPolicy_ptr create_thread_policy ( + PortableServer::ThreadPolicyValue value, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +#endif /* TAO_HAS_MINIMUM_POA == 0 */ + +virtual PortableServer::LifespanPolicy_ptr create_lifespan_policy ( + PortableServer::LifespanPolicyValue value, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +virtual PortableServer::IdUniquenessPolicy_ptr create_id_uniqueness_policy ( + PortableServer::IdUniquenessPolicyValue value, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +virtual PortableServer::IdAssignmentPolicy_ptr create_id_assignment_policy ( + PortableServer::IdAssignmentPolicyValue value, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +#if (TAO_HAS_MINIMUM_POA == 0) + +virtual PortableServer::ImplicitActivationPolicy_ptr create_implicit_activation_policy ( + PortableServer::ImplicitActivationPolicyValue value, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +virtual PortableServer::ServantRetentionPolicy_ptr create_servant_retention_policy ( + PortableServer::ServantRetentionPolicyValue value, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +virtual PortableServer::RequestProcessingPolicy_ptr create_request_processing_policy ( + PortableServer::RequestProcessingPolicyValue value, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +#endif /* TAO_HAS_MINIMUM_POA == 0 */ + +virtual char * the_name ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +virtual PortableServer::POA_ptr the_parent ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +virtual PortableServer::POAList * the_children ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +virtual PortableServer::POAManager_ptr the_POAManager ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +#if (TAO_HAS_MINIMUM_POA == 0) + +virtual PortableServer::AdapterActivator_ptr the_activator ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +virtual void the_activator ( + PortableServer::AdapterActivator_ptr the_activator, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +virtual PortableServer::ServantManager_ptr get_servant_manager ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + PortableServer::POA::WrongPolicy + )) = 0; + +virtual void set_servant_manager ( + PortableServer::ServantManager_ptr imgr, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + PortableServer::POA::WrongPolicy + )) = 0; + +virtual PortableServer::Servant get_servant ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + PortableServer::POA::NoServant, + PortableServer::POA::WrongPolicy + )) = 0; + +virtual void set_servant ( + PortableServer::Servant p_servant, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + PortableServer::POA::WrongPolicy + )) = 0; + +#endif /* TAO_HAS_MINIMUM_POA == 0 */ + +virtual PortableServer::ObjectId * activate_object ( + PortableServer::Servant p_servant, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + PortableServer::POA::ServantAlreadyActive, + PortableServer::POA::WrongPolicy + )) = 0; + +virtual void activate_object_with_id ( + const PortableServer::ObjectId & id, + PortableServer::Servant p_servant, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + PortableServer::POA::ServantAlreadyActive, + PortableServer::POA::ObjectAlreadyActive, + PortableServer::POA::WrongPolicy + )) = 0; + +virtual void deactivate_object ( + const PortableServer::ObjectId & oid, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + PortableServer::POA::ObjectNotActive, + PortableServer::POA::WrongPolicy + )) = 0; + +virtual CORBA::Object_ptr create_reference ( + const char * intf, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + PortableServer::POA::WrongPolicy + )) = 0; + +virtual CORBA::Object_ptr create_reference_with_id ( + const PortableServer::ObjectId & oid, + const char * intf, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + PortableServer::POA::WrongPolicy + )) = 0; + +virtual PortableServer::ObjectId * servant_to_id ( + PortableServer::Servant p_servant, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + PortableServer::POA::ServantNotActive, + PortableServer::POA::WrongPolicy + )) = 0; + +virtual CORBA::Object_ptr servant_to_reference ( + PortableServer::Servant p_servant, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + PortableServer::POA::ServantNotActive, + PortableServer::POA::WrongPolicy + )) = 0; + +virtual PortableServer::Servant reference_to_servant ( + CORBA::Object_ptr reference, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + PortableServer::POA::ObjectNotActive, + PortableServer::POA::WrongPolicy + )) = 0; + +virtual PortableServer::ObjectId * reference_to_id ( + CORBA::Object_ptr reference, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + PortableServer::POA::WrongAdapter, + PortableServer::POA::WrongPolicy + )) = 0; + +virtual PortableServer::Servant id_to_servant ( + const PortableServer::ObjectId & oid, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + PortableServer::POA::ObjectNotActive, + PortableServer::POA::WrongPolicy + )) = 0; + +virtual CORBA::Object_ptr id_to_reference ( + const PortableServer::ObjectId & oid, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + PortableServer::POA::ObjectNotActive, + PortableServer::POA::WrongPolicy + )) = 0; + +virtual void *_tao_QueryInterface (ptr_arith_t type); + +virtual const char* _interface_repository_id (void) const; + +protected: + POA (void); + virtual ~POA (void); +private: + POA (const POA &); + void operator= (const POA &); +}; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_CURRENT___PTR_CH_) +#define _PORTABLESERVER_CURRENT___PTR_CH_ + +class Current; +typedef Current *Current_ptr; + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_CURRENT___VAR_CH_) +#define _PORTABLESERVER_CURRENT___VAR_CH_ + +class TAO_Export Current_var : public TAO_Base_var +{ +public: + Current_var (void); // default constructor + Current_var (Current_ptr p) : ptr_ (p) {} + Current_var (const Current_var &); // copy constructor + ~Current_var (void); // destructor + + Current_var &operator= (Current_ptr); + Current_var &operator= (const Current_var &); + Current_ptr operator-> (void) const; + + operator const Current_ptr &() const; + operator Current_ptr &(); + // in, inout, out, _retn + Current_ptr in (void) const; + Current_ptr &inout (void); + Current_ptr &out (void); + Current_ptr _retn (void); + Current_ptr ptr (void) const; + +private: + Current_ptr ptr_; + // Unimplemented - prevents widening assignment. + Current_var (const TAO_Base_var &rhs); + Current_var &operator= (const TAO_Base_var &rhs); +}; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_CURRENT___OUT_CH_) +#define _PORTABLESERVER_CURRENT___OUT_CH_ + +class TAO_Export Current_out +{ +public: + Current_out (Current_ptr &); + Current_out (Current_var &); + Current_out (const Current_out &); + Current_out &operator= (const Current_out &); + Current_out &operator= (const Current_var &); + Current_out &operator= (Current_ptr); + operator Current_ptr &(); + Current_ptr &ptr (void); + Current_ptr operator-> (void); + +private: + Current_ptr &ptr_; +}; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_CURRENT_CH_) +#define _PORTABLESERVER_CURRENT_CH_ + +class TAO_Export Current: public virtual CORBA::Current +{ +public: +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef Current_ptr _ptr_type; + typedef Current_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations + static Current_ptr _duplicate (Current_ptr obj); + static Current_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static Current_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static Current_ptr _nil (void) + { + return (Current_ptr)0; + } + + +#if !defined (_PORTABLESERVER_CURRENT_NOCONTEXT_CH_) +#define _PORTABLESERVER_CURRENT_NOCONTEXT_CH_ + + class TAO_Export NoContext : public CORBA::UserException + { + public: + + + NoContext (void); // default ctor + NoContext (const NoContext &); // copy ctor + ~NoContext (void); + NoContext &operator= (const NoContext &); + + + virtual void _raise (void); + + virtual void _tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &) const; + virtual void _tao_decode ( + TAO_InputCDR &, + CORBA::Environment &); + + static NoContext *_downcast (CORBA::Exception *); + + + // = TAO extension + static CORBA::Exception *_alloc (void); + +}; // exception PortableServer::Current::NoContext + + +#endif /* end #if !defined */ + +virtual PortableServer::POA_ptr get_POA ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + PortableServer::Current::NoContext + )) = 0; + +virtual PortableServer::ObjectId * get_object_id ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + PortableServer::Current::NoContext + )) = 0; + +virtual void *_tao_QueryInterface (ptr_arith_t type); + +virtual const char* _interface_repository_id (void) const; + +protected: + Current (void); + virtual ~Current (void); +private: + Current (const Current &); + void operator= (const Current &); +}; + + +#endif /* end #if !defined */ + + TAO_NAMESPACE_STORAGE_CLASS char *ObjectId_to_string (const PortableServer::ObjectId &id); + TAO_NAMESPACE_STORAGE_CLASS CORBA::WChar *ObjectId_to_wstring (const PortableServer::ObjectId &id); + TAO_NAMESPACE_STORAGE_CLASS PortableServer::ObjectId *string_to_ObjectId (const char *id); + TAO_NAMESPACE_STORAGE_CLASS PortableServer::ObjectId *wstring_to_ObjectId (const CORBA::WChar *id); + +} +TAO_NAMESPACE_CLOSE // module PortableServer + +TAO_Export void operator<<= (CORBA::Any &, const PortableServer::ObjectId &); // copying version +TAO_Export void operator<<= (CORBA::Any &, PortableServer::ObjectId*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::ObjectId *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const PortableServer::ObjectId *&); + +#if (TAO_HAS_MINIMUM_CORBA == 0) + +TAO_Export void operator<<= (CORBA::Any &, const PortableServer::ForwardRequest &); // copying version +TAO_Export void operator<<= (CORBA::Any &, PortableServer::ForwardRequest*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::ForwardRequest *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const PortableServer::ForwardRequest *&); + +#endif /* TAO_HAS_MINIMUM_CORBA == 0 */ + +#if (TAO_HAS_MINIMUM_POA == 0) + +TAO_Export void operator<<= (CORBA::Any &, PortableServer::ThreadPolicyValue); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::ThreadPolicyValue &); + +#endif /* TAO_HAS_MINIMUM_POA == 0 */ + +TAO_Export void operator<<= (CORBA::Any &, PortableServer::LifespanPolicyValue); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::LifespanPolicyValue &); +TAO_Export void operator<<= (CORBA::Any &, PortableServer::IdUniquenessPolicyValue); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::IdUniquenessPolicyValue &); +TAO_Export void operator<<= (CORBA::Any &, PortableServer::IdAssignmentPolicyValue); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::IdAssignmentPolicyValue &); + +#if (TAO_HAS_MINIMUM_POA == 0) + +TAO_Export void operator<<= (CORBA::Any &, PortableServer::ImplicitActivationPolicyValue); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::ImplicitActivationPolicyValue &); +TAO_Export void operator<<= (CORBA::Any &, PortableServer::ServantRetentionPolicyValue); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::ServantRetentionPolicyValue &); +TAO_Export void operator<<= (CORBA::Any &, PortableServer::RequestProcessingPolicyValue); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::RequestProcessingPolicyValue &); + +#endif /* TAO_HAS_MINIMUM_POA == 0 */ + +#ifndef __ACE_INLINE__ + + +#if !defined _TAO_CDR_OP_PortableServer_ObjectId_H_ +#define _TAO_CDR_OP_PortableServer_ObjectId_H_ + +TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, + const PortableServer::ObjectId & + ); +TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, + PortableServer::ObjectId & + ); + +#endif /* _TAO_CDR_OP_PortableServer_ObjectId_H_ */ + +#if (TAO_HAS_MINIMUM_CORBA == 0) + +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ForwardRequest &); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::ForwardRequest &); + +#endif /* TAO_HAS_MINIMUM_CORBA == 0 */ + +# if !defined (ACE_LACKS_IOSTREAM_TOTALLY) + +#if (TAO_HAS_MINIMUM_CORBA == 0) + +TAO_Export ostream& operator<< (ostream &, const PortableServer::ForwardRequest &); + +#endif /* TAO_HAS_MINIMUM_CORBA == 0 */ + +# endif /* ACE_LACKS_IOSTREAM_TOTALLY */ + +#if (TAO_HAS_MINIMUM_POA == 0) + +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ThreadPolicyValue &); // +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::ThreadPolicyValue &); + +#endif /* TAO_HAS_MINIMUM_POA == 0 */ + +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::LifespanPolicyValue &); // +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::LifespanPolicyValue &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::IdUniquenessPolicyValue &); // +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::IdUniquenessPolicyValue &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::IdAssignmentPolicyValue &); // +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::IdAssignmentPolicyValue &); + +#if (TAO_HAS_MINIMUM_POA == 0) + +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ImplicitActivationPolicyValue &); // +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::ImplicitActivationPolicyValue &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ServantRetentionPolicyValue &); // +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::ServantRetentionPolicyValue &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::RequestProcessingPolicyValue &); // +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::RequestProcessingPolicyValue &); + +#endif /* TAO_HAS_MINIMUM_POA == 0 */ + +#endif /* __ACE_INLINE__ */ + + +#if defined (__ACE_INLINE__) +#include "PortableServerC.i" +#endif /* defined INLINE */ + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#pragma warning(pop) +#endif /* _MSC_VER */ + +#include "ace/post.h" +#endif /* ifndef */ |