diff options
Diffstat (limited to 'TAO/tao/PortableServer/PortableServerC.h')
| -rw-r--r-- | TAO/tao/PortableServer/PortableServerC.h | 2554 |
1 files changed, 1499 insertions, 1055 deletions
diff --git a/TAO/tao/PortableServer/PortableServerC.h b/TAO/tao/PortableServer/PortableServerC.h index 844e2beded5..616c2ba2e5a 100644 --- a/TAO/tao/PortableServer/PortableServerC.h +++ b/TAO/tao/PortableServer/PortableServerC.h @@ -19,8 +19,8 @@ // Information about TAO is available at: // http://www.cs.wustl.edu/~schmidt/TAO.html -#ifndef _TAO_IDL_ORIG_PORTABLESERVERC_H_ -#define _TAO_IDL_ORIG_PORTABLESERVERC_H_ +#ifndef _TAO_IDL_PORTABLESERVERC_H_ +#define _TAO_IDL_PORTABLESERVERC_H_ #include "ace/pre.h" #include "portableserver_export.h" @@ -76,47 +76,50 @@ TAO_NAMESPACE PortableServer 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_PortableServer_Export POA_var : public TAO_Base_var { public: POA_var (void); // default constructor - POA_var (POA_ptr p) : ptr_ (p) {} + 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 + // 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; - + // Hooks used by template sequence and object manager classes // for non-defined forward declared interfaces. static POA_ptr tao_duplicate (POA_ptr); static void tao_release (POA_ptr); static POA_ptr tao_nil (void); - static POA_ptr tao_narrow (CORBA::Object * TAO_ENV_ARG_DECL_NOT_USED); + static POA_ptr tao_narrow ( + CORBA::Object * + TAO_ENV_ARG_DECL_NOT_USED + ); static CORBA::Object * tao_upcast (void *); - + private: POA_ptr ptr_; // Unimplemented - prevents widening assignment. @@ -126,11 +129,11 @@ TAO_NAMESPACE PortableServer #endif /* end #if !defined */ - - + + #if !defined (_PORTABLESERVER_POA___OUT_CH_) #define _PORTABLESERVER_POA___OUT_CH_ - + class TAO_PortableServer_Export POA_out { public: @@ -143,141 +146,156 @@ TAO_NAMESPACE PortableServer 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, + + class TAO_EXPORT_MACRO _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 - TAO_ENV_ARG_DECL_WITH_DEFAULTS); - - virtual CORBA_Object* _upcast (void *src) const; - - }; - + CORBA::Boolean release = 0 + ); + _TAO_Unbounded_Object_Sequence_PortableServer_POAList ( + const _TAO_Unbounded_Object_Sequence_PortableServer_POAList &rhs + ); + _TAO_Unbounded_Object_Sequence_PortableServer_POAList &operator= ( + const _TAO_Unbounded_Object_Sequence_PortableServer_POAList &rhs + ); + virtual ~_TAO_Unbounded_Object_Sequence_PortableServer_POAList (void); + + // = Accessors. + TAO_Object_Manager<PortableServer::POA,PortableServer::POA_var> operator[] (CORBA::ULong index) const; + + // = Static operations. + static POA **allocbuf (CORBA::ULong nelems); + static void freebuf (POA **buffer); + + // Implement the TAO_Base_Sequence methods (see 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 + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ); + virtual CORBA_Object* _upcast (void *src) const; + }; + #endif /* end #if !defined */ - - -#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ - + + +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + #if !defined (_PORTABLESERVER_POALIST_CH_) #define _PORTABLESERVER_POALIST_CH_ - + class POAList; class POAList_var; - + // ************************************************************* // POAList // ************************************************************* - - class TAO_PortableServer_Export POAList : public + + class TAO_PortableServer_Export POAList : public #if !defined (TAO_USE_SEQUENCE_TEMPLATES) - _TAO_Unbounded_Object_Sequence_PortableServer_POAList + _TAO_Unbounded_Object_Sequence_PortableServer_POAList #else /* TAO_USE_SEQUENCE_TEMPLATES */ - TAO_Unbounded_Object_Sequence<POA,POA_var> -#endif /* !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 - ); + 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_PortableServer_Export POAList_var { public: - POAList_var (void); // default constructor + POAList_var (void); POAList_var (POAList *); - POAList_var (const POAList_var &); // copy constructor - ~POAList_var (void); // destructor - + POAList_var (const POAList_var &); + ~POAList_var (void); + 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 + + // 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_PortableServer_Export POAList_out { public: @@ -290,52 +308,52 @@ TAO_NAMESPACE PortableServer 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 + // 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_PortableServer_Export ObjectId : public + + class TAO_PortableServer_Export ObjectId : public #if !defined (TAO_USE_SEQUENCE_TEMPLATES) - TAO_Unbounded_Sequence<CORBA::Octet> + TAO_Unbounded_Sequence<CORBA::Octet> #else /* TAO_USE_SEQUENCE_TEMPLATES */ - TAO_Unbounded_Sequence<CORBA::Octet> -#endif /* !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 - ); + 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 (TAO_NO_COPY_OCTET_SEQUENCES == 1) ObjectId ( CORBA::ULong length, @@ -343,59 +361,61 @@ TAO_NAMESPACE PortableServer ) : TAO_Unbounded_Sequence<CORBA::Octet> (length, mb) {} #endif /* TAO_NO_COPY_OCTET_SEQUENCE == 1 */ - + }; - + #endif /* end #if !defined */ - - + + #if !defined (_PORTABLESERVER_OBJECTID___VAR_CH_) #define _PORTABLESERVER_OBJECTID___VAR_CH_ - + // ************************************************************* // class PortableServer::ObjectId_var // ************************************************************* - + class TAO_PortableServer_Export ObjectId_var { public: - ObjectId_var (void); // default constructor + ObjectId_var (void); 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 (const ObjectId_var &); + // Fixed-size base types only. + ObjectId_var (const ObjectId &); + ~ObjectId_var (void); + ObjectId_var &operator= (ObjectId *); ObjectId_var &operator= (const ObjectId_var &); - ObjectId_var &operator= (const ObjectId &); // fixed-size base types only + // Fixed-size base types only. + ObjectId_var &operator= (const ObjectId &); ObjectId *operator-> (void); const ObjectId *operator-> (void) const; - + operator const ObjectId &() const; operator ObjectId &(); operator ObjectId &() const; - + CORBA::Octet & operator[] (CORBA::ULong index); const CORBA::Octet & operator[] (CORBA::ULong index) const; - - // in, inout, out, _retn + + // 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_PortableServer_Export ObjectId_out { public: @@ -408,139 +428,350 @@ TAO_NAMESPACE PortableServer ObjectId *&ptr (void); ObjectId *operator-> (void); CORBA::Octet & operator[] (CORBA::ULong index); - + private: ObjectId *&ptr_; - // assignment from T_var not allowed + // Assignment from T_var not allowed. void operator= (const ObjectId_var &); }; - - + + #endif /* end #if !defined */ - - TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ObjectId; - - + + 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_PortableServer_Export ForwardRequest : public CORBA::UserException { public: CORBA::Object_var forward_reference; - + ForwardRequest (void); // Default constructor. - + ForwardRequest (const ForwardRequest &); // Copy constructor. - + ~ForwardRequest (void); // Destructor. - + static void _tao_any_destructor (void*); - + ForwardRequest &operator= (const ForwardRequest &); - + virtual void _raise (void); virtual void _tao_encode ( TAO_OutputCDR & TAO_ENV_ARG_DECL_NOT_USED ) const; - + virtual void _tao_decode ( TAO_InputCDR & TAO_ENV_ARG_DECL_NOT_USED ); - + 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; +TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_ForwardRequest; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_NOTAGROUPOBJECT_CH_) +#define _PORTABLESERVER_NOTAGROUPOBJECT_CH_ + + class TAO_PortableServer_Export NotAGroupObject : public CORBA::UserException + { + public: + + NotAGroupObject (void); + // Default constructor. + + NotAGroupObject (const NotAGroupObject &); + // Copy constructor. + + ~NotAGroupObject (void); + // Destructor. + + static void _tao_any_destructor (void*); + + NotAGroupObject &operator= (const NotAGroupObject &); + + virtual void _raise (void); + virtual void _tao_encode ( + TAO_OutputCDR & + TAO_ENV_ARG_DECL_NOT_USED + ) const; + + virtual void _tao_decode ( + TAO_InputCDR & + TAO_ENV_ARG_DECL_NOT_USED + ); + + static NotAGroupObject *_downcast (CORBA::Exception *); -#endif /* end #if !defined */ + // = TAO extension. + static CORBA::Exception *_alloc (void); + virtual CORBA::TypeCode_ptr _type (void) const; + }; // Exception PortableServer::NotAGroupObject. + +TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_NotAGroupObject; + + +#endif /* end #if !defined */ + + +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +#if !defined (__TAO_UNBOUNDED_SEQUENCE_PORTABLESERVER_IDS_CH_) +#define __TAO_UNBOUNDED_SEQUENCE_PORTABLESERVER_IDS_CH_ + + class TAO_EXPORT_MACRO _TAO_Unbounded_Sequence_PortableServer_IDs + : public TAO_Unbounded_Base_Sequence + { + public: + // = Initialization and termination methods. + _TAO_Unbounded_Sequence_PortableServer_IDs (void); + _TAO_Unbounded_Sequence_PortableServer_IDs (CORBA::ULong maximum); + _TAO_Unbounded_Sequence_PortableServer_IDs ( + CORBA::ULong maximum, + CORBA::ULong length, + ObjectId *data, + CORBA::Boolean release = 0 + ); + _TAO_Unbounded_Sequence_PortableServer_IDs ( + const _TAO_Unbounded_Sequence_PortableServer_IDs &rhs + ); + _TAO_Unbounded_Sequence_PortableServer_IDs &operator= ( + const _TAO_Unbounded_Sequence_PortableServer_IDs &rhs + ); + virtual ~_TAO_Unbounded_Sequence_PortableServer_IDs (void); + + // = Accessors. + ObjectId &operator[] (CORBA::ULong i); + const ObjectId &operator[] (CORBA::ULong i) const; + + // = Static operations. + static ObjectId *allocbuf (CORBA::ULong size); + static void freebuf (ObjectId *buffer); + + // Implement the TAO_Base_Sequence methods (see Sequence.h) + virtual void _allocate_buffer (CORBA::ULong length); + virtual void _deallocate_buffer (void); + ObjectId *get_buffer (CORBA::Boolean orphan = 0); + const ObjectId *get_buffer (void) const; + void replace ( + CORBA::ULong max, + CORBA::ULong length, + ObjectId *data, + CORBA::Boolean release + ); + }; + +#endif /* end #if !defined */ + + +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +#if !defined (_PORTABLESERVER_IDS_CH_) +#define _PORTABLESERVER_IDS_CH_ + + class IDs; + class IDs_var; + + // ************************************************************* + // IDs + // ************************************************************* + + class TAO_PortableServer_Export IDs : public +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Sequence_PortableServer_IDs +#else /* TAO_USE_SEQUENCE_TEMPLATES */ + TAO_Unbounded_Sequence<ObjectId> +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: + IDs (void); // default ctor + IDs (CORBA::ULong max); // uses max size + IDs ( + CORBA::ULong max, + CORBA::ULong length, + ObjectId *buffer, + CORBA::Boolean release = 0 + ); + IDs (const IDs &); // copy ctor + ~IDs (void); + static void _tao_any_destructor (void*); + +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef IDs_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + + }; + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_IDS___VAR_CH_) +#define _PORTABLESERVER_IDS___VAR_CH_ + + // ************************************************************* + // class PortableServer::IDs_var + // ************************************************************* + + class TAO_PortableServer_Export IDs_var + { + public: + IDs_var (void); + IDs_var (IDs *); + IDs_var (const IDs_var &); + ~IDs_var (void); + + IDs_var &operator= (IDs *); + IDs_var &operator= (const IDs_var &); + IDs *operator-> (void); + const IDs *operator-> (void) const; + + operator const IDs &() const; + operator IDs &(); + operator IDs &() const; + operator IDs *&(); // variable-size base types only + + ObjectId & operator[] (CORBA::ULong index); + const ObjectId & operator[] (CORBA::ULong index) const; + + // in, inout, out, _retn + const IDs &in (void) const; + IDs &inout (void); + IDs *&out (void); + IDs *_retn (void); + IDs *ptr (void) const; + + private: + IDs *ptr_; + }; + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_IDS___OUT_CH_) +#define _PORTABLESERVER_IDS___OUT_CH_ + + class TAO_PortableServer_Export IDs_out + { + public: + IDs_out (IDs *&); + IDs_out (IDs_var &); + IDs_out (const IDs_out &); + IDs_out &operator= (const IDs_out &); + IDs_out &operator= (IDs *); + operator IDs *&(); + IDs *&ptr (void); + IDs *operator-> (void); + ObjectId & operator[] (CORBA::ULong index); + + private: + IDs *&ptr_; + // Assignment from T_var not allowed. + void operator= (const IDs_var &); + }; + + +#endif /* end #if !defined */ + #endif /* TAO_HAS_MINIMUM_CORBA == 0 */ + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_IDs; + 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 + ORB_CTRL_MODEL, + SINGLE_THREAD_MODEL }; - + #if (TAO_HAS_MINIMUM_POA == 0) typedef ThreadPolicyValue &ThreadPolicyValue_out; - TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ThreadPolicyValue; - - + 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_PortableServer_Export ThreadPolicy_var : public TAO_Base_var { public: ThreadPolicy_var (void); // default constructor - ThreadPolicy_var (ThreadPolicy_ptr p) : ptr_ (p) {} + 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 + // 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; - + // Hooks used by template sequence and object manager classes // for non-defined forward declared interfaces. static ThreadPolicy_ptr tao_duplicate (ThreadPolicy_ptr); static void tao_release (ThreadPolicy_ptr); static ThreadPolicy_ptr tao_nil (void); - static ThreadPolicy_ptr tao_narrow (CORBA::Object * TAO_ENV_ARG_DECL_NOT_USED); + static ThreadPolicy_ptr tao_narrow ( + CORBA::Object * + TAO_ENV_ARG_DECL_NOT_USED + ); static CORBA::Object * tao_upcast (void *); - + private: ThreadPolicy_ptr ptr_; // Unimplemented - prevents widening assignment. @@ -550,11 +781,11 @@ TAO_NAMESPACE PortableServer #endif /* end #if !defined */ - - + + #if !defined (_PORTABLESERVER_THREADPOLICY___OUT_CH_) #define _PORTABLESERVER_THREADPOLICY___OUT_CH_ - + class TAO_PortableServer_Export ThreadPolicy_out { public: @@ -567,19 +798,20 @@ TAO_NAMESPACE PortableServer 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_PortableServer_Export ThreadPolicy: public virtual CORBA::Policy + + class TAO_PortableServer_Export ThreadPolicy + : public virtual CORBA::Policy { public: #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) @@ -587,98 +819,106 @@ class TAO_PortableServer_Export ThreadPolicy: public virtual CORBA::Policy typedef ThreadPolicy_var _var_type; #endif /* ! __GNUC__ || g++ >= 2.8 */ - static int _tao_class_id; - - // the static operations + static int _tao_class_id; + + // The static operations. static ThreadPolicy_ptr _duplicate (ThreadPolicy_ptr obj); + static ThreadPolicy_ptr _narrow ( CORBA::Object_ptr obj - TAO_ENV_ARG_DECL_WITH_DEFAULTS); - + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ); + static ThreadPolicy_ptr _unchecked_narrow ( CORBA::Object_ptr obj - TAO_ENV_ARG_DECL_WITH_DEFAULTS); - + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ); + static ThreadPolicy_ptr _nil (void) { return (ThreadPolicy_ptr)0; } - - virtual PortableServer::ThreadPolicyValue value ( - TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) - + + virtual ::PortableServer::ThreadPolicyValue value ( + TAO_ENV_SINGLE_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: - ThreadPolicy (); - + 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 + TRANSIENT, + PERSISTENT }; + typedef LifespanPolicyValue &LifespanPolicyValue_out; - TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_LifespanPolicyValue; - - + 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_PortableServer_Export LifespanPolicy_var : public TAO_Base_var { public: LifespanPolicy_var (void); // default constructor - LifespanPolicy_var (LifespanPolicy_ptr p) : ptr_ (p) {} + 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 + // 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; - + // Hooks used by template sequence and object manager classes // for non-defined forward declared interfaces. static LifespanPolicy_ptr tao_duplicate (LifespanPolicy_ptr); static void tao_release (LifespanPolicy_ptr); static LifespanPolicy_ptr tao_nil (void); - static LifespanPolicy_ptr tao_narrow (CORBA::Object * TAO_ENV_ARG_DECL_NOT_USED); + static LifespanPolicy_ptr tao_narrow ( + CORBA::Object * + TAO_ENV_ARG_DECL_NOT_USED + ); static CORBA::Object * tao_upcast (void *); - + private: LifespanPolicy_ptr ptr_; // Unimplemented - prevents widening assignment. @@ -688,11 +928,11 @@ class TAO_PortableServer_Export ThreadPolicy: public virtual CORBA::Policy #endif /* end #if !defined */ - - + + #if !defined (_PORTABLESERVER_LIFESPANPOLICY___OUT_CH_) #define _PORTABLESERVER_LIFESPANPOLICY___OUT_CH_ - + class TAO_PortableServer_Export LifespanPolicy_out { public: @@ -705,19 +945,20 @@ class TAO_PortableServer_Export ThreadPolicy: public virtual CORBA::Policy 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_PortableServer_Export LifespanPolicy: public virtual CORBA::Policy + + class TAO_PortableServer_Export LifespanPolicy + : public virtual CORBA::Policy { public: #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) @@ -725,96 +966,104 @@ class TAO_PortableServer_Export LifespanPolicy: public virtual CORBA::Policy typedef LifespanPolicy_var _var_type; #endif /* ! __GNUC__ || g++ >= 2.8 */ - static int _tao_class_id; - - // the static operations + static int _tao_class_id; + + // The static operations. static LifespanPolicy_ptr _duplicate (LifespanPolicy_ptr obj); + static LifespanPolicy_ptr _narrow ( CORBA::Object_ptr obj - TAO_ENV_ARG_DECL_WITH_DEFAULTS); - + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ); + static LifespanPolicy_ptr _unchecked_narrow ( CORBA::Object_ptr obj - TAO_ENV_ARG_DECL_WITH_DEFAULTS); - + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ); + static LifespanPolicy_ptr _nil (void) { return (LifespanPolicy_ptr)0; } - - virtual PortableServer::LifespanPolicyValue value ( - TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) - + + virtual ::PortableServer::LifespanPolicyValue value ( + TAO_ENV_SINGLE_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: - LifespanPolicy (); - + LifespanPolicy (void); + virtual ~LifespanPolicy (void); + private: LifespanPolicy (const LifespanPolicy &); void operator= (const LifespanPolicy &); }; - - + + #endif /* end #if !defined */ - + enum IdUniquenessPolicyValue { - UNIQUE_ID, - MULTIPLE_ID + UNIQUE_ID, + MULTIPLE_ID }; + typedef IdUniquenessPolicyValue &IdUniquenessPolicyValue_out; - TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_IdUniquenessPolicyValue; - - + 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_PortableServer_Export IdUniquenessPolicy_var : public TAO_Base_var { public: IdUniquenessPolicy_var (void); // default constructor - IdUniquenessPolicy_var (IdUniquenessPolicy_ptr p) : ptr_ (p) {} + 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 + // 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; - + // Hooks used by template sequence and object manager classes // for non-defined forward declared interfaces. static IdUniquenessPolicy_ptr tao_duplicate (IdUniquenessPolicy_ptr); static void tao_release (IdUniquenessPolicy_ptr); static IdUniquenessPolicy_ptr tao_nil (void); - static IdUniquenessPolicy_ptr tao_narrow (CORBA::Object * TAO_ENV_ARG_DECL_NOT_USED); + static IdUniquenessPolicy_ptr tao_narrow ( + CORBA::Object * + TAO_ENV_ARG_DECL_NOT_USED + ); static CORBA::Object * tao_upcast (void *); - + private: IdUniquenessPolicy_ptr ptr_; // Unimplemented - prevents widening assignment. @@ -824,11 +1073,11 @@ class TAO_PortableServer_Export LifespanPolicy: public virtual CORBA::Policy #endif /* end #if !defined */ - - + + #if !defined (_PORTABLESERVER_IDUNIQUENESSPOLICY___OUT_CH_) #define _PORTABLESERVER_IDUNIQUENESSPOLICY___OUT_CH_ - + class TAO_PortableServer_Export IdUniquenessPolicy_out { public: @@ -841,19 +1090,20 @@ class TAO_PortableServer_Export LifespanPolicy: public virtual CORBA::Policy 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_PortableServer_Export IdUniquenessPolicy: public virtual CORBA::Policy + + class TAO_PortableServer_Export IdUniquenessPolicy + : public virtual CORBA::Policy { public: #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) @@ -861,96 +1111,104 @@ class TAO_PortableServer_Export IdUniquenessPolicy: public virtual CORBA::Policy typedef IdUniquenessPolicy_var _var_type; #endif /* ! __GNUC__ || g++ >= 2.8 */ - static int _tao_class_id; - - // the static operations + static int _tao_class_id; + + // The static operations. static IdUniquenessPolicy_ptr _duplicate (IdUniquenessPolicy_ptr obj); + static IdUniquenessPolicy_ptr _narrow ( CORBA::Object_ptr obj - TAO_ENV_ARG_DECL_WITH_DEFAULTS); - + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ); + static IdUniquenessPolicy_ptr _unchecked_narrow ( CORBA::Object_ptr obj - TAO_ENV_ARG_DECL_WITH_DEFAULTS); - + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ); + static IdUniquenessPolicy_ptr _nil (void) { return (IdUniquenessPolicy_ptr)0; } - - virtual PortableServer::IdUniquenessPolicyValue value ( - TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) - + + virtual ::PortableServer::IdUniquenessPolicyValue value ( + TAO_ENV_SINGLE_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: - IdUniquenessPolicy (); - + IdUniquenessPolicy (void); + virtual ~IdUniquenessPolicy (void); + private: IdUniquenessPolicy (const IdUniquenessPolicy &); void operator= (const IdUniquenessPolicy &); }; - - + + #endif /* end #if !defined */ - + enum IdAssignmentPolicyValue { - USER_ID, - SYSTEM_ID + USER_ID, + SYSTEM_ID }; + typedef IdAssignmentPolicyValue &IdAssignmentPolicyValue_out; - TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_IdAssignmentPolicyValue; - - + 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_PortableServer_Export IdAssignmentPolicy_var : public TAO_Base_var { public: IdAssignmentPolicy_var (void); // default constructor - IdAssignmentPolicy_var (IdAssignmentPolicy_ptr p) : ptr_ (p) {} + 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 + // 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; - + // Hooks used by template sequence and object manager classes // for non-defined forward declared interfaces. static IdAssignmentPolicy_ptr tao_duplicate (IdAssignmentPolicy_ptr); static void tao_release (IdAssignmentPolicy_ptr); static IdAssignmentPolicy_ptr tao_nil (void); - static IdAssignmentPolicy_ptr tao_narrow (CORBA::Object * TAO_ENV_ARG_DECL_NOT_USED); + static IdAssignmentPolicy_ptr tao_narrow ( + CORBA::Object * + TAO_ENV_ARG_DECL_NOT_USED + ); static CORBA::Object * tao_upcast (void *); - + private: IdAssignmentPolicy_ptr ptr_; // Unimplemented - prevents widening assignment. @@ -960,11 +1218,11 @@ class TAO_PortableServer_Export IdUniquenessPolicy: public virtual CORBA::Policy #endif /* end #if !defined */ - - + + #if !defined (_PORTABLESERVER_IDASSIGNMENTPOLICY___OUT_CH_) #define _PORTABLESERVER_IDASSIGNMENTPOLICY___OUT_CH_ - + class TAO_PortableServer_Export IdAssignmentPolicy_out { public: @@ -977,19 +1235,20 @@ class TAO_PortableServer_Export IdUniquenessPolicy: public virtual CORBA::Policy 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_PortableServer_Export IdAssignmentPolicy: public virtual CORBA::Policy + + class TAO_PortableServer_Export IdAssignmentPolicy + : public virtual CORBA::Policy { public: #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) @@ -997,99 +1256,106 @@ class TAO_PortableServer_Export IdAssignmentPolicy: public virtual CORBA::Policy typedef IdAssignmentPolicy_var _var_type; #endif /* ! __GNUC__ || g++ >= 2.8 */ - static int _tao_class_id; - - // the static operations + static int _tao_class_id; + + // The static operations. static IdAssignmentPolicy_ptr _duplicate (IdAssignmentPolicy_ptr obj); + static IdAssignmentPolicy_ptr _narrow ( CORBA::Object_ptr obj - TAO_ENV_ARG_DECL_WITH_DEFAULTS); - + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ); + static IdAssignmentPolicy_ptr _unchecked_narrow ( CORBA::Object_ptr obj - TAO_ENV_ARG_DECL_WITH_DEFAULTS); - + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ); + static IdAssignmentPolicy_ptr _nil (void) { return (IdAssignmentPolicy_ptr)0; } - - virtual PortableServer::IdAssignmentPolicyValue value ( - TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) - + + virtual ::PortableServer::IdAssignmentPolicyValue value ( + TAO_ENV_SINGLE_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: - IdAssignmentPolicy (); - + IdAssignmentPolicy (void); + virtual ~IdAssignmentPolicy (void); + private: IdAssignmentPolicy (const IdAssignmentPolicy &); void operator= (const IdAssignmentPolicy &); }; - - + + #endif /* end #if !defined */ - + enum ImplicitActivationPolicyValue { - IMPLICIT_ACTIVATION, - NO_IMPLICIT_ACTIVATION + IMPLICIT_ACTIVATION, + NO_IMPLICIT_ACTIVATION }; - + #if (TAO_HAS_MINIMUM_POA == 0) typedef ImplicitActivationPolicyValue &ImplicitActivationPolicyValue_out; - TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ImplicitActivationPolicyValue; - - + 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_PortableServer_Export ImplicitActivationPolicy_var : public TAO_Base_var { public: ImplicitActivationPolicy_var (void); // default constructor - ImplicitActivationPolicy_var (ImplicitActivationPolicy_ptr p) : ptr_ (p) {} + 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 + // 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; - + // Hooks used by template sequence and object manager classes // for non-defined forward declared interfaces. static ImplicitActivationPolicy_ptr tao_duplicate (ImplicitActivationPolicy_ptr); static void tao_release (ImplicitActivationPolicy_ptr); static ImplicitActivationPolicy_ptr tao_nil (void); - static ImplicitActivationPolicy_ptr tao_narrow (CORBA::Object * TAO_ENV_ARG_DECL_NOT_USED); + static ImplicitActivationPolicy_ptr tao_narrow ( + CORBA::Object * + TAO_ENV_ARG_DECL_NOT_USED + ); static CORBA::Object * tao_upcast (void *); - + private: ImplicitActivationPolicy_ptr ptr_; // Unimplemented - prevents widening assignment. @@ -1099,11 +1365,11 @@ class TAO_PortableServer_Export IdAssignmentPolicy: public virtual CORBA::Policy #endif /* end #if !defined */ - - + + #if !defined (_PORTABLESERVER_IMPLICITACTIVATIONPOLICY___OUT_CH_) #define _PORTABLESERVER_IMPLICITACTIVATIONPOLICY___OUT_CH_ - + class TAO_PortableServer_Export ImplicitActivationPolicy_out { public: @@ -1116,19 +1382,20 @@ class TAO_PortableServer_Export IdAssignmentPolicy: public virtual CORBA::Policy 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_PortableServer_Export ImplicitActivationPolicy: public virtual CORBA::Policy + + class TAO_PortableServer_Export ImplicitActivationPolicy + : public virtual CORBA::Policy { public: #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) @@ -1136,101 +1403,108 @@ class TAO_PortableServer_Export ImplicitActivationPolicy: public virtual CORBA:: typedef ImplicitActivationPolicy_var _var_type; #endif /* ! __GNUC__ || g++ >= 2.8 */ - static int _tao_class_id; - - // the static operations + static int _tao_class_id; + + // The static operations. static ImplicitActivationPolicy_ptr _duplicate (ImplicitActivationPolicy_ptr obj); + static ImplicitActivationPolicy_ptr _narrow ( CORBA::Object_ptr obj - TAO_ENV_ARG_DECL_WITH_DEFAULTS); - + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ); + static ImplicitActivationPolicy_ptr _unchecked_narrow ( CORBA::Object_ptr obj - TAO_ENV_ARG_DECL_WITH_DEFAULTS); - + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ); + static ImplicitActivationPolicy_ptr _nil (void) { return (ImplicitActivationPolicy_ptr)0; } - - virtual PortableServer::ImplicitActivationPolicyValue value ( - TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) - + + virtual ::PortableServer::ImplicitActivationPolicyValue value ( + TAO_ENV_SINGLE_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: - ImplicitActivationPolicy (); - + 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 + RETAIN, + NON_RETAIN }; - + #if (TAO_HAS_MINIMUM_POA == 0) typedef ServantRetentionPolicyValue &ServantRetentionPolicyValue_out; - TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ServantRetentionPolicyValue; - - + 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_PortableServer_Export ServantRetentionPolicy_var : public TAO_Base_var { public: ServantRetentionPolicy_var (void); // default constructor - ServantRetentionPolicy_var (ServantRetentionPolicy_ptr p) : ptr_ (p) {} + 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 + // 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; - + // Hooks used by template sequence and object manager classes // for non-defined forward declared interfaces. static ServantRetentionPolicy_ptr tao_duplicate (ServantRetentionPolicy_ptr); static void tao_release (ServantRetentionPolicy_ptr); static ServantRetentionPolicy_ptr tao_nil (void); - static ServantRetentionPolicy_ptr tao_narrow (CORBA::Object * TAO_ENV_ARG_DECL_NOT_USED); + static ServantRetentionPolicy_ptr tao_narrow ( + CORBA::Object * + TAO_ENV_ARG_DECL_NOT_USED + ); static CORBA::Object * tao_upcast (void *); - + private: ServantRetentionPolicy_ptr ptr_; // Unimplemented - prevents widening assignment. @@ -1240,11 +1514,11 @@ class TAO_PortableServer_Export ImplicitActivationPolicy: public virtual CORBA:: #endif /* end #if !defined */ - - + + #if !defined (_PORTABLESERVER_SERVANTRETENTIONPOLICY___OUT_CH_) #define _PORTABLESERVER_SERVANTRETENTIONPOLICY___OUT_CH_ - + class TAO_PortableServer_Export ServantRetentionPolicy_out { public: @@ -1257,19 +1531,20 @@ class TAO_PortableServer_Export ImplicitActivationPolicy: public virtual CORBA:: 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_PortableServer_Export ServantRetentionPolicy: public virtual CORBA::Policy + + class TAO_PortableServer_Export ServantRetentionPolicy + : public virtual CORBA::Policy { public: #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) @@ -1277,102 +1552,109 @@ class TAO_PortableServer_Export ServantRetentionPolicy: public virtual CORBA::Po typedef ServantRetentionPolicy_var _var_type; #endif /* ! __GNUC__ || g++ >= 2.8 */ - static int _tao_class_id; - - // the static operations + static int _tao_class_id; + + // The static operations. static ServantRetentionPolicy_ptr _duplicate (ServantRetentionPolicy_ptr obj); + static ServantRetentionPolicy_ptr _narrow ( CORBA::Object_ptr obj - TAO_ENV_ARG_DECL_WITH_DEFAULTS); - + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ); + static ServantRetentionPolicy_ptr _unchecked_narrow ( CORBA::Object_ptr obj - TAO_ENV_ARG_DECL_WITH_DEFAULTS); - + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ); + static ServantRetentionPolicy_ptr _nil (void) { return (ServantRetentionPolicy_ptr)0; } - - virtual PortableServer::ServantRetentionPolicyValue value ( - TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) - + + virtual ::PortableServer::ServantRetentionPolicyValue value ( + TAO_ENV_SINGLE_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: - ServantRetentionPolicy (); - + 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 + USE_ACTIVE_OBJECT_MAP_ONLY, + USE_DEFAULT_SERVANT, + USE_SERVANT_MANAGER }; - + #if (TAO_HAS_MINIMUM_POA == 0) typedef RequestProcessingPolicyValue &RequestProcessingPolicyValue_out; - TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_RequestProcessingPolicyValue; - - + 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_PortableServer_Export RequestProcessingPolicy_var : public TAO_Base_var { public: RequestProcessingPolicy_var (void); // default constructor - RequestProcessingPolicy_var (RequestProcessingPolicy_ptr p) : ptr_ (p) {} + 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 + // 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; - + // Hooks used by template sequence and object manager classes // for non-defined forward declared interfaces. static RequestProcessingPolicy_ptr tao_duplicate (RequestProcessingPolicy_ptr); static void tao_release (RequestProcessingPolicy_ptr); static RequestProcessingPolicy_ptr tao_nil (void); - static RequestProcessingPolicy_ptr tao_narrow (CORBA::Object * TAO_ENV_ARG_DECL_NOT_USED); + static RequestProcessingPolicy_ptr tao_narrow ( + CORBA::Object * + TAO_ENV_ARG_DECL_NOT_USED + ); static CORBA::Object * tao_upcast (void *); - + private: RequestProcessingPolicy_ptr ptr_; // Unimplemented - prevents widening assignment. @@ -1382,11 +1664,11 @@ class TAO_PortableServer_Export ServantRetentionPolicy: public virtual CORBA::Po #endif /* end #if !defined */ - - + + #if !defined (_PORTABLESERVER_REQUESTPROCESSINGPOLICY___OUT_CH_) #define _PORTABLESERVER_REQUESTPROCESSINGPOLICY___OUT_CH_ - + class TAO_PortableServer_Export RequestProcessingPolicy_out { public: @@ -1399,19 +1681,20 @@ class TAO_PortableServer_Export ServantRetentionPolicy: public virtual CORBA::Po 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_PortableServer_Export RequestProcessingPolicy: public virtual CORBA::Policy + + class TAO_PortableServer_Export RequestProcessingPolicy + : public virtual CORBA::Policy { public: #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) @@ -1419,90 +1702,96 @@ class TAO_PortableServer_Export RequestProcessingPolicy: public virtual CORBA::P typedef RequestProcessingPolicy_var _var_type; #endif /* ! __GNUC__ || g++ >= 2.8 */ - static int _tao_class_id; - - // the static operations + static int _tao_class_id; + + // The static operations. static RequestProcessingPolicy_ptr _duplicate (RequestProcessingPolicy_ptr obj); + static RequestProcessingPolicy_ptr _narrow ( CORBA::Object_ptr obj - TAO_ENV_ARG_DECL_WITH_DEFAULTS); - + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ); + static RequestProcessingPolicy_ptr _unchecked_narrow ( CORBA::Object_ptr obj - TAO_ENV_ARG_DECL_WITH_DEFAULTS); - + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ); + static RequestProcessingPolicy_ptr _nil (void) { return (RequestProcessingPolicy_ptr)0; } - - virtual PortableServer::RequestProcessingPolicyValue value ( - TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) - + + virtual ::PortableServer::RequestProcessingPolicyValue value ( + TAO_ENV_SINGLE_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: - RequestProcessingPolicy (); - + 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_PortableServer_Export POAManager_var : public TAO_Base_var { public: POAManager_var (void); // default constructor - POAManager_var (POAManager_ptr p) : ptr_ (p) {} + 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 + // 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; - + // Hooks used by template sequence and object manager classes // for non-defined forward declared interfaces. static POAManager_ptr tao_duplicate (POAManager_ptr); static void tao_release (POAManager_ptr); static POAManager_ptr tao_nil (void); - static POAManager_ptr tao_narrow (CORBA::Object * TAO_ENV_ARG_DECL_NOT_USED); + static POAManager_ptr tao_narrow ( + CORBA::Object * + TAO_ENV_ARG_DECL_NOT_USED + ); static CORBA::Object * tao_upcast (void *); - + private: POAManager_ptr ptr_; // Unimplemented - prevents widening assignment. @@ -1512,11 +1801,11 @@ class TAO_PortableServer_Export RequestProcessingPolicy: public virtual CORBA::P #endif /* end #if !defined */ - - + + #if !defined (_PORTABLESERVER_POAMANAGER___OUT_CH_) #define _PORTABLESERVER_POAMANAGER___OUT_CH_ - + class TAO_PortableServer_Export POAManager_out { public: @@ -1529,19 +1818,20 @@ class TAO_PortableServer_Export RequestProcessingPolicy: public virtual CORBA::P 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_PortableServer_Export POAManager : public virtual CORBA_Object + + class TAO_PortableServer_Export POAManager + : public virtual CORBA_Object { public: #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) @@ -1549,54 +1839,57 @@ class TAO_PortableServer_Export POAManager : public virtual CORBA_Object typedef POAManager_var _var_type; #endif /* ! __GNUC__ || g++ >= 2.8 */ - static int _tao_class_id; - - // the static operations + static int _tao_class_id; + + // The static operations. static POAManager_ptr _duplicate (POAManager_ptr obj); + static POAManager_ptr _narrow ( CORBA::Object_ptr obj - TAO_ENV_ARG_DECL_WITH_DEFAULTS); - + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ); + static POAManager_ptr _unchecked_narrow ( CORBA::Object_ptr obj - TAO_ENV_ARG_DECL_WITH_DEFAULTS); - + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ); + static POAManager_ptr _nil (void) { return (POAManager_ptr)0; } - - + + #if !defined (_PORTABLESERVER_POAMANAGER_ADAPTERINACTIVE_CH_) #define _PORTABLESERVER_POAMANAGER_ADAPTERINACTIVE_CH_ - + class TAO_PortableServer_Export AdapterInactive : public CORBA::UserException { public: - + AdapterInactive (void); // Default constructor. - + AdapterInactive (const AdapterInactive &); // Copy constructor. - + ~AdapterInactive (void); // Destructor. - + AdapterInactive &operator= (const AdapterInactive &); - + virtual void _raise (void); virtual void _tao_encode ( TAO_OutputCDR & TAO_ENV_ARG_DECL_NOT_USED ) const; - + virtual void _tao_decode ( TAO_InputCDR & TAO_ENV_ARG_DECL_NOT_USED ); - + static AdapterInactive *_downcast (CORBA::Exception *); @@ -1606,122 +1899,123 @@ class TAO_PortableServer_Export POAManager : public virtual CORBA_Object #endif /* end #if !defined */ - + enum State { - HOLDING, - ACTIVE, - DISCARDING, - INACTIVE + HOLDING, + ACTIVE, + DISCARDING, + INACTIVE }; + typedef State &State_out; virtual void activate ( - TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) - + TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException, PortableServer::POAManager::AdapterInactive )) = 0; #if (TAO_HAS_MINIMUM_POA == 0) - + virtual void hold_requests ( - CORBA::Boolean wait_for_completion - TAO_ENV_ARG_DECL_WITH_DEFAULTS) - + CORBA::Boolean wait_for_completion TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException, PortableServer::POAManager::AdapterInactive )) = 0; - + virtual void discard_requests ( - CORBA::Boolean wait_for_completion - TAO_ENV_ARG_DECL_WITH_DEFAULTS) - + CORBA::Boolean wait_for_completion TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException, PortableServer::POAManager::AdapterInactive )) = 0; - + virtual void deactivate ( CORBA::Boolean etherealize_objects, - CORBA::Boolean wait_for_completion - TAO_ENV_ARG_DECL_WITH_DEFAULTS) - + CORBA::Boolean wait_for_completion TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException, PortableServer::POAManager::AdapterInactive )) = 0; - + #endif /* TAO_HAS_MINIMUM_POA == 0 */ - virtual PortableServer::POAManager::State get_state ( - TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) - + virtual ::PortableServer::POAManager::State get_state ( + TAO_ENV_SINGLE_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: - POAManager (); - + 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_PortableServer_Export AdapterActivator_var : public TAO_Base_var { public: AdapterActivator_var (void); // default constructor - AdapterActivator_var (AdapterActivator_ptr p) : ptr_ (p) {} + 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 + // 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; - + // Hooks used by template sequence and object manager classes // for non-defined forward declared interfaces. static AdapterActivator_ptr tao_duplicate (AdapterActivator_ptr); static void tao_release (AdapterActivator_ptr); static AdapterActivator_ptr tao_nil (void); - static AdapterActivator_ptr tao_narrow (CORBA::Object * TAO_ENV_ARG_DECL_NOT_USED); + static AdapterActivator_ptr tao_narrow ( + CORBA::Object * + TAO_ENV_ARG_DECL_NOT_USED + ); static CORBA::Object * tao_upcast (void *); - + private: AdapterActivator_ptr ptr_; // Unimplemented - prevents widening assignment. @@ -1731,11 +2025,11 @@ class TAO_PortableServer_Export POAManager : public virtual CORBA_Object #endif /* end #if !defined */ - - + + #if !defined (_PORTABLESERVER_ADAPTERACTIVATOR___OUT_CH_) #define _PORTABLESERVER_ADAPTERACTIVATOR___OUT_CH_ - + class TAO_PortableServer_Export AdapterActivator_out { public: @@ -1748,19 +2042,20 @@ class TAO_PortableServer_Export POAManager : public virtual CORBA_Object 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_PortableServer_Export AdapterActivator : public virtual CORBA_Object + + class TAO_PortableServer_Export AdapterActivator + : public virtual CORBA_Object { public: #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) @@ -1768,90 +2063,96 @@ class TAO_PortableServer_Export AdapterActivator : public virtual CORBA_Object typedef AdapterActivator_var _var_type; #endif /* ! __GNUC__ || g++ >= 2.8 */ - static int _tao_class_id; - - // the static operations + static int _tao_class_id; + + // The static operations. static AdapterActivator_ptr _duplicate (AdapterActivator_ptr obj); + static AdapterActivator_ptr _narrow ( CORBA::Object_ptr obj - TAO_ENV_ARG_DECL_WITH_DEFAULTS); - + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ); + static AdapterActivator_ptr _unchecked_narrow ( CORBA::Object_ptr obj - TAO_ENV_ARG_DECL_WITH_DEFAULTS); - + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ); + static AdapterActivator_ptr _nil (void) { return (AdapterActivator_ptr)0; } - + virtual CORBA::Boolean unknown_adapter ( PortableServer::POA_ptr parent, - const char * name - TAO_ENV_ARG_DECL_WITH_DEFAULTS) - + const char * name 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: - AdapterActivator (); - + 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_PortableServer_Export ServantManager_var : public TAO_Base_var { public: ServantManager_var (void); // default constructor - ServantManager_var (ServantManager_ptr p) : ptr_ (p) {} + 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 + // 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; - + // Hooks used by template sequence and object manager classes // for non-defined forward declared interfaces. static ServantManager_ptr tao_duplicate (ServantManager_ptr); static void tao_release (ServantManager_ptr); static ServantManager_ptr tao_nil (void); - static ServantManager_ptr tao_narrow (CORBA::Object * TAO_ENV_ARG_DECL_NOT_USED); + static ServantManager_ptr tao_narrow ( + CORBA::Object * + TAO_ENV_ARG_DECL_NOT_USED + ); static CORBA::Object * tao_upcast (void *); - + private: ServantManager_ptr ptr_; // Unimplemented - prevents widening assignment. @@ -1861,11 +2162,11 @@ class TAO_PortableServer_Export AdapterActivator : public virtual CORBA_Object #endif /* end #if !defined */ - - + + #if !defined (_PORTABLESERVER_SERVANTMANAGER___OUT_CH_) #define _PORTABLESERVER_SERVANTMANAGER___OUT_CH_ - + class TAO_PortableServer_Export ServantManager_out { public: @@ -1878,19 +2179,20 @@ class TAO_PortableServer_Export AdapterActivator : public virtual CORBA_Object 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_PortableServer_Export ServantManager : public virtual CORBA_Object + + class TAO_PortableServer_Export ServantManager + : public virtual CORBA_Object { public: #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) @@ -1898,81 +2200,88 @@ class TAO_PortableServer_Export ServantManager : public virtual CORBA_Object typedef ServantManager_var _var_type; #endif /* ! __GNUC__ || g++ >= 2.8 */ - static int _tao_class_id; - - // the static operations + static int _tao_class_id; + + // The static operations. static ServantManager_ptr _duplicate (ServantManager_ptr obj); + static ServantManager_ptr _narrow ( CORBA::Object_ptr obj - TAO_ENV_ARG_DECL_WITH_DEFAULTS); - + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ); + static ServantManager_ptr _unchecked_narrow ( CORBA::Object_ptr obj - TAO_ENV_ARG_DECL_WITH_DEFAULTS); - + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ); + 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 (); - + 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_PortableServer_Export ServantActivator_var : public TAO_Base_var { public: ServantActivator_var (void); // default constructor - ServantActivator_var (ServantActivator_ptr p) : ptr_ (p) {} + 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 + // 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; - + // Hooks used by template sequence and object manager classes // for non-defined forward declared interfaces. static ServantActivator_ptr tao_duplicate (ServantActivator_ptr); static void tao_release (ServantActivator_ptr); static ServantActivator_ptr tao_nil (void); - static ServantActivator_ptr tao_narrow (CORBA::Object * TAO_ENV_ARG_DECL_NOT_USED); + static ServantActivator_ptr tao_narrow ( + CORBA::Object * + TAO_ENV_ARG_DECL_NOT_USED + ); static CORBA::Object * tao_upcast (void *); - + private: ServantActivator_ptr ptr_; // Unimplemented - prevents widening assignment. @@ -1982,11 +2291,11 @@ class TAO_PortableServer_Export ServantManager : public virtual CORBA_Object #endif /* end #if !defined */ - - + + #if !defined (_PORTABLESERVER_SERVANTACTIVATOR___OUT_CH_) #define _PORTABLESERVER_SERVANTACTIVATOR___OUT_CH_ - + class TAO_PortableServer_Export ServantActivator_out { public: @@ -1999,19 +2308,20 @@ class TAO_PortableServer_Export ServantManager : public virtual CORBA_Object 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_PortableServer_Export ServantActivator: public virtual ServantManager + + class TAO_PortableServer_Export ServantActivator + : public virtual PortableServer::ServantManager { public: #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) @@ -2019,109 +2329,114 @@ class TAO_PortableServer_Export ServantActivator: public virtual ServantManager typedef ServantActivator_var _var_type; #endif /* ! __GNUC__ || g++ >= 2.8 */ - static int _tao_class_id; - - // the static operations + static int _tao_class_id; + + // The static operations. static ServantActivator_ptr _duplicate (ServantActivator_ptr obj); + static ServantActivator_ptr _narrow ( CORBA::Object_ptr obj - TAO_ENV_ARG_DECL_WITH_DEFAULTS); - + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ); + static ServantActivator_ptr _unchecked_narrow ( CORBA::Object_ptr obj - TAO_ENV_ARG_DECL_WITH_DEFAULTS); - + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ); + static ServantActivator_ptr _nil (void) { return (ServantActivator_ptr)0; } - - virtual PortableServer::Servant incarnate ( + + virtual ::PortableServer::Servant incarnate ( const PortableServer::ObjectId & oid, - PortableServer::POA_ptr adapter - TAO_ENV_ARG_DECL_WITH_DEFAULTS + PortableServer::POA_ptr adapter TAO_ENV_ARG_DECL_WITH_DEFAULTS ) #if (TAO_HAS_MINIMUM_CORBA == 0) - ACE_THROW_SPEC (( - CORBA::SystemException, - PortableServer::ForwardRequest - )) = 0; + ACE_THROW_SPEC (( + CORBA::SystemException, + PortableServer::ForwardRequest + )) = 0; #else - ACE_THROW_SPEC (( - CORBA::SystemException - )) = 0; + 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 + 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 (); - + 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_PortableServer_Export ServantLocator_var : public TAO_Base_var { public: ServantLocator_var (void); // default constructor - ServantLocator_var (ServantLocator_ptr p) : ptr_ (p) {} + 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 + // 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; - + // Hooks used by template sequence and object manager classes // for non-defined forward declared interfaces. static ServantLocator_ptr tao_duplicate (ServantLocator_ptr); static void tao_release (ServantLocator_ptr); static ServantLocator_ptr tao_nil (void); - static ServantLocator_ptr tao_narrow (CORBA::Object * TAO_ENV_ARG_DECL_NOT_USED); + static ServantLocator_ptr tao_narrow ( + CORBA::Object * + TAO_ENV_ARG_DECL_NOT_USED + ); static CORBA::Object * tao_upcast (void *); - + private: ServantLocator_ptr ptr_; // Unimplemented - prevents widening assignment. @@ -2131,11 +2446,11 @@ class TAO_PortableServer_Export ServantActivator: public virtual ServantManager #endif /* end #if !defined */ - - + + #if !defined (_PORTABLESERVER_SERVANTLOCATOR___OUT_CH_) #define _PORTABLESERVER_SERVANTLOCATOR___OUT_CH_ - + class TAO_PortableServer_Export ServantLocator_out { public: @@ -2148,19 +2463,20 @@ class TAO_PortableServer_Export ServantActivator: public virtual ServantManager 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_PortableServer_Export ServantLocator: public virtual ServantManager + + class TAO_PortableServer_Export ServantLocator + : public virtual PortableServer::ServantManager { public: @@ -2171,29 +2487,31 @@ class TAO_PortableServer_Export ServantLocator: public virtual ServantManager typedef ServantLocator_var _var_type; #endif /* ! __GNUC__ || g++ >= 2.8 */ - static int _tao_class_id; - - // the static operations + static int _tao_class_id; + + // The static operations. static ServantLocator_ptr _duplicate (ServantLocator_ptr obj); + static ServantLocator_ptr _narrow ( CORBA::Object_ptr obj - TAO_ENV_ARG_DECL_WITH_DEFAULTS); - + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ); + static ServantLocator_ptr _unchecked_narrow ( CORBA::Object_ptr obj - TAO_ENV_ARG_DECL_WITH_DEFAULTS); - + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ); + static ServantLocator_ptr _nil (void) { return (ServantLocator_ptr)0; } - - virtual PortableServer::Servant preinvoke ( + + 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 + PortableServer::ServantLocator::Cookie & the_cookie TAO_ENV_ARG_DECL_WITH_DEFAULTS ) #if (TAO_HAS_MINIMUM_CORBA == 0) ACE_THROW_SPEC (( @@ -2204,44 +2522,122 @@ class TAO_PortableServer_Export ServantLocator: public virtual ServantManager ACE_THROW_SPEC (( CORBA::SystemException )) = 0; -#endif /* TAO_HAS_MINIMUM_CORBA == 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 + 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 (); - + ServantLocator (void); + virtual ~ServantLocator (void); + private: ServantLocator (const ServantLocator &); void operator= (const ServantLocator &); }; - - + + +#endif /* end #if !defined */ + + +#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_PortableServer_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; + + // Hooks used by template sequence and object manager classes + // for non-defined forward declared interfaces. + static POA_ptr tao_duplicate (POA_ptr); + static void tao_release (POA_ptr); + static POA_ptr tao_nil (void); + static POA_ptr tao_narrow ( + CORBA::Object * + TAO_ENV_ARG_DECL_NOT_USED + ); + static CORBA::Object * tao_upcast (void *); + + 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_PortableServer_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 */ + #endif /* TAO_HAS_MINIMUM_POA == 0 */ - + #if !defined (_PORTABLESERVER_POA_CH_) #define _PORTABLESERVER_POA_CH_ - - -class TAO_PortableServer_Export POA : public virtual CORBA_Object + + class TAO_PortableServer_Export POA + : public virtual CORBA_Object { public: #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) @@ -2249,56 +2645,61 @@ class TAO_PortableServer_Export POA : public virtual CORBA_Object typedef POA_var _var_type; #endif /* ! __GNUC__ || g++ >= 2.8 */ - static int _tao_class_id; - - // the static operations + static int _tao_class_id; + + // The static operations. static POA_ptr _duplicate (POA_ptr obj); + static POA_ptr _narrow ( CORBA::Object_ptr obj - TAO_ENV_ARG_DECL_WITH_DEFAULTS); - + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ); + static POA_ptr _unchecked_narrow ( CORBA::Object_ptr obj - TAO_ENV_ARG_DECL_WITH_DEFAULTS); - + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ); + static POA_ptr _nil (void) { return (POA_ptr)0; } - - virtual TAO_POA* _tao_poa_downcast(void) {return 0;} - + + virtual TAO_POA* _tao_poa_downcast(void) + { + return 0; + } + #if !defined (_PORTABLESERVER_POA_ADAPTERALREADYEXISTS_CH_) #define _PORTABLESERVER_POA_ADAPTERALREADYEXISTS_CH_ - + class TAO_PortableServer_Export AdapterAlreadyExists : public CORBA::UserException { public: - + AdapterAlreadyExists (void); // Default constructor. - + AdapterAlreadyExists (const AdapterAlreadyExists &); // Copy constructor. - + ~AdapterAlreadyExists (void); // Destructor. - + AdapterAlreadyExists &operator= (const AdapterAlreadyExists &); - + virtual void _raise (void); virtual void _tao_encode ( TAO_OutputCDR & TAO_ENV_ARG_DECL_NOT_USED ) const; - + virtual void _tao_decode ( TAO_InputCDR & TAO_ENV_ARG_DECL_NOT_USED ); - - + static AdapterAlreadyExists *_downcast (CORBA::Exception *); @@ -2308,38 +2709,38 @@ class TAO_PortableServer_Export POA : public virtual CORBA_Object #endif /* end #if !defined */ - - + + #if !defined (_PORTABLESERVER_POA_ADAPTERNONEXISTENT_CH_) #define _PORTABLESERVER_POA_ADAPTERNONEXISTENT_CH_ - + class TAO_PortableServer_Export AdapterNonExistent : public CORBA::UserException { public: - + AdapterNonExistent (void); // Default constructor. - + AdapterNonExistent (const AdapterNonExistent &); // Copy constructor. - + ~AdapterNonExistent (void); // Destructor. - + AdapterNonExistent &operator= (const AdapterNonExistent &); - + virtual void _raise (void); virtual void _tao_encode ( TAO_OutputCDR & TAO_ENV_ARG_DECL_NOT_USED ) const; - + virtual void _tao_decode ( TAO_InputCDR & TAO_ENV_ARG_DECL_NOT_USED ); - + static AdapterNonExistent *_downcast (CORBA::Exception *); @@ -2349,85 +2750,84 @@ class TAO_PortableServer_Export POA : public virtual CORBA_Object #endif /* end #if !defined */ - - + + #if !defined (_PORTABLESERVER_POA_INVALIDPOLICY_CH_) #define _PORTABLESERVER_POA_INVALIDPOLICY_CH_ - + class TAO_PortableServer_Export InvalidPolicy : public CORBA::UserException { public: CORBA::UShort index; - + InvalidPolicy (void); // Default constructor. - + InvalidPolicy (const InvalidPolicy &); // Copy constructor. - + ~InvalidPolicy (void); // Destructor. - + InvalidPolicy &operator= (const InvalidPolicy &); - + virtual void _raise (void); virtual void _tao_encode ( TAO_OutputCDR & TAO_ENV_ARG_DECL_NOT_USED ) const; - + virtual void _tao_decode ( TAO_InputCDR & TAO_ENV_ARG_DECL_NOT_USED ); - + 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_PortableServer_Export NoServant : public CORBA::UserException { public: - + NoServant (void); // Default constructor. - + NoServant (const NoServant &); // Copy constructor. - + ~NoServant (void); // Destructor. - + NoServant &operator= (const NoServant &); - + virtual void _raise (void); virtual void _tao_encode ( TAO_OutputCDR & TAO_ENV_ARG_DECL_NOT_USED ) const; - + virtual void _tao_decode ( TAO_InputCDR & TAO_ENV_ARG_DECL_NOT_USED ); - + static NoServant *_downcast (CORBA::Exception *); @@ -2437,40 +2837,39 @@ class TAO_PortableServer_Export POA : public virtual CORBA_Object #endif /* end #if !defined */ - - + #endif /* TAO_HAS_MINIMUM_POA == 0 */ - + #if !defined (_PORTABLESERVER_POA_OBJECTALREADYACTIVE_CH_) #define _PORTABLESERVER_POA_OBJECTALREADYACTIVE_CH_ - + class TAO_PortableServer_Export ObjectAlreadyActive : public CORBA::UserException { public: - + ObjectAlreadyActive (void); // Default constructor. - + ObjectAlreadyActive (const ObjectAlreadyActive &); // Copy constructor. - + ~ObjectAlreadyActive (void); // Destructor. - + ObjectAlreadyActive &operator= (const ObjectAlreadyActive &); - + virtual void _raise (void); virtual void _tao_encode ( TAO_OutputCDR & TAO_ENV_ARG_DECL_NOT_USED ) const; - + virtual void _tao_decode ( TAO_InputCDR & TAO_ENV_ARG_DECL_NOT_USED ); - + static ObjectAlreadyActive *_downcast (CORBA::Exception *); @@ -2480,38 +2879,38 @@ class TAO_PortableServer_Export POA : public virtual CORBA_Object #endif /* end #if !defined */ - - + + #if !defined (_PORTABLESERVER_POA_OBJECTNOTACTIVE_CH_) #define _PORTABLESERVER_POA_OBJECTNOTACTIVE_CH_ - + class TAO_PortableServer_Export ObjectNotActive : public CORBA::UserException { public: - + ObjectNotActive (void); // Default constructor. - + ObjectNotActive (const ObjectNotActive &); // Copy constructor. - + ~ObjectNotActive (void); // Destructor. - + ObjectNotActive &operator= (const ObjectNotActive &); - + virtual void _raise (void); virtual void _tao_encode ( TAO_OutputCDR & TAO_ENV_ARG_DECL_NOT_USED ) const; - + virtual void _tao_decode ( TAO_InputCDR & TAO_ENV_ARG_DECL_NOT_USED ); - + static ObjectNotActive *_downcast (CORBA::Exception *); @@ -2521,38 +2920,38 @@ class TAO_PortableServer_Export POA : public virtual CORBA_Object #endif /* end #if !defined */ - - + + #if !defined (_PORTABLESERVER_POA_SERVANTALREADYACTIVE_CH_) #define _PORTABLESERVER_POA_SERVANTALREADYACTIVE_CH_ - + class TAO_PortableServer_Export ServantAlreadyActive : public CORBA::UserException { public: - + ServantAlreadyActive (void); // Default constructor. - + ServantAlreadyActive (const ServantAlreadyActive &); // Copy constructor. - + ~ServantAlreadyActive (void); // Destructor. - + ServantAlreadyActive &operator= (const ServantAlreadyActive &); - + virtual void _raise (void); virtual void _tao_encode ( TAO_OutputCDR & TAO_ENV_ARG_DECL_NOT_USED ) const; - + virtual void _tao_decode ( TAO_InputCDR & TAO_ENV_ARG_DECL_NOT_USED ); - + static ServantAlreadyActive *_downcast (CORBA::Exception *); @@ -2562,38 +2961,38 @@ class TAO_PortableServer_Export POA : public virtual CORBA_Object #endif /* end #if !defined */ - - + + #if !defined (_PORTABLESERVER_POA_SERVANTNOTACTIVE_CH_) #define _PORTABLESERVER_POA_SERVANTNOTACTIVE_CH_ - + class TAO_PortableServer_Export ServantNotActive : public CORBA::UserException { public: - + ServantNotActive (void); // Default constructor. - + ServantNotActive (const ServantNotActive &); // Copy constructor. - + ~ServantNotActive (void); // Destructor. - + ServantNotActive &operator= (const ServantNotActive &); - + virtual void _raise (void); virtual void _tao_encode ( TAO_OutputCDR & TAO_ENV_ARG_DECL_NOT_USED ) const; - + virtual void _tao_decode ( TAO_InputCDR & TAO_ENV_ARG_DECL_NOT_USED ); - + static ServantNotActive *_downcast (CORBA::Exception *); @@ -2603,38 +3002,38 @@ class TAO_PortableServer_Export POA : public virtual CORBA_Object #endif /* end #if !defined */ - - + + #if !defined (_PORTABLESERVER_POA_WRONGADAPTER_CH_) #define _PORTABLESERVER_POA_WRONGADAPTER_CH_ - + class TAO_PortableServer_Export WrongAdapter : public CORBA::UserException { public: - + WrongAdapter (void); // Default constructor. - + WrongAdapter (const WrongAdapter &); // Copy constructor. - + ~WrongAdapter (void); // Destructor. - + WrongAdapter &operator= (const WrongAdapter &); - + virtual void _raise (void); virtual void _tao_encode ( TAO_OutputCDR & TAO_ENV_ARG_DECL_NOT_USED ) const; - + virtual void _tao_decode ( TAO_InputCDR & TAO_ENV_ARG_DECL_NOT_USED ); - + static WrongAdapter *_downcast (CORBA::Exception *); @@ -2644,38 +3043,38 @@ class TAO_PortableServer_Export POA : public virtual CORBA_Object #endif /* end #if !defined */ - - + + #if !defined (_PORTABLESERVER_POA_WRONGPOLICY_CH_) #define _PORTABLESERVER_POA_WRONGPOLICY_CH_ - + class TAO_PortableServer_Export WrongPolicy : public CORBA::UserException { public: - + WrongPolicy (void); // Default constructor. - + WrongPolicy (const WrongPolicy &); // Copy constructor. - + ~WrongPolicy (void); // Destructor. - + WrongPolicy &operator= (const WrongPolicy &); - + virtual void _raise (void); virtual void _tao_encode ( TAO_OutputCDR & TAO_ENV_ARG_DECL_NOT_USED ) const; - + virtual void _tao_decode ( TAO_InputCDR & TAO_ENV_ARG_DECL_NOT_USED ); - + static WrongPolicy *_downcast (CORBA::Exception *); @@ -2685,361 +3084,375 @@ class TAO_PortableServer_Export POA : public virtual CORBA_Object #endif /* end #if !defined */ - - virtual PortableServer::POA_ptr create_POA ( + + virtual ::PortableServer::POA_ptr create_POA ( const char * adapter_name, PortableServer::POAManager_ptr a_POAManager, - const CORBA::PolicyList & policies - TAO_ENV_ARG_DECL_WITH_DEFAULTS) - + const CORBA::PolicyList & policies TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException, PortableServer::POA::AdapterAlreadyExists, PortableServer::POA::InvalidPolicy )) = 0; - - virtual PortableServer::POA_ptr find_POA ( + + virtual ::PortableServer::POA_ptr find_POA ( const char * adapter_name, - CORBA::Boolean activate_it - TAO_ENV_ARG_DECL_WITH_DEFAULTS) - + CORBA::Boolean activate_it TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException, PortableServer::POA::AdapterNonExistent )) = 0; - + virtual void destroy ( CORBA::Boolean etherealize_objects, - CORBA::Boolean wait_for_completion - TAO_ENV_ARG_DECL_WITH_DEFAULTS) - + CORBA::Boolean wait_for_completion TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException )) = 0; #if (TAO_HAS_MINIMUM_POA == 0) - - virtual PortableServer::ThreadPolicy_ptr create_thread_policy ( - PortableServer::ThreadPolicyValue value - TAO_ENV_ARG_DECL_WITH_DEFAULTS) - + + virtual ::PortableServer::ThreadPolicy_ptr create_thread_policy ( + PortableServer::ThreadPolicyValue value TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException )) = 0; - + #endif /* TAO_HAS_MINIMUM_POA == 0 */ - virtual PortableServer::LifespanPolicy_ptr create_lifespan_policy ( - PortableServer::LifespanPolicyValue value - TAO_ENV_ARG_DECL_WITH_DEFAULTS) - + virtual ::PortableServer::LifespanPolicy_ptr create_lifespan_policy ( + PortableServer::LifespanPolicyValue value TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException )) = 0; - - virtual PortableServer::IdUniquenessPolicy_ptr create_id_uniqueness_policy ( - PortableServer::IdUniquenessPolicyValue value - TAO_ENV_ARG_DECL_WITH_DEFAULTS) - + + virtual ::PortableServer::IdUniquenessPolicy_ptr create_id_uniqueness_policy ( + PortableServer::IdUniquenessPolicyValue value TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException )) = 0; - - virtual PortableServer::IdAssignmentPolicy_ptr create_id_assignment_policy ( - PortableServer::IdAssignmentPolicyValue value - TAO_ENV_ARG_DECL_WITH_DEFAULTS) - + + virtual ::PortableServer::IdAssignmentPolicy_ptr create_id_assignment_policy ( + PortableServer::IdAssignmentPolicyValue value TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException )) = 0; - + #if (TAO_HAS_MINIMUM_POA == 0) - virtual PortableServer::ImplicitActivationPolicy_ptr create_implicit_activation_policy ( - PortableServer::ImplicitActivationPolicyValue value - TAO_ENV_ARG_DECL_WITH_DEFAULTS) - + virtual ::PortableServer::ImplicitActivationPolicy_ptr create_implicit_activation_policy ( + PortableServer::ImplicitActivationPolicyValue value TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException )) = 0; - - virtual PortableServer::ServantRetentionPolicy_ptr create_servant_retention_policy ( - PortableServer::ServantRetentionPolicyValue value - TAO_ENV_ARG_DECL_WITH_DEFAULTS) - + + virtual ::PortableServer::ServantRetentionPolicy_ptr create_servant_retention_policy ( + PortableServer::ServantRetentionPolicyValue value TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException )) = 0; - - virtual PortableServer::RequestProcessingPolicy_ptr create_request_processing_policy ( - PortableServer::RequestProcessingPolicyValue value - TAO_ENV_ARG_DECL_WITH_DEFAULTS) - + + virtual ::PortableServer::RequestProcessingPolicy_ptr create_request_processing_policy ( + PortableServer::RequestProcessingPolicyValue value TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException )) = 0; - + #endif /* TAO_HAS_MINIMUM_POA == 0 */ virtual char * the_name ( - TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) - + TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException )) = 0; - - virtual PortableServer::POA_ptr the_parent ( - TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) - + + virtual ::PortableServer::POA_ptr the_parent ( + TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException )) = 0; - - virtual PortableServer::POAList * the_children ( - TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) - + + virtual ::PortableServer::POAList * the_children ( + TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException )) = 0; - - virtual PortableServer::POAManager_ptr the_POAManager ( - TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) - + + virtual ::PortableServer::POAManager_ptr the_POAManager ( + TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException )) = 0; - + #if (TAO_HAS_MINIMUM_POA == 0) - virtual PortableServer::AdapterActivator_ptr the_activator ( - TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) - + virtual ::PortableServer::AdapterActivator_ptr the_activator ( + TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException )) = 0; - + virtual void the_activator ( - PortableServer::AdapterActivator_ptr the_activator - TAO_ENV_ARG_DECL_WITH_DEFAULTS) - + PortableServer::AdapterActivator_ptr the_activator TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException )) = 0; - - virtual PortableServer::ServantManager_ptr get_servant_manager ( - TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) - + + virtual ::PortableServer::ServantManager_ptr get_servant_manager ( + TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException, PortableServer::POA::WrongPolicy )) = 0; - + virtual void set_servant_manager ( - PortableServer::ServantManager_ptr imgr - TAO_ENV_ARG_DECL_WITH_DEFAULTS) - + PortableServer::ServantManager_ptr imgr TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException, PortableServer::POA::WrongPolicy )) = 0; - - virtual PortableServer::Servant get_servant ( - TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) - + + virtual ::PortableServer::Servant get_servant ( + TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException, PortableServer::POA::NoServant, PortableServer::POA::WrongPolicy )) = 0; - + virtual void set_servant ( - PortableServer::Servant p_servant - TAO_ENV_ARG_DECL_WITH_DEFAULTS) - + PortableServer::Servant p_servant TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException, PortableServer::POA::WrongPolicy )) = 0; - + #endif /* TAO_HAS_MINIMUM_POA == 0 */ - virtual PortableServer::ObjectId * activate_object ( - PortableServer::Servant p_servant - TAO_ENV_ARG_DECL_WITH_DEFAULTS) - + virtual ::PortableServer::ObjectId * activate_object ( + PortableServer::Servant p_servant TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) 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 - TAO_ENV_ARG_DECL_WITH_DEFAULTS) - + PortableServer::Servant p_servant TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException, PortableServer::POA::ServantAlreadyActive, PortableServer::POA::ObjectAlreadyActive, PortableServer::POA::WrongPolicy )) = 0; - + virtual void deactivate_object ( - const PortableServer::ObjectId & oid - TAO_ENV_ARG_DECL_WITH_DEFAULTS) - + const PortableServer::ObjectId & oid TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException, PortableServer::POA::ObjectNotActive, PortableServer::POA::WrongPolicy )) = 0; - + virtual CORBA::Object_ptr create_reference ( - const char * intf - TAO_ENV_ARG_DECL_WITH_DEFAULTS) - + const char * intf TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException, PortableServer::POA::WrongPolicy )) = 0; - + virtual CORBA::Object_ptr create_reference_with_id ( const PortableServer::ObjectId & oid, - const char * intf - TAO_ENV_ARG_DECL_WITH_DEFAULTS) - + const char * intf TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException, PortableServer::POA::WrongPolicy )) = 0; - - virtual PortableServer::ObjectId * servant_to_id ( - PortableServer::Servant p_servant - TAO_ENV_ARG_DECL_WITH_DEFAULTS) - + + virtual ::PortableServer::ObjectId * servant_to_id ( + PortableServer::Servant p_servant TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException, PortableServer::POA::ServantNotActive, PortableServer::POA::WrongPolicy )) = 0; - + virtual CORBA::Object_ptr servant_to_reference ( - PortableServer::Servant p_servant - TAO_ENV_ARG_DECL_WITH_DEFAULTS) - + PortableServer::Servant p_servant TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException, PortableServer::POA::ServantNotActive, PortableServer::POA::WrongPolicy )) = 0; - - virtual PortableServer::Servant reference_to_servant ( - CORBA::Object_ptr reference - TAO_ENV_ARG_DECL_WITH_DEFAULTS) - + + virtual ::PortableServer::Servant reference_to_servant ( + CORBA::Object_ptr reference TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException, PortableServer::POA::ObjectNotActive, PortableServer::POA::WrongAdapter, PortableServer::POA::WrongPolicy )) = 0; - - virtual PortableServer::ObjectId * reference_to_id ( - CORBA::Object_ptr reference - TAO_ENV_ARG_DECL_WITH_DEFAULTS) - + + virtual ::PortableServer::ObjectId * reference_to_id ( + CORBA::Object_ptr reference TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException, PortableServer::POA::WrongAdapter, PortableServer::POA::WrongPolicy )) = 0; - - virtual PortableServer::Servant id_to_servant ( - const PortableServer::ObjectId & oid - TAO_ENV_ARG_DECL_WITH_DEFAULTS) - + + virtual ::PortableServer::Servant id_to_servant ( + const PortableServer::ObjectId & oid TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException, PortableServer::POA::ObjectNotActive, PortableServer::POA::WrongPolicy )) = 0; - + virtual CORBA::Object_ptr id_to_reference ( - const PortableServer::ObjectId & oid - TAO_ENV_ARG_DECL_WITH_DEFAULTS) - + const PortableServer::ObjectId & oid TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException, PortableServer::POA::ObjectNotActive, PortableServer::POA::WrongPolicy )) = 0; - - virtual CORBA::OctetSeq * id ( - TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) - + + virtual ::CORBA::OctetSeq * id ( + TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException )) = 0; - + + virtual ::PortableServer::ObjectId * create_id_for_reference ( + CORBA::Object_ptr the_ref TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + PortableServer::NotAGroupObject + )) = 0; + + virtual ::PortableServer::IDs * reference_to_ids ( + CORBA::Object_ptr the_ref TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + PortableServer::NotAGroupObject + )) = 0; + + virtual void associate_reference_with_id ( + CORBA::Object_ptr ref, + const PortableServer::ObjectId & oid TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + PortableServer::NotAGroupObject + )) = 0; + + virtual void disassociate_reference_with_id ( + CORBA::Object_ptr ref, + const PortableServer::ObjectId & oid TAO_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + PortableServer::NotAGroupObject + )) = 0; + virtual void *_tao_QueryInterface (ptr_arith_t type); - + virtual const char* _interface_repository_id (void) const; protected: - POA (); - + 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_PortableServer_Export Current_var : public TAO_Base_var { public: Current_var (void); // default constructor - Current_var (Current_ptr p) : ptr_ (p) {} + 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 + // 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; - + // Hooks used by template sequence and object manager classes // for non-defined forward declared interfaces. static Current_ptr tao_duplicate (Current_ptr); static void tao_release (Current_ptr); static Current_ptr tao_nil (void); - static Current_ptr tao_narrow (CORBA::Object * TAO_ENV_ARG_DECL_NOT_USED); + static Current_ptr tao_narrow ( + CORBA::Object * + TAO_ENV_ARG_DECL_NOT_USED + ); static CORBA::Object * tao_upcast (void *); - + private: Current_ptr ptr_; // Unimplemented - prevents widening assignment. @@ -3049,11 +3462,11 @@ class TAO_PortableServer_Export POA : public virtual CORBA_Object #endif /* end #if !defined */ - - + + #if !defined (_PORTABLESERVER_CURRENT___OUT_CH_) #define _PORTABLESERVER_CURRENT___OUT_CH_ - + class TAO_PortableServer_Export Current_out { public: @@ -3066,19 +3479,20 @@ class TAO_PortableServer_Export POA : public virtual CORBA_Object 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_PortableServer_Export Current: public virtual CORBA::Current + + class TAO_PortableServer_Export Current + : public virtual CORBA::Current { public: #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) @@ -3086,54 +3500,57 @@ class TAO_PortableServer_Export Current: public virtual CORBA::Current typedef Current_var _var_type; #endif /* ! __GNUC__ || g++ >= 2.8 */ - static int _tao_class_id; - - // the static operations + static int _tao_class_id; + + // The static operations. static Current_ptr _duplicate (Current_ptr obj); + static Current_ptr _narrow ( CORBA::Object_ptr obj - TAO_ENV_ARG_DECL_WITH_DEFAULTS); - + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ); + static Current_ptr _unchecked_narrow ( CORBA::Object_ptr obj - TAO_ENV_ARG_DECL_WITH_DEFAULTS); - + TAO_ENV_ARG_DECL_WITH_DEFAULTS + ); + static Current_ptr _nil (void) { return (Current_ptr)0; } - - + + #if !defined (_PORTABLESERVER_CURRENT_NOCONTEXT_CH_) #define _PORTABLESERVER_CURRENT_NOCONTEXT_CH_ - + class TAO_PortableServer_Export NoContext : public CORBA::UserException { public: - + NoContext (void); // Default constructor. - + NoContext (const NoContext &); // Copy constructor. - + ~NoContext (void); // Destructor. - + NoContext &operator= (const NoContext &); - + virtual void _raise (void); virtual void _tao_encode ( TAO_OutputCDR & TAO_ENV_ARG_DECL_NOT_USED ) const; - + virtual void _tao_decode ( TAO_InputCDR & TAO_ENV_ARG_DECL_NOT_USED ); - + static NoContext *_downcast (CORBA::Exception *); @@ -3143,45 +3560,45 @@ class TAO_PortableServer_Export Current: public virtual CORBA::Current #endif /* end #if !defined */ - - virtual PortableServer::POA_ptr get_POA ( - TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) - + + virtual ::PortableServer::POA_ptr get_POA ( + TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) ACE_THROW_SPEC (( CORBA::SystemException, PortableServer::Current::NoContext )) = 0; - - virtual PortableServer::ObjectId * get_object_id ( - TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) - + + virtual ::PortableServer::ObjectId * get_object_id ( + TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) 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 (); - + 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 @@ -3199,6 +3616,15 @@ TAO_PortableServer_Export CORBA::Boolean operator>>= (const CORBA::Any &, const #endif /* TAO_HAS_MINIMUM_CORBA == 0 */ +TAO_PortableServer_Export void operator<<= (CORBA::Any &, const PortableServer::NotAGroupObject &); // copying version +TAO_PortableServer_Export void operator<<= (CORBA::Any &, PortableServer::NotAGroupObject*); // noncopying version +TAO_PortableServer_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::NotAGroupObject *&); // deprecated +TAO_PortableServer_Export CORBA::Boolean operator>>= (const CORBA::Any &, const PortableServer::NotAGroupObject *&); +TAO_PortableServer_Export void operator<<= (CORBA::Any &, const PortableServer::IDs &); // copying version +TAO_PortableServer_Export void operator<<= (CORBA::Any &, PortableServer::IDs*); // noncopying version +TAO_PortableServer_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::IDs *&); // deprecated +TAO_PortableServer_Export CORBA::Boolean operator>>= (const CORBA::Any &, const PortableServer::IDs *&); + #if (TAO_HAS_MINIMUM_POA == 0) TAO_PortableServer_Export void operator<<= (CORBA::Any &, PortableServer::ThreadPolicyValue); @@ -3248,27 +3674,45 @@ TAO_PortableServer_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableSer #endif /* TAO_HAS_MINIMUM_CORBA == 0 */ +TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::NotAGroupObject &); +TAO_PortableServer_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::NotAGroupObject &); + + +#if !defined _TAO_CDR_OP_PortableServer_IDs_H_ +#define _TAO_CDR_OP_PortableServer_IDs_H_ + +TAO_PortableServer_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, + const PortableServer::IDs & + ); +TAO_PortableServer_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, + PortableServer::IDs & + ); + +#endif /* _TAO_CDR_OP_PortableServer_IDs_H_ */ + #if (TAO_HAS_MINIMUM_POA == 0) -TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ThreadPolicyValue &); // +TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ThreadPolicyValue &); // TAO_PortableServer_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::ThreadPolicyValue &); #endif /* TAO_HAS_MINIMUM_POA == 0 */ -TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::LifespanPolicyValue &); // +TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::LifespanPolicyValue &); // TAO_PortableServer_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::LifespanPolicyValue &); -TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::IdUniquenessPolicyValue &); // +TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::IdUniquenessPolicyValue &); // TAO_PortableServer_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::IdUniquenessPolicyValue &); -TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::IdAssignmentPolicyValue &); // +TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::IdAssignmentPolicyValue &); // TAO_PortableServer_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::IdAssignmentPolicyValue &); #if (TAO_HAS_MINIMUM_POA == 0) -TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ImplicitActivationPolicyValue &); // +TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ImplicitActivationPolicyValue &); // TAO_PortableServer_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::ImplicitActivationPolicyValue &); -TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ServantRetentionPolicyValue &); // +TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ServantRetentionPolicyValue &); // TAO_PortableServer_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::ServantRetentionPolicyValue &); -TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::RequestProcessingPolicyValue &); // +TAO_PortableServer_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::RequestProcessingPolicyValue &); // TAO_PortableServer_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::RequestProcessingPolicyValue &); #endif /* TAO_HAS_MINIMUM_POA == 0 */ |