diff options
Diffstat (limited to 'TAO/tao/PortableServer/PortableServerC.cpp')
| -rw-r--r-- | TAO/tao/PortableServer/PortableServerC.cpp | 2976 |
1 files changed, 2976 insertions, 0 deletions
diff --git a/TAO/tao/PortableServer/PortableServerC.cpp b/TAO/tao/PortableServer/PortableServerC.cpp new file mode 100644 index 00000000000..6ed213b5503 --- /dev/null +++ b/TAO/tao/PortableServer/PortableServerC.cpp @@ -0,0 +1,2976 @@ +/* -*- C++ -*- $Id$ */ + +// ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* +// TAO and the TAO IDL Compiler have been developed by the Center for +// Distributed Object Computing at Washington University, St. Louis. +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + +#include "PortableServerC.h" +#include "POA.h" +#include "tao/ORB.h" + +#if !defined (__ACE_INLINE__) +#include "PortableServerC.i" +#endif /* !defined INLINE */ + + +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_PORTABLESERVER_POALIST_CS_) +#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_PORTABLESERVER_POALIST_CS_ + + // The Base_Sequence functions, please see tao/Sequence.h + void + PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::_allocate_buffer (CORBA::ULong length) + { + PortableServer::POA **tmp = 0; + tmp = _TAO_Unbounded_Object_Sequence_PortableServer_POAList::allocbuf (length); + + if (this->buffer_ != 0) + { + PortableServer::POA **old = ACE_reinterpret_cast (PortableServer::POA**, this->buffer_); + for (CORBA::ULong i = 0; i < this->length_; ++i) + if (!this->release_) + tmp[i] = PortableServer::POA::_duplicate (old[i]); + else + tmp[i] = old[i]; + + if (this->release_) + delete[] old; + + } + this->buffer_ = tmp; + } + + void + PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::_deallocate_buffer (void) + { + if (this->buffer_ == 0 || this->release_ == 0) + return; + PortableServer::POA **tmp = ACE_reinterpret_cast (PortableServer::POA**, this->buffer_); + for (CORBA::ULong i = 0; i < this->length_; ++i) + { + CORBA::release (tmp[i]); + tmp[i] = PortableServer::POA::_nil (); + } + _TAO_Unbounded_Object_Sequence_PortableServer_POAList::freebuf (tmp); + this->buffer_ = 0; + } + + PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::~_TAO_Unbounded_Object_Sequence_PortableServer_POAList (void) + { + this->_deallocate_buffer (); + } + + void + PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol) + { + PortableServer::POA **tmp = ACE_reinterpret_cast (PortableServer::POA**, this->buffer_); + + for (CORBA::ULong i = nl; i < ol; ++i) + { + CORBA::release (tmp[i]); + tmp[i] = PortableServer::POA::_nil (); + } + } + void + PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::_downcast ( + void* target, + CORBA_Object *src, + CORBA_Environment &ACE_TRY_ENV + ) + { + PortableServer::POA **tmp = ACE_static_cast (PortableServer::POA**, target); + *tmp = PortableServer::POA::_narrow (src, ACE_TRY_ENV); + } + + CORBA_Object* + PortableServer::_TAO_Unbounded_Object_Sequence_PortableServer_POAList::_upcast (void *src) const + { + PortableServer::POA **tmp = ACE_static_cast (PortableServer::POA**, src); + return *tmp; + } + +#endif /* end #if !defined */ + + +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +#if !defined (_PORTABLESERVER_POALIST_CS_) +#define _PORTABLESERVER_POALIST_CS_ + +// ************************************************************* +// PortableServer::POAList +// ************************************************************* + +PortableServer::POAList::POAList (void) +{} +PortableServer::POAList::POAList (CORBA::ULong max) // uses max size + : +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Object_Sequence_PortableServer_POAList +#else /* TAO_USE_SEQUENCE_TEMPLATES */ + TAO_Unbounded_Object_Sequence<PortableServer::POA,PortableServer::POA_var> +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (max) +{} +PortableServer::POAList::POAList (CORBA::ULong max, CORBA::ULong length, PortableServer::POA_ptr *buffer, CORBA::Boolean release) + : +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Object_Sequence_PortableServer_POAList +#else /* TAO_USE_SEQUENCE_TEMPLATES */ + TAO_Unbounded_Object_Sequence<PortableServer::POA,PortableServer::POA_var> +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (max, length, buffer, release) +{} +PortableServer::POAList::POAList (const POAList &seq) // copy ctor + : +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Object_Sequence_PortableServer_POAList +#else /* TAO_USE_SEQUENCE_TEMPLATES */ + TAO_Unbounded_Object_Sequence<PortableServer::POA,PortableServer::POA_var> +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (seq) +{} +PortableServer::POAList::~POAList (void) // dtor +{} +void PortableServer::POAList::_tao_any_destructor (void *x) +{ + POAList *tmp = ACE_static_cast (POAList*,x); + delete tmp; +} + + +#endif /* end #if !defined */ + + +#if !defined (_PORTABLESERVER_OBJECTID_CS_) +#define _PORTABLESERVER_OBJECTID_CS_ + +// ************************************************************* +// PortableServer::ObjectId +// ************************************************************* + +PortableServer::ObjectId::ObjectId (void) +{} +PortableServer::ObjectId::ObjectId (CORBA::ULong max) // uses max size + : +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + TAO_Unbounded_Sequence<CORBA::Octet> +#else /* TAO_USE_SEQUENCE_TEMPLATES */ + TAO_Unbounded_Sequence<CORBA::Octet> +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (max) +{} +PortableServer::ObjectId::ObjectId (CORBA::ULong max, CORBA::ULong length, CORBA::Octet *buffer, CORBA::Boolean release) + : +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + TAO_Unbounded_Sequence<CORBA::Octet> +#else /* TAO_USE_SEQUENCE_TEMPLATES */ + TAO_Unbounded_Sequence<CORBA::Octet> +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (max, length, buffer, release) +{} +PortableServer::ObjectId::ObjectId (const ObjectId &seq) // copy ctor + : +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + TAO_Unbounded_Sequence<CORBA::Octet> +#else /* TAO_USE_SEQUENCE_TEMPLATES */ + TAO_Unbounded_Sequence<CORBA::Octet> +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (seq) +{} +PortableServer::ObjectId::~ObjectId (void) // dtor +{} +void PortableServer::ObjectId::_tao_any_destructor (void *x) +{ + ObjectId *tmp = ACE_static_cast (ObjectId*,x); + delete tmp; +} + + +#endif /* end #if !defined */ + +static const CORBA::Long _oc_PortableServer_ObjectId[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f4f), ACE_NTOHL (0x626a6563), ACE_NTOHL (0x7449643a), ACE_NTOHL (0x312e3000), // repository ID = IDL:PortableServer/ObjectId:1.0 + 9, ACE_NTOHL (0x4f626a65), ACE_NTOHL (0x63744964), ACE_NTOHL (0x0), // name = ObjectId + CORBA::tk_sequence, // typecode kind + 12, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + CORBA::tk_octet, + + 0U, + +}; +static CORBA::TypeCode _tc_TAO_tc_PortableServer_ObjectId (CORBA::tk_alias, sizeof (_oc_PortableServer_ObjectId), (char *) &_oc_PortableServer_ObjectId, 0, sizeof (PortableServer::ObjectId)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (PortableServer) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ObjectId, &_tc_TAO_tc_PortableServer_ObjectId) +TAO_NAMESPACE_END + +#if (TAO_HAS_MINIMUM_CORBA == 0) + +// default constructor +PortableServer::ForwardRequest::ForwardRequest (void) + : CORBA_UserException ("IDL:PortableServer/ForwardRequest:1.0") +{ +} + +// destructor - all members are of self managing types +PortableServer::ForwardRequest::~ForwardRequest (void) +{ +} + +void PortableServer::ForwardRequest::_tao_any_destructor (void *x) +{ + ForwardRequest *tmp = ACE_static_cast (ForwardRequest*,x); + delete tmp; +} + +// copy constructor +PortableServer::ForwardRequest::ForwardRequest (const ::PortableServer::ForwardRequest &_tao_excp) + : CORBA_UserException (_tao_excp._id ()) +{ + this->forward_reference = CORBA::Object::_duplicate (_tao_excp.forward_reference.in ()); +} + +// assignment operator +PortableServer::ForwardRequest& +PortableServer::ForwardRequest::operator= (const ::PortableServer::ForwardRequest &_tao_excp) +{ + + this->CORBA_UserException::operator= (_tao_excp); + this->forward_reference = CORBA::Object::_duplicate (_tao_excp.forward_reference.in ()); + return *this; +} + +// narrow +PortableServer::ForwardRequest * +PortableServer::ForwardRequest::_downcast (CORBA::Exception *exc) +{ + if (!ACE_OS::strcmp ("IDL:PortableServer/ForwardRequest:1.0", exc->_id ())) // same type + return ACE_dynamic_cast (ForwardRequest *, exc); + else + return 0; +} + + +void PortableServer::ForwardRequest::_raise () +{ + TAO_RAISE(*this); +} + + +void PortableServer::ForwardRequest::_tao_encode ( + TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + + +void PortableServer::ForwardRequest::_tao_decode ( + TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +// TAO extension - the _alloc method +CORBA::Exception *PortableServer::ForwardRequest::_alloc (void) +{ + CORBA::Exception *retval = 0; + ACE_NEW_RETURN (retval, ::PortableServer::ForwardRequest, 0); + return retval; +} + +PortableServer::ForwardRequest::ForwardRequest ( + const CORBA::Object_ptr _tao_forward_reference +) + : CORBA_UserException (CORBA::string_dup ("IDL:PortableServer/ForwardRequest:1.0")) +{ + this->forward_reference = CORBA::Object::_duplicate (_tao_forward_reference); +} + +static const CORBA::Long _oc_PortableServer_ForwardRequest[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 38, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f46), ACE_NTOHL (0x6f727761), ACE_NTOHL (0x72645265), ACE_NTOHL (0x71756573), ACE_NTOHL (0x743a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:PortableServer/ForwardRequest:1.0 + 15, ACE_NTOHL (0x466f7277), ACE_NTOHL (0x61726452), ACE_NTOHL (0x65717565), ACE_NTOHL (0x73740000), // name = ForwardRequest + 1, // member count + 18, ACE_NTOHL (0x666f7277), ACE_NTOHL (0x6172645f), ACE_NTOHL (0x72656665), ACE_NTOHL (0x72656e63), ACE_NTOHL (0x65000000), // name = forward_reference + CORBA::tk_objref, + 52, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 29, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4f62), ACE_NTOHL (0x6a656374), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:omg.org/CORBA/Object:1.0 + 7, ACE_NTOHL (0x4f626a65), ACE_NTOHL (0x63740000), // name = Object + +}; +static CORBA::TypeCode _tc_TAO_tc_PortableServer_ForwardRequest (CORBA::tk_except, sizeof (_oc_PortableServer_ForwardRequest), (char *) &_oc_PortableServer_ForwardRequest, 0, sizeof (PortableServer::ForwardRequest)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (PortableServer) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ForwardRequest, &_tc_TAO_tc_PortableServer_ForwardRequest) +TAO_NAMESPACE_END + +CORBA::TypeCode_ptr +PortableServer::ForwardRequest::_type (void) const +{ + return _tc_ForwardRequest; +} + +#endif /* TAO_HAS_MINIMUM_CORBA == 0 */ + +TAO_NAMESPACE_TYPE (const CORBA::ULong) +TAO_NAMESPACE_BEGIN (PortableServer) +TAO_NAMESPACE_DEFINE (const CORBA::ULong, THREAD_POLICY_ID, 16U) +TAO_NAMESPACE_END +TAO_NAMESPACE_TYPE (const CORBA::ULong) +TAO_NAMESPACE_BEGIN (PortableServer) +TAO_NAMESPACE_DEFINE (const CORBA::ULong, LIFESPAN_POLICY_ID, 17U) +TAO_NAMESPACE_END +TAO_NAMESPACE_TYPE (const CORBA::ULong) +TAO_NAMESPACE_BEGIN (PortableServer) +TAO_NAMESPACE_DEFINE (const CORBA::ULong, ID_UNIQUENESS_POLICY_ID, 18U) +TAO_NAMESPACE_END +TAO_NAMESPACE_TYPE (const CORBA::ULong) +TAO_NAMESPACE_BEGIN (PortableServer) +TAO_NAMESPACE_DEFINE (const CORBA::ULong, ID_ASSIGNMENT_POLICY_ID, 19U) +TAO_NAMESPACE_END +TAO_NAMESPACE_TYPE (const CORBA::ULong) +TAO_NAMESPACE_BEGIN (PortableServer) +TAO_NAMESPACE_DEFINE (const CORBA::ULong, IMPLICIT_ACTIVATION_POLICY_ID, 20U) +TAO_NAMESPACE_END +TAO_NAMESPACE_TYPE (const CORBA::ULong) +TAO_NAMESPACE_BEGIN (PortableServer) +TAO_NAMESPACE_DEFINE (const CORBA::ULong, SERVANT_RETENTION_POLICY_ID, 21U) +TAO_NAMESPACE_END +TAO_NAMESPACE_TYPE (const CORBA::ULong) +TAO_NAMESPACE_BEGIN (PortableServer) +TAO_NAMESPACE_DEFINE (const CORBA::ULong, REQUEST_PROCESSING_POLICY_ID, 22U) +TAO_NAMESPACE_END + +#if (TAO_HAS_MINIMUM_POA == 0) + +static const CORBA::Long _oc_PortableServer_ThreadPolicyValue[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f54), ACE_NTOHL (0x68726561), ACE_NTOHL (0x64506f6c), ACE_NTOHL (0x69637956), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:PortableServer/ThreadPolicyValue:1.0 + 18, ACE_NTOHL (0x54687265), ACE_NTOHL (0x6164506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x56616c75), ACE_NTOHL (0x65000000), // name = ThreadPolicyValue + 2, // member count + 15, ACE_NTOHL (0x4f52425f), ACE_NTOHL (0x4354524c), ACE_NTOHL (0x5f4d4f44), ACE_NTOHL (0x454c0000), // name = ORB_CTRL_MODEL + 20, ACE_NTOHL (0x53494e47), ACE_NTOHL (0x4c455f54), ACE_NTOHL (0x48524541), ACE_NTOHL (0x445f4d4f), ACE_NTOHL (0x44454c00), // name = SINGLE_THREAD_MODEL +}; +static CORBA::TypeCode _tc_TAO_tc_PortableServer_ThreadPolicyValue (CORBA::tk_enum, sizeof (_oc_PortableServer_ThreadPolicyValue), (char *) &_oc_PortableServer_ThreadPolicyValue, 0, sizeof (PortableServer::ThreadPolicyValue)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (PortableServer) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ThreadPolicyValue, &_tc_TAO_tc_PortableServer_ThreadPolicyValue) +TAO_NAMESPACE_END + +// default constructor +PortableServer::ThreadPolicy::ThreadPolicy (void) +{} + +// destructor +PortableServer::ThreadPolicy::~ThreadPolicy (void) +{} + +PortableServer::ThreadPolicy_ptr PortableServer::ThreadPolicy::_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV + ) +{ + return ThreadPolicy::_unchecked_narrow (obj, ACE_TRY_ENV); +} + +PortableServer::ThreadPolicy_ptr PortableServer::ThreadPolicy::_unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment & + ) +{ + if (CORBA::is_nil (obj)) + return ThreadPolicy::_nil (); + return + ACE_reinterpret_cast + ( + ThreadPolicy_ptr, + obj->_tao_QueryInterface + ( + ACE_reinterpret_cast + ( + ptr_arith_t, + &ThreadPolicy::_narrow + ) + ) + ); +} + +PortableServer::ThreadPolicy_ptr +PortableServer::ThreadPolicy::_duplicate (ThreadPolicy_ptr obj) +{ + if (!CORBA::is_nil (obj)) + obj->_add_ref (); + return obj; +} + +void *PortableServer::ThreadPolicy::_tao_QueryInterface (ptr_arith_t type) +{ + void *retv = 0; + if (type == ACE_reinterpret_cast + (ptr_arith_t, + &ACE_NESTED_CLASS (::PortableServer, ThreadPolicy)::_narrow)) + retv = ACE_reinterpret_cast (void*, this); + else if (type == ACE_reinterpret_cast + (ptr_arith_t, + &::CORBA::Policy::_narrow)) + retv = ACE_reinterpret_cast + ( + void *, + ACE_static_cast + ( + CORBA::Policy_ptr, + this + ) + ); + else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow)) + retv = ACE_reinterpret_cast (void *, + ACE_static_cast (CORBA::Object_ptr, this)); + + if (retv) + this->_add_ref (); + return retv; +} + +const char* PortableServer::ThreadPolicy::_interface_repository_id (void) const +{ + return "IDL:PortableServer/ThreadPolicy:1.0"; +} + +#endif /* TAO_HAS_MINIMUM_POA == 0 */ + +static const CORBA::Long _oc_PortableServer_LifespanPolicyValue[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 43, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f4c), ACE_NTOHL (0x69666573), ACE_NTOHL (0x70616e50), ACE_NTOHL (0x6f6c6963), ACE_NTOHL (0x7956616c), ACE_NTOHL (0x75653a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:PortableServer/LifespanPolicyValue:1.0 + 20, ACE_NTOHL (0x4c696665), ACE_NTOHL (0x7370616e), ACE_NTOHL (0x506f6c69), ACE_NTOHL (0x63795661), ACE_NTOHL (0x6c756500), // name = LifespanPolicyValue + 2, // member count + 10, ACE_NTOHL (0x5452414e), ACE_NTOHL (0x5349454e), ACE_NTOHL (0x54000000), // name = TRANSIENT + 11, ACE_NTOHL (0x50455253), ACE_NTOHL (0x49535445), ACE_NTOHL (0x4e540000), // name = PERSISTENT +}; +static CORBA::TypeCode _tc_TAO_tc_PortableServer_LifespanPolicyValue (CORBA::tk_enum, sizeof (_oc_PortableServer_LifespanPolicyValue), (char *) &_oc_PortableServer_LifespanPolicyValue, 0, sizeof (PortableServer::LifespanPolicyValue)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (PortableServer) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_LifespanPolicyValue, &_tc_TAO_tc_PortableServer_LifespanPolicyValue) +TAO_NAMESPACE_END + +// default constructor +PortableServer::LifespanPolicy::LifespanPolicy (void) +{} + +// destructor +PortableServer::LifespanPolicy::~LifespanPolicy (void) +{} + +PortableServer::LifespanPolicy_ptr PortableServer::LifespanPolicy::_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV + ) +{ + return LifespanPolicy::_unchecked_narrow (obj, ACE_TRY_ENV); +} + +PortableServer::LifespanPolicy_ptr PortableServer::LifespanPolicy::_unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment & + ) +{ + if (CORBA::is_nil (obj)) + return LifespanPolicy::_nil (); + return + ACE_reinterpret_cast + ( + LifespanPolicy_ptr, + obj->_tao_QueryInterface + ( + ACE_reinterpret_cast + ( + ptr_arith_t, + &LifespanPolicy::_narrow + ) + ) + ); +} + +PortableServer::LifespanPolicy_ptr +PortableServer::LifespanPolicy::_duplicate (LifespanPolicy_ptr obj) +{ + if (!CORBA::is_nil (obj)) + obj->_add_ref (); + return obj; +} + +void *PortableServer::LifespanPolicy::_tao_QueryInterface (ptr_arith_t type) +{ + void *retv = 0; + if (type == ACE_reinterpret_cast + (ptr_arith_t, + &ACE_NESTED_CLASS (::PortableServer, LifespanPolicy)::_narrow)) + retv = ACE_reinterpret_cast (void*, this); + else if (type == ACE_reinterpret_cast + (ptr_arith_t, + &::CORBA::Policy::_narrow)) + retv = ACE_reinterpret_cast + ( + void *, + ACE_static_cast + ( + CORBA::Policy_ptr, + this + ) + ); + else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow)) + retv = ACE_reinterpret_cast (void *, + ACE_static_cast (CORBA::Object_ptr, this)); + + if (retv) + this->_add_ref (); + return retv; +} + +const char* PortableServer::LifespanPolicy::_interface_repository_id (void) const +{ + return "IDL:PortableServer/LifespanPolicy:1.0"; +} + +static const CORBA::Long _oc_PortableServer_IdUniquenessPolicyValue[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 47, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f49), ACE_NTOHL (0x64556e69), ACE_NTOHL (0x7175656e), ACE_NTOHL (0x65737350), ACE_NTOHL (0x6f6c6963), ACE_NTOHL (0x7956616c), ACE_NTOHL (0x75653a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:PortableServer/IdUniquenessPolicyValue:1.0 + 24, ACE_NTOHL (0x4964556e), ACE_NTOHL (0x69717565), ACE_NTOHL (0x6e657373), ACE_NTOHL (0x506f6c69), ACE_NTOHL (0x63795661), ACE_NTOHL (0x6c756500), // name = IdUniquenessPolicyValue + 2, // member count + 10, ACE_NTOHL (0x554e4951), ACE_NTOHL (0x55455f49), ACE_NTOHL (0x44000000), // name = UNIQUE_ID + 12, ACE_NTOHL (0x4d554c54), ACE_NTOHL (0x49504c45), ACE_NTOHL (0x5f494400), // name = MULTIPLE_ID +}; +static CORBA::TypeCode _tc_TAO_tc_PortableServer_IdUniquenessPolicyValue (CORBA::tk_enum, sizeof (_oc_PortableServer_IdUniquenessPolicyValue), (char *) &_oc_PortableServer_IdUniquenessPolicyValue, 0, sizeof (PortableServer::IdUniquenessPolicyValue)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (PortableServer) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_IdUniquenessPolicyValue, &_tc_TAO_tc_PortableServer_IdUniquenessPolicyValue) +TAO_NAMESPACE_END + +// default constructor +PortableServer::IdUniquenessPolicy::IdUniquenessPolicy (void) +{} + +// destructor +PortableServer::IdUniquenessPolicy::~IdUniquenessPolicy (void) +{} + +PortableServer::IdUniquenessPolicy_ptr PortableServer::IdUniquenessPolicy::_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV + ) +{ + return IdUniquenessPolicy::_unchecked_narrow (obj, ACE_TRY_ENV); +} + +PortableServer::IdUniquenessPolicy_ptr PortableServer::IdUniquenessPolicy::_unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment & + ) +{ + if (CORBA::is_nil (obj)) + return IdUniquenessPolicy::_nil (); + return + ACE_reinterpret_cast + ( + IdUniquenessPolicy_ptr, + obj->_tao_QueryInterface + ( + ACE_reinterpret_cast + ( + ptr_arith_t, + &IdUniquenessPolicy::_narrow + ) + ) + ); +} + +PortableServer::IdUniquenessPolicy_ptr +PortableServer::IdUniquenessPolicy::_duplicate (IdUniquenessPolicy_ptr obj) +{ + if (!CORBA::is_nil (obj)) + obj->_add_ref (); + return obj; +} + +void *PortableServer::IdUniquenessPolicy::_tao_QueryInterface (ptr_arith_t type) +{ + void *retv = 0; + if (type == ACE_reinterpret_cast + (ptr_arith_t, + &ACE_NESTED_CLASS (::PortableServer, IdUniquenessPolicy)::_narrow)) + retv = ACE_reinterpret_cast (void*, this); + else if (type == ACE_reinterpret_cast + (ptr_arith_t, + &::CORBA::Policy::_narrow)) + retv = ACE_reinterpret_cast + ( + void *, + ACE_static_cast + ( + CORBA::Policy_ptr, + this + ) + ); + else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow)) + retv = ACE_reinterpret_cast (void *, + ACE_static_cast (CORBA::Object_ptr, this)); + + if (retv) + this->_add_ref (); + return retv; +} + +const char* PortableServer::IdUniquenessPolicy::_interface_repository_id (void) const +{ + return "IDL:PortableServer/IdUniquenessPolicy:1.0"; +} + +static const CORBA::Long _oc_PortableServer_IdAssignmentPolicyValue[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 47, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f49), ACE_NTOHL (0x64417373), ACE_NTOHL (0x69676e6d), ACE_NTOHL (0x656e7450), ACE_NTOHL (0x6f6c6963), ACE_NTOHL (0x7956616c), ACE_NTOHL (0x75653a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:PortableServer/IdAssignmentPolicyValue:1.0 + 24, ACE_NTOHL (0x49644173), ACE_NTOHL (0x7369676e), ACE_NTOHL (0x6d656e74), ACE_NTOHL (0x506f6c69), ACE_NTOHL (0x63795661), ACE_NTOHL (0x6c756500), // name = IdAssignmentPolicyValue + 2, // member count + 8, ACE_NTOHL (0x55534552), ACE_NTOHL (0x5f494400), // name = USER_ID + 10, ACE_NTOHL (0x53595354), ACE_NTOHL (0x454d5f49), ACE_NTOHL (0x44000000), // name = SYSTEM_ID +}; +static CORBA::TypeCode _tc_TAO_tc_PortableServer_IdAssignmentPolicyValue (CORBA::tk_enum, sizeof (_oc_PortableServer_IdAssignmentPolicyValue), (char *) &_oc_PortableServer_IdAssignmentPolicyValue, 0, sizeof (PortableServer::IdAssignmentPolicyValue)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (PortableServer) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_IdAssignmentPolicyValue, &_tc_TAO_tc_PortableServer_IdAssignmentPolicyValue) +TAO_NAMESPACE_END + +// default constructor +PortableServer::IdAssignmentPolicy::IdAssignmentPolicy (void) +{} + +// destructor +PortableServer::IdAssignmentPolicy::~IdAssignmentPolicy (void) +{} + +PortableServer::IdAssignmentPolicy_ptr PortableServer::IdAssignmentPolicy::_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV + ) +{ + return IdAssignmentPolicy::_unchecked_narrow (obj, ACE_TRY_ENV); +} + +PortableServer::IdAssignmentPolicy_ptr PortableServer::IdAssignmentPolicy::_unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment & + ) +{ + if (CORBA::is_nil (obj)) + return IdAssignmentPolicy::_nil (); + return + ACE_reinterpret_cast + ( + IdAssignmentPolicy_ptr, + obj->_tao_QueryInterface + ( + ACE_reinterpret_cast + ( + ptr_arith_t, + &IdAssignmentPolicy::_narrow + ) + ) + ); +} + +PortableServer::IdAssignmentPolicy_ptr +PortableServer::IdAssignmentPolicy::_duplicate (IdAssignmentPolicy_ptr obj) +{ + if (!CORBA::is_nil (obj)) + obj->_add_ref (); + return obj; +} + +void *PortableServer::IdAssignmentPolicy::_tao_QueryInterface (ptr_arith_t type) +{ + void *retv = 0; + if (type == ACE_reinterpret_cast + (ptr_arith_t, + &ACE_NESTED_CLASS (::PortableServer, IdAssignmentPolicy)::_narrow)) + retv = ACE_reinterpret_cast (void*, this); + else if (type == ACE_reinterpret_cast + (ptr_arith_t, + &::CORBA::Policy::_narrow)) + retv = ACE_reinterpret_cast + ( + void *, + ACE_static_cast + ( + CORBA::Policy_ptr, + this + ) + ); + else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow)) + retv = ACE_reinterpret_cast (void *, + ACE_static_cast (CORBA::Object_ptr, this)); + + if (retv) + this->_add_ref (); + return retv; +} + +const char* PortableServer::IdAssignmentPolicy::_interface_repository_id (void) const +{ + return "IDL:PortableServer/IdAssignmentPolicy:1.0"; +} + +#if (TAO_HAS_MINIMUM_POA == 0) + +static const CORBA::Long _oc_PortableServer_ImplicitActivationPolicyValue[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 53, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f49), ACE_NTOHL (0x6d706c69), ACE_NTOHL (0x63697441), ACE_NTOHL (0x63746976), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e506f6c), ACE_NTOHL (0x69637956), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:PortableServer/ImplicitActivationPolicyValue:1.0 + 30, ACE_NTOHL (0x496d706c), ACE_NTOHL (0x69636974), ACE_NTOHL (0x41637469), ACE_NTOHL (0x76617469), ACE_NTOHL (0x6f6e506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x56616c75), ACE_NTOHL (0x65000000), // name = ImplicitActivationPolicyValue + 2, // member count + 20, ACE_NTOHL (0x494d504c), ACE_NTOHL (0x49434954), ACE_NTOHL (0x5f414354), ACE_NTOHL (0x49564154), ACE_NTOHL (0x494f4e00), // name = IMPLICIT_ACTIVATION + 23, ACE_NTOHL (0x4e4f5f49), ACE_NTOHL (0x4d504c49), ACE_NTOHL (0x4349545f), ACE_NTOHL (0x41435449), ACE_NTOHL (0x56415449), ACE_NTOHL (0x4f4e0000), // name = NO_IMPLICIT_ACTIVATION +}; +static CORBA::TypeCode _tc_TAO_tc_PortableServer_ImplicitActivationPolicyValue (CORBA::tk_enum, sizeof (_oc_PortableServer_ImplicitActivationPolicyValue), (char *) &_oc_PortableServer_ImplicitActivationPolicyValue, 0, sizeof (PortableServer::ImplicitActivationPolicyValue)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (PortableServer) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ImplicitActivationPolicyValue, &_tc_TAO_tc_PortableServer_ImplicitActivationPolicyValue) +TAO_NAMESPACE_END + +// default constructor +PortableServer::ImplicitActivationPolicy::ImplicitActivationPolicy (void) +{} + +// destructor +PortableServer::ImplicitActivationPolicy::~ImplicitActivationPolicy (void) +{} + +PortableServer::ImplicitActivationPolicy_ptr PortableServer::ImplicitActivationPolicy::_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV + ) +{ + return ImplicitActivationPolicy::_unchecked_narrow (obj, ACE_TRY_ENV); +} + +PortableServer::ImplicitActivationPolicy_ptr PortableServer::ImplicitActivationPolicy::_unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment & + ) +{ + if (CORBA::is_nil (obj)) + return ImplicitActivationPolicy::_nil (); + return + ACE_reinterpret_cast + ( + ImplicitActivationPolicy_ptr, + obj->_tao_QueryInterface + ( + ACE_reinterpret_cast + ( + ptr_arith_t, + &ImplicitActivationPolicy::_narrow + ) + ) + ); +} + +PortableServer::ImplicitActivationPolicy_ptr +PortableServer::ImplicitActivationPolicy::_duplicate (ImplicitActivationPolicy_ptr obj) +{ + if (!CORBA::is_nil (obj)) + obj->_add_ref (); + return obj; +} + +void *PortableServer::ImplicitActivationPolicy::_tao_QueryInterface (ptr_arith_t type) +{ + void *retv = 0; + if (type == ACE_reinterpret_cast + (ptr_arith_t, + &ACE_NESTED_CLASS (::PortableServer, ImplicitActivationPolicy)::_narrow)) + retv = ACE_reinterpret_cast (void*, this); + else if (type == ACE_reinterpret_cast + (ptr_arith_t, + &::CORBA::Policy::_narrow)) + retv = ACE_reinterpret_cast + ( + void *, + ACE_static_cast + ( + CORBA::Policy_ptr, + this + ) + ); + else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow)) + retv = ACE_reinterpret_cast (void *, + ACE_static_cast (CORBA::Object_ptr, this)); + + if (retv) + this->_add_ref (); + return retv; +} + +const char* PortableServer::ImplicitActivationPolicy::_interface_repository_id (void) const +{ + return "IDL:PortableServer/ImplicitActivationPolicy:1.0"; +} + +static const CORBA::Long _oc_PortableServer_ServantRetentionPolicyValue[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 51, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f53), ACE_NTOHL (0x65727661), ACE_NTOHL (0x6e745265), ACE_NTOHL (0x74656e74), ACE_NTOHL (0x696f6e50), ACE_NTOHL (0x6f6c6963), ACE_NTOHL (0x7956616c), ACE_NTOHL (0x75653a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:PortableServer/ServantRetentionPolicyValue:1.0 + 28, ACE_NTOHL (0x53657276), ACE_NTOHL (0x616e7452), ACE_NTOHL (0x6574656e), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x506f6c69), ACE_NTOHL (0x63795661), ACE_NTOHL (0x6c756500), // name = ServantRetentionPolicyValue + 2, // member count + 7, ACE_NTOHL (0x52455441), ACE_NTOHL (0x494e0000), // name = RETAIN + 11, ACE_NTOHL (0x4e4f4e5f), ACE_NTOHL (0x52455441), ACE_NTOHL (0x494e0000), // name = NON_RETAIN +}; +static CORBA::TypeCode _tc_TAO_tc_PortableServer_ServantRetentionPolicyValue (CORBA::tk_enum, sizeof (_oc_PortableServer_ServantRetentionPolicyValue), (char *) &_oc_PortableServer_ServantRetentionPolicyValue, 0, sizeof (PortableServer::ServantRetentionPolicyValue)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (PortableServer) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ServantRetentionPolicyValue, &_tc_TAO_tc_PortableServer_ServantRetentionPolicyValue) +TAO_NAMESPACE_END + +// default constructor +PortableServer::ServantRetentionPolicy::ServantRetentionPolicy (void) +{} + +// destructor +PortableServer::ServantRetentionPolicy::~ServantRetentionPolicy (void) +{} + +PortableServer::ServantRetentionPolicy_ptr PortableServer::ServantRetentionPolicy::_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV + ) +{ + return ServantRetentionPolicy::_unchecked_narrow (obj, ACE_TRY_ENV); +} + +PortableServer::ServantRetentionPolicy_ptr PortableServer::ServantRetentionPolicy::_unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment & + ) +{ + if (CORBA::is_nil (obj)) + return ServantRetentionPolicy::_nil (); + return + ACE_reinterpret_cast + ( + ServantRetentionPolicy_ptr, + obj->_tao_QueryInterface + ( + ACE_reinterpret_cast + ( + ptr_arith_t, + &ServantRetentionPolicy::_narrow + ) + ) + ); +} + +PortableServer::ServantRetentionPolicy_ptr +PortableServer::ServantRetentionPolicy::_duplicate (ServantRetentionPolicy_ptr obj) +{ + if (!CORBA::is_nil (obj)) + obj->_add_ref (); + return obj; +} + +void *PortableServer::ServantRetentionPolicy::_tao_QueryInterface (ptr_arith_t type) +{ + void *retv = 0; + if (type == ACE_reinterpret_cast + (ptr_arith_t, + &ACE_NESTED_CLASS (::PortableServer, ServantRetentionPolicy)::_narrow)) + retv = ACE_reinterpret_cast (void*, this); + else if (type == ACE_reinterpret_cast + (ptr_arith_t, + &::CORBA::Policy::_narrow)) + retv = ACE_reinterpret_cast + ( + void *, + ACE_static_cast + ( + CORBA::Policy_ptr, + this + ) + ); + else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow)) + retv = ACE_reinterpret_cast (void *, + ACE_static_cast (CORBA::Object_ptr, this)); + + if (retv) + this->_add_ref (); + return retv; +} + +const char* PortableServer::ServantRetentionPolicy::_interface_repository_id (void) const +{ + return "IDL:PortableServer/ServantRetentionPolicy:1.0"; +} + +static const CORBA::Long _oc_PortableServer_RequestProcessingPolicyValue[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 52, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f52), ACE_NTOHL (0x65717565), ACE_NTOHL (0x73745072), ACE_NTOHL (0x6f636573), ACE_NTOHL (0x73696e67), ACE_NTOHL (0x506f6c69), ACE_NTOHL (0x63795661), ACE_NTOHL (0x6c75653a), ACE_NTOHL (0x312e3000), // repository ID = IDL:PortableServer/RequestProcessingPolicyValue:1.0 + 29, ACE_NTOHL (0x52657175), ACE_NTOHL (0x65737450), ACE_NTOHL (0x726f6365), ACE_NTOHL (0x7373696e), ACE_NTOHL (0x67506f6c), ACE_NTOHL (0x69637956), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x0), // name = RequestProcessingPolicyValue + 3, // member count + 27, ACE_NTOHL (0x5553455f), ACE_NTOHL (0x41435449), ACE_NTOHL (0x56455f4f), ACE_NTOHL (0x424a4543), ACE_NTOHL (0x545f4d41), ACE_NTOHL (0x505f4f4e), ACE_NTOHL (0x4c590000), // name = USE_ACTIVE_OBJECT_MAP_ONLY + 20, ACE_NTOHL (0x5553455f), ACE_NTOHL (0x44454641), ACE_NTOHL (0x554c545f), ACE_NTOHL (0x53455256), ACE_NTOHL (0x414e5400), // name = USE_DEFAULT_SERVANT + 20, ACE_NTOHL (0x5553455f), ACE_NTOHL (0x53455256), ACE_NTOHL (0x414e545f), ACE_NTOHL (0x4d414e41), ACE_NTOHL (0x47455200), // name = USE_SERVANT_MANAGER +}; +static CORBA::TypeCode _tc_TAO_tc_PortableServer_RequestProcessingPolicyValue (CORBA::tk_enum, sizeof (_oc_PortableServer_RequestProcessingPolicyValue), (char *) &_oc_PortableServer_RequestProcessingPolicyValue, 0, sizeof (PortableServer::RequestProcessingPolicyValue)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (PortableServer) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_RequestProcessingPolicyValue, &_tc_TAO_tc_PortableServer_RequestProcessingPolicyValue) +TAO_NAMESPACE_END + +// default constructor +PortableServer::RequestProcessingPolicy::RequestProcessingPolicy (void) +{} + +// destructor +PortableServer::RequestProcessingPolicy::~RequestProcessingPolicy (void) +{} + +PortableServer::RequestProcessingPolicy_ptr PortableServer::RequestProcessingPolicy::_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV + ) +{ + return RequestProcessingPolicy::_unchecked_narrow (obj, ACE_TRY_ENV); +} + +PortableServer::RequestProcessingPolicy_ptr PortableServer::RequestProcessingPolicy::_unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment & + ) +{ + if (CORBA::is_nil (obj)) + return RequestProcessingPolicy::_nil (); + return + ACE_reinterpret_cast + ( + RequestProcessingPolicy_ptr, + obj->_tao_QueryInterface + ( + ACE_reinterpret_cast + ( + ptr_arith_t, + &RequestProcessingPolicy::_narrow + ) + ) + ); +} + +PortableServer::RequestProcessingPolicy_ptr +PortableServer::RequestProcessingPolicy::_duplicate (RequestProcessingPolicy_ptr obj) +{ + if (!CORBA::is_nil (obj)) + obj->_add_ref (); + return obj; +} + +void *PortableServer::RequestProcessingPolicy::_tao_QueryInterface (ptr_arith_t type) +{ + void *retv = 0; + if (type == ACE_reinterpret_cast + (ptr_arith_t, + &ACE_NESTED_CLASS (::PortableServer, RequestProcessingPolicy)::_narrow)) + retv = ACE_reinterpret_cast (void*, this); + else if (type == ACE_reinterpret_cast + (ptr_arith_t, + &::CORBA::Policy::_narrow)) + retv = ACE_reinterpret_cast + ( + void *, + ACE_static_cast + ( + CORBA::Policy_ptr, + this + ) + ); + else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow)) + retv = ACE_reinterpret_cast (void *, + ACE_static_cast (CORBA::Object_ptr, this)); + + if (retv) + this->_add_ref (); + return retv; +} + +const char* PortableServer::RequestProcessingPolicy::_interface_repository_id (void) const +{ + return "IDL:PortableServer/RequestProcessingPolicy:1.0"; +} + +#endif /* TAO_HAS_MINIMUM_POA == 0 */ + +// default constructor +PortableServer::POAManager::POAManager (void) +{} + +// destructor +PortableServer::POAManager::~POAManager (void) +{} + +PortableServer::POAManager_ptr PortableServer::POAManager::_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV + ) +{ + return POAManager::_unchecked_narrow (obj, ACE_TRY_ENV); +} + +PortableServer::POAManager_ptr PortableServer::POAManager::_unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment & + ) +{ + if (CORBA::is_nil (obj)) + return POAManager::_nil (); + return + ACE_reinterpret_cast + ( + POAManager_ptr, + obj->_tao_QueryInterface + ( + ACE_reinterpret_cast + ( + ptr_arith_t, + &POAManager::_narrow + ) + ) + ); +} + +PortableServer::POAManager_ptr +PortableServer::POAManager::_duplicate (POAManager_ptr obj) +{ + if (!CORBA::is_nil (obj)) + obj->_add_ref (); + return obj; +} + +void *PortableServer::POAManager::_tao_QueryInterface (ptr_arith_t type) +{ + void *retv = 0; + if (type == ACE_reinterpret_cast + (ptr_arith_t, + &ACE_NESTED_CLASS (::PortableServer, POAManager)::_narrow)) + retv = ACE_reinterpret_cast (void*, this); + else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow)) + retv = ACE_reinterpret_cast (void *, + ACE_static_cast (CORBA::Object_ptr, this)); + + if (retv) + this->_add_ref (); + return retv; +} + + +const char* PortableServer::POAManager::_interface_repository_id (void) const +{ + return "IDL:PortableServer/POAManager:1.0"; +} + +// default constructor +PortableServer::POAManager::AdapterInactive::AdapterInactive (void) +{ +} + +// destructor - all members are of self managing types +PortableServer::POAManager::AdapterInactive::~AdapterInactive (void) +{ +} + +void PortableServer::POAManager::AdapterInactive::_raise () +{ + TAO_RAISE(*this); +} + + +void PortableServer::POAManager::AdapterInactive::_tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &ACE_TRY_ENV) const +{ + ACE_THROW (CORBA::MARSHAL ()); +} + +void PortableServer::POAManager::AdapterInactive::_tao_decode ( + TAO_InputCDR &, + CORBA::Environment &ACE_TRY_ENV) +{ + ACE_THROW (CORBA::MARSHAL ()); +} + + +#if (TAO_HAS_MINIMUM_POA == 0) + +// copy constructor +PortableServer::POAManager::AdapterInactive::AdapterInactive (const ::PortableServer::POAManager::AdapterInactive &_tao_excp) + : CORBA_UserException (_tao_excp._id ()) +{ +} + +// assignment operator +PortableServer::POAManager::AdapterInactive& +PortableServer::POAManager::AdapterInactive::operator= (const ::PortableServer::POAManager::AdapterInactive &_tao_excp) +{ + + this->CORBA_UserException::operator= (_tao_excp); + return *this; +} + +// narrow +PortableServer::POAManager::AdapterInactive * +PortableServer::POAManager::AdapterInactive::_downcast (CORBA::Exception *exc) +{ + if (!ACE_OS::strcmp ("IDL:PortableServer/POAManager/AdapterInactive:1.0", exc->_id ())) // same type + return ACE_dynamic_cast (AdapterInactive *, exc); + else + return 0; +} + + +// TAO extension - the _alloc method +CORBA::Exception *PortableServer::POAManager::AdapterInactive::_alloc (void) +{ + CORBA::Exception *retval = 0; + ACE_NEW_RETURN (retval, ::PortableServer::POAManager::AdapterInactive, 0); + return retval; +} + +// default constructor +PortableServer::AdapterActivator::AdapterActivator (void) +{} + +// destructor +PortableServer::AdapterActivator::~AdapterActivator (void) +{} + +PortableServer::AdapterActivator_ptr PortableServer::AdapterActivator::_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV + ) +{ + return AdapterActivator::_unchecked_narrow (obj, ACE_TRY_ENV); +} + +PortableServer::AdapterActivator_ptr PortableServer::AdapterActivator::_unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment & + ) +{ + if (CORBA::is_nil (obj)) + return AdapterActivator::_nil (); + return + ACE_reinterpret_cast + ( + AdapterActivator_ptr, + obj->_tao_QueryInterface + ( + ACE_reinterpret_cast + ( + ptr_arith_t, + &AdapterActivator::_narrow + ) + ) + ); +} + +PortableServer::AdapterActivator_ptr +PortableServer::AdapterActivator::_duplicate (AdapterActivator_ptr obj) +{ + if (!CORBA::is_nil (obj)) + obj->_add_ref (); + return obj; +} + +void *PortableServer::AdapterActivator::_tao_QueryInterface (ptr_arith_t type) +{ + void *retv = 0; + if (type == ACE_reinterpret_cast + (ptr_arith_t, + &ACE_NESTED_CLASS (::PortableServer, AdapterActivator)::_narrow)) + retv = ACE_reinterpret_cast (void*, this); + else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow)) + retv = ACE_reinterpret_cast (void *, + ACE_static_cast (CORBA::Object_ptr, this)); + + if (retv) + this->_add_ref (); + return retv; +} + +const char* PortableServer::AdapterActivator::_interface_repository_id (void) const +{ + return "IDL:PortableServer/AdapterActivator:1.0"; +} + + +// default constructor +PortableServer::ServantManager::ServantManager (void) +{} + +// destructor +PortableServer::ServantManager::~ServantManager (void) +{} + +PortableServer::ServantManager_ptr PortableServer::ServantManager::_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV + ) +{ + return ServantManager::_unchecked_narrow (obj, ACE_TRY_ENV); +} + +PortableServer::ServantManager_ptr PortableServer::ServantManager::_unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment & + ) +{ + if (CORBA::is_nil (obj)) + return ServantManager::_nil (); + return + ACE_reinterpret_cast + ( + ServantManager_ptr, + obj->_tao_QueryInterface + ( + ACE_reinterpret_cast + ( + ptr_arith_t, + &ServantManager::_narrow + ) + ) + ); +} + +PortableServer::ServantManager_ptr +PortableServer::ServantManager::_duplicate (ServantManager_ptr obj) +{ + if (!CORBA::is_nil (obj)) + obj->_add_ref (); + return obj; +} + +void *PortableServer::ServantManager::_tao_QueryInterface (ptr_arith_t type) +{ + void *retv = 0; + if (type == ACE_reinterpret_cast + (ptr_arith_t, + &ACE_NESTED_CLASS (::PortableServer, ServantManager)::_narrow)) + retv = ACE_reinterpret_cast (void*, this); + else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow)) + retv = ACE_reinterpret_cast (void *, + ACE_static_cast (CORBA::Object_ptr, this)); + + if (retv) + this->_add_ref (); + return retv; +} + +const char* PortableServer::ServantManager::_interface_repository_id (void) const +{ + return "IDL:PortableServer/ServantManager:1.0"; +} + + +// default constructor +PortableServer::ServantActivator::ServantActivator (void) +{} + +// destructor +PortableServer::ServantActivator::~ServantActivator (void) +{} + +PortableServer::ServantActivator_ptr PortableServer::ServantActivator::_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV + ) +{ + return ServantActivator::_unchecked_narrow (obj, ACE_TRY_ENV); +} + +PortableServer::ServantActivator_ptr PortableServer::ServantActivator::_unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment & + ) +{ + if (CORBA::is_nil (obj)) + return ServantActivator::_nil (); + return + ACE_reinterpret_cast + ( + ServantActivator_ptr, + obj->_tao_QueryInterface + ( + ACE_reinterpret_cast + ( + ptr_arith_t, + &ServantActivator::_narrow + ) + ) + ); +} + +PortableServer::ServantActivator_ptr +PortableServer::ServantActivator::_duplicate (ServantActivator_ptr obj) +{ + if (!CORBA::is_nil (obj)) + obj->_add_ref (); + return obj; +} + +void *PortableServer::ServantActivator::_tao_QueryInterface (ptr_arith_t type) +{ + void *retv = 0; + if (type == ACE_reinterpret_cast + (ptr_arith_t, + &ACE_NESTED_CLASS (::PortableServer, ServantActivator)::_narrow)) + retv = ACE_reinterpret_cast (void*, this); + else if (type == ACE_reinterpret_cast + (ptr_arith_t, + &ACE_NESTED_CLASS (::PortableServer, ServantManager)::_narrow)) + retv = ACE_reinterpret_cast + ( + void *, + ACE_static_cast + ( + PortableServer::ServantManager_ptr, + this + ) + ); + else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow)) + retv = ACE_reinterpret_cast (void *, + ACE_static_cast (CORBA::Object_ptr, this)); + + if (retv) + this->_add_ref (); + return retv; +} + +const char* PortableServer::ServantActivator::_interface_repository_id (void) const +{ + return "IDL:PortableServer/ServantActivator:1.0"; +} + + +// default constructor +PortableServer::ServantLocator::ServantLocator (void) +{} + +// destructor +PortableServer::ServantLocator::~ServantLocator (void) +{} + +PortableServer::ServantLocator_ptr PortableServer::ServantLocator::_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV + ) +{ + return ServantLocator::_unchecked_narrow (obj, ACE_TRY_ENV); +} + +PortableServer::ServantLocator_ptr PortableServer::ServantLocator::_unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment & + ) +{ + if (CORBA::is_nil (obj)) + return ServantLocator::_nil (); + return + ACE_reinterpret_cast + ( + ServantLocator_ptr, + obj->_tao_QueryInterface + ( + ACE_reinterpret_cast + ( + ptr_arith_t, + &ServantLocator::_narrow + ) + ) + ); +} + +PortableServer::ServantLocator_ptr +PortableServer::ServantLocator::_duplicate (ServantLocator_ptr obj) +{ + if (!CORBA::is_nil (obj)) + obj->_add_ref (); + return obj; +} + +void *PortableServer::ServantLocator::_tao_QueryInterface (ptr_arith_t type) +{ + void *retv = 0; + if (type == ACE_reinterpret_cast + (ptr_arith_t, + &ACE_NESTED_CLASS (::PortableServer, ServantLocator)::_narrow)) + retv = ACE_reinterpret_cast (void*, this); + else if (type == ACE_reinterpret_cast + (ptr_arith_t, + &ACE_NESTED_CLASS (::PortableServer, ServantManager)::_narrow)) + retv = ACE_reinterpret_cast + ( + void *, + ACE_static_cast + ( + PortableServer::ServantManager_ptr, + this + ) + ); + else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow)) + retv = ACE_reinterpret_cast (void *, + ACE_static_cast (CORBA::Object_ptr, this)); + + if (retv) + this->_add_ref (); + return retv; +} + +const char* PortableServer::ServantLocator::_interface_repository_id (void) const +{ + return "IDL:PortableServer/ServantLocator:1.0"; +} + +#endif /* TAO_HAS_MINIMUM_POA == 0 */ + +// default constructor +PortableServer::POA::POA (void) +{} + +// destructor +PortableServer::POA::~POA (void) +{} + +PortableServer::POA_ptr PortableServer::POA::_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV + ) +{ + return POA::_unchecked_narrow (obj, ACE_TRY_ENV); +} + +PortableServer::POA_ptr PortableServer::POA::_unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment & + ) +{ + if (CORBA::is_nil (obj)) + return POA::_nil (); + return + ACE_reinterpret_cast + ( + POA_ptr, + obj->_tao_QueryInterface + ( + ACE_reinterpret_cast + ( + ptr_arith_t, + &POA::_narrow + ) + ) + ); +} + +PortableServer::POA_ptr +PortableServer::POA::_duplicate (POA_ptr obj) +{ + if (!CORBA::is_nil (obj)) + obj->_add_ref (); + return obj; +} + +// default constructor +PortableServer::POA::AdapterAlreadyExists::AdapterAlreadyExists (void) +{ +} + +// destructor - all members are of self managing types +PortableServer::POA::AdapterAlreadyExists::~AdapterAlreadyExists (void) +{ +} + +// copy constructor +PortableServer::POA::AdapterAlreadyExists::AdapterAlreadyExists (const ::PortableServer::POA::AdapterAlreadyExists &_tao_excp) + : CORBA_UserException (_tao_excp._id ()) +{ +} + +// assignment operator +PortableServer::POA::AdapterAlreadyExists& +PortableServer::POA::AdapterAlreadyExists::operator= (const ::PortableServer::POA::AdapterAlreadyExists &_tao_excp) +{ + + this->CORBA_UserException::operator= (_tao_excp); + return *this; +} + +// narrow +PortableServer::POA::AdapterAlreadyExists * +PortableServer::POA::AdapterAlreadyExists::_downcast (CORBA::Exception *exc) +{ + if (!ACE_OS::strcmp ("IDL:PortableServer/POA/AdapterAlreadyExists:1.0", exc->_id ())) // same type + return ACE_dynamic_cast (AdapterAlreadyExists *, exc); + else + return 0; +} + + +void PortableServer::POA::AdapterAlreadyExists::_raise () +{ + TAO_RAISE(*this); +} + + +void PortableServer::POA::AdapterAlreadyExists::_tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &ACE_TRY_ENV) const +{ + ACE_THROW (CORBA::MARSHAL ()); +} + + +void PortableServer::POA::AdapterAlreadyExists::_tao_decode ( + TAO_InputCDR &, + CORBA::Environment &ACE_TRY_ENV) +{ + ACE_THROW (CORBA::MARSHAL ()); +} + +// TAO extension - the _alloc method +CORBA::Exception *PortableServer::POA::AdapterAlreadyExists::_alloc (void) +{ + CORBA::Exception *retval = 0; + ACE_NEW_RETURN (retval, ::PortableServer::POA::AdapterAlreadyExists, 0); + return retval; +} + +// default constructor +PortableServer::POA::AdapterNonExistent::AdapterNonExistent (void) +{ +} + +// destructor - all members are of self managing types +PortableServer::POA::AdapterNonExistent::~AdapterNonExistent (void) +{ +} + +// copy constructor +PortableServer::POA::AdapterNonExistent::AdapterNonExistent (const ::PortableServer::POA::AdapterNonExistent &_tao_excp) + : CORBA_UserException (_tao_excp._id ()) +{ +} + +// assignment operator +PortableServer::POA::AdapterNonExistent& +PortableServer::POA::AdapterNonExistent::operator= (const ::PortableServer::POA::AdapterNonExistent &_tao_excp) +{ + + this->CORBA_UserException::operator= (_tao_excp); + return *this; +} + +// narrow +PortableServer::POA::AdapterNonExistent * +PortableServer::POA::AdapterNonExistent::_downcast (CORBA::Exception *exc) +{ + if (!ACE_OS::strcmp ("IDL:PortableServer/POA/AdapterNonExistent:1.0", exc->_id ())) // same type + return ACE_dynamic_cast (AdapterNonExistent *, exc); + else + return 0; +} + + +void PortableServer::POA::AdapterNonExistent::_raise () +{ + TAO_RAISE(*this); +} + + +void PortableServer::POA::AdapterNonExistent::_tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &ACE_TRY_ENV) const +{ + ACE_THROW (CORBA::MARSHAL ()); +} + + +void PortableServer::POA::AdapterNonExistent::_tao_decode ( + TAO_InputCDR &, + CORBA::Environment &ACE_TRY_ENV) +{ + ACE_THROW (CORBA::MARSHAL ()); +} + +// TAO extension - the _alloc method +CORBA::Exception *PortableServer::POA::AdapterNonExistent::_alloc (void) +{ + CORBA::Exception *retval = 0; + ACE_NEW_RETURN (retval, ::PortableServer::POA::AdapterNonExistent, 0); + return retval; +} + +// default constructor +PortableServer::POA::InvalidPolicy::InvalidPolicy (void) +{ +} + +// destructor - all members are of self managing types +PortableServer::POA::InvalidPolicy::~InvalidPolicy (void) +{ +} + +// copy constructor +PortableServer::POA::InvalidPolicy::InvalidPolicy (const ::PortableServer::POA::InvalidPolicy &_tao_excp) + : CORBA_UserException (_tao_excp._id ()) +{ + this->index = _tao_excp.index; +} + +// assignment operator +PortableServer::POA::InvalidPolicy& +PortableServer::POA::InvalidPolicy::operator= (const ::PortableServer::POA::InvalidPolicy &_tao_excp) +{ + + this->CORBA_UserException::operator= (_tao_excp); + this->index = _tao_excp.index; + return *this; +} + +// narrow +PortableServer::POA::InvalidPolicy * +PortableServer::POA::InvalidPolicy::_downcast (CORBA::Exception *exc) +{ + if (!ACE_OS::strcmp ("IDL:PortableServer/POA/InvalidPolicy:1.0", exc->_id ())) // same type + return ACE_dynamic_cast (InvalidPolicy *, exc); + else + return 0; +} + + +void PortableServer::POA::InvalidPolicy::_raise () +{ + TAO_RAISE(*this); +} + + +void PortableServer::POA::InvalidPolicy::_tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &ACE_TRY_ENV) const +{ + ACE_THROW (CORBA::MARSHAL ()); +} + + +void PortableServer::POA::InvalidPolicy::_tao_decode ( + TAO_InputCDR &, + CORBA::Environment &ACE_TRY_ENV) +{ + ACE_THROW (CORBA::MARSHAL ()); +} + +// TAO extension - the _alloc method +CORBA::Exception *PortableServer::POA::InvalidPolicy::_alloc (void) +{ + CORBA::Exception *retval = 0; + ACE_NEW_RETURN (retval, ::PortableServer::POA::InvalidPolicy, 0); + return retval; +} + +PortableServer::POA::InvalidPolicy::InvalidPolicy ( + CORBA::UShort _tao_index +) +{ + this->index = _tao_index; +} + +#if (TAO_HAS_MINIMUM_POA == 0) + +// default constructor +PortableServer::POA::NoServant::NoServant (void) +{ +} + +// destructor - all members are of self managing types +PortableServer::POA::NoServant::~NoServant (void) +{ +} + +// copy constructor +PortableServer::POA::NoServant::NoServant (const ::PortableServer::POA::NoServant &_tao_excp) + : CORBA_UserException (_tao_excp._id ()) +{ +} + +// assignment operator +PortableServer::POA::NoServant& +PortableServer::POA::NoServant::operator= (const ::PortableServer::POA::NoServant &_tao_excp) +{ + + this->CORBA_UserException::operator= (_tao_excp); + return *this; +} + +// narrow +PortableServer::POA::NoServant * +PortableServer::POA::NoServant::_downcast (CORBA::Exception *exc) +{ + if (!ACE_OS::strcmp ("IDL:PortableServer/POA/NoServant:1.0", exc->_id ())) // same type + return ACE_dynamic_cast (NoServant *, exc); + else + return 0; +} + + +void PortableServer::POA::NoServant::_raise () +{ + TAO_RAISE(*this); +} + + +void PortableServer::POA::NoServant::_tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &ACE_TRY_ENV) const +{ + ACE_THROW (CORBA::MARSHAL ()); +} + + +void PortableServer::POA::NoServant::_tao_decode ( + TAO_InputCDR &, + CORBA::Environment &ACE_TRY_ENV) +{ + ACE_THROW (CORBA::MARSHAL ()); +} + +// TAO extension - the _alloc method +CORBA::Exception *PortableServer::POA::NoServant::_alloc (void) +{ + CORBA::Exception *retval = 0; + ACE_NEW_RETURN (retval, ::PortableServer::POA::NoServant, 0); + return retval; +} + +#endif /* TAO_HAS_MINIMUM_POA == 0 */ + +// default constructor +PortableServer::POA::ObjectAlreadyActive::ObjectAlreadyActive (void) +{ +} + +// destructor - all members are of self managing types +PortableServer::POA::ObjectAlreadyActive::~ObjectAlreadyActive (void) +{ +} + +// copy constructor +PortableServer::POA::ObjectAlreadyActive::ObjectAlreadyActive (const ::PortableServer::POA::ObjectAlreadyActive &_tao_excp) + : CORBA_UserException (_tao_excp._id ()) +{ +} + +// assignment operator +PortableServer::POA::ObjectAlreadyActive& +PortableServer::POA::ObjectAlreadyActive::operator= (const ::PortableServer::POA::ObjectAlreadyActive &_tao_excp) +{ + + this->CORBA_UserException::operator= (_tao_excp); + return *this; +} + +// narrow +PortableServer::POA::ObjectAlreadyActive * +PortableServer::POA::ObjectAlreadyActive::_downcast (CORBA::Exception *exc) +{ + if (!ACE_OS::strcmp ("IDL:PortableServer/POA/ObjectAlreadyActive:1.0", exc->_id ())) // same type + return ACE_dynamic_cast (ObjectAlreadyActive *, exc); + else + return 0; +} + + +void PortableServer::POA::ObjectAlreadyActive::_raise () +{ + TAO_RAISE(*this); +} + + +void PortableServer::POA::ObjectAlreadyActive::_tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &ACE_TRY_ENV) const +{ + ACE_THROW (CORBA::MARSHAL ()); +} + + +void PortableServer::POA::ObjectAlreadyActive::_tao_decode ( + TAO_InputCDR &, + CORBA::Environment &ACE_TRY_ENV) +{ + ACE_THROW (CORBA::MARSHAL ()); +} + +// TAO extension - the _alloc method +CORBA::Exception *PortableServer::POA::ObjectAlreadyActive::_alloc (void) +{ + CORBA::Exception *retval = 0; + ACE_NEW_RETURN (retval, ::PortableServer::POA::ObjectAlreadyActive, 0); + return retval; +} + +// default constructor +PortableServer::POA::ObjectNotActive::ObjectNotActive (void) +{ +} + +// destructor - all members are of self managing types +PortableServer::POA::ObjectNotActive::~ObjectNotActive (void) +{ +} + +// copy constructor +PortableServer::POA::ObjectNotActive::ObjectNotActive (const ::PortableServer::POA::ObjectNotActive &_tao_excp) + : CORBA_UserException (_tao_excp._id ()) +{ +} + +// assignment operator +PortableServer::POA::ObjectNotActive& +PortableServer::POA::ObjectNotActive::operator= (const ::PortableServer::POA::ObjectNotActive &_tao_excp) +{ + + this->CORBA_UserException::operator= (_tao_excp); + return *this; +} + +// narrow +PortableServer::POA::ObjectNotActive * +PortableServer::POA::ObjectNotActive::_downcast (CORBA::Exception *exc) +{ + if (!ACE_OS::strcmp ("IDL:PortableServer/POA/ObjectNotActive:1.0", exc->_id ())) // same type + return ACE_dynamic_cast (ObjectNotActive *, exc); + else + return 0; +} + + +void PortableServer::POA::ObjectNotActive::_raise () +{ + TAO_RAISE(*this); +} + + +void PortableServer::POA::ObjectNotActive::_tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &ACE_TRY_ENV) const +{ + ACE_THROW (CORBA::MARSHAL ()); +} + + +void PortableServer::POA::ObjectNotActive::_tao_decode ( + TAO_InputCDR &, + CORBA::Environment &ACE_TRY_ENV) +{ + ACE_THROW (CORBA::MARSHAL ()); +} + +// TAO extension - the _alloc method +CORBA::Exception *PortableServer::POA::ObjectNotActive::_alloc (void) +{ + CORBA::Exception *retval = 0; + ACE_NEW_RETURN (retval, ::PortableServer::POA::ObjectNotActive, 0); + return retval; +} + +// default constructor +PortableServer::POA::ServantAlreadyActive::ServantAlreadyActive (void) +{ +} + +// destructor - all members are of self managing types +PortableServer::POA::ServantAlreadyActive::~ServantAlreadyActive (void) +{ +} + +// copy constructor +PortableServer::POA::ServantAlreadyActive::ServantAlreadyActive (const ::PortableServer::POA::ServantAlreadyActive &_tao_excp) + : CORBA_UserException (_tao_excp._id ()) +{ +} + +// assignment operator +PortableServer::POA::ServantAlreadyActive& +PortableServer::POA::ServantAlreadyActive::operator= (const ::PortableServer::POA::ServantAlreadyActive &_tao_excp) +{ + + this->CORBA_UserException::operator= (_tao_excp); + return *this; +} + +// narrow +PortableServer::POA::ServantAlreadyActive * +PortableServer::POA::ServantAlreadyActive::_downcast (CORBA::Exception *exc) +{ + if (!ACE_OS::strcmp ("IDL:PortableServer/POA/ServantAlreadyActive:1.0", exc->_id ())) // same type + return ACE_dynamic_cast (ServantAlreadyActive *, exc); + else + return 0; +} + + +void PortableServer::POA::ServantAlreadyActive::_raise () +{ + TAO_RAISE(*this); +} + + +void PortableServer::POA::ServantAlreadyActive::_tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &ACE_TRY_ENV) const +{ + ACE_THROW (CORBA::MARSHAL ()); +} + + +void PortableServer::POA::ServantAlreadyActive::_tao_decode ( + TAO_InputCDR &, + CORBA::Environment &ACE_TRY_ENV) +{ + ACE_THROW (CORBA::MARSHAL ()); +} + +// TAO extension - the _alloc method +CORBA::Exception *PortableServer::POA::ServantAlreadyActive::_alloc (void) +{ + CORBA::Exception *retval = 0; + ACE_NEW_RETURN (retval, ::PortableServer::POA::ServantAlreadyActive, 0); + return retval; +} + +// default constructor +PortableServer::POA::ServantNotActive::ServantNotActive (void) +{ +} + +// destructor - all members are of self managing types +PortableServer::POA::ServantNotActive::~ServantNotActive (void) +{ +} + +// copy constructor +PortableServer::POA::ServantNotActive::ServantNotActive (const ::PortableServer::POA::ServantNotActive &_tao_excp) + : CORBA_UserException (_tao_excp._id ()) +{ +} + +// assignment operator +PortableServer::POA::ServantNotActive& +PortableServer::POA::ServantNotActive::operator= (const ::PortableServer::POA::ServantNotActive &_tao_excp) +{ + + this->CORBA_UserException::operator= (_tao_excp); + return *this; +} + +// narrow +PortableServer::POA::ServantNotActive * +PortableServer::POA::ServantNotActive::_downcast (CORBA::Exception *exc) +{ + if (!ACE_OS::strcmp ("IDL:PortableServer/POA/ServantNotActive:1.0", exc->_id ())) // same type + return ACE_dynamic_cast (ServantNotActive *, exc); + else + return 0; +} + + +void PortableServer::POA::ServantNotActive::_raise () +{ + TAO_RAISE(*this); +} + + +void PortableServer::POA::ServantNotActive::_tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &ACE_TRY_ENV) const +{ + ACE_THROW (CORBA::MARSHAL ()); +} + + +void PortableServer::POA::ServantNotActive::_tao_decode ( + TAO_InputCDR &, + CORBA::Environment &ACE_TRY_ENV) +{ + ACE_THROW (CORBA::MARSHAL ()); +} + +// TAO extension - the _alloc method +CORBA::Exception *PortableServer::POA::ServantNotActive::_alloc (void) +{ + CORBA::Exception *retval = 0; + ACE_NEW_RETURN (retval, ::PortableServer::POA::ServantNotActive, 0); + return retval; +} + +// default constructor +PortableServer::POA::WrongAdapter::WrongAdapter (void) +{ +} + +// destructor - all members are of self managing types +PortableServer::POA::WrongAdapter::~WrongAdapter (void) +{ +} + +// copy constructor +PortableServer::POA::WrongAdapter::WrongAdapter (const ::PortableServer::POA::WrongAdapter &_tao_excp) + : CORBA_UserException (_tao_excp._id ()) +{ +} + +// assignment operator +PortableServer::POA::WrongAdapter& +PortableServer::POA::WrongAdapter::operator= (const ::PortableServer::POA::WrongAdapter &_tao_excp) +{ + + this->CORBA_UserException::operator= (_tao_excp); + return *this; +} + +// narrow +PortableServer::POA::WrongAdapter * +PortableServer::POA::WrongAdapter::_downcast (CORBA::Exception *exc) +{ + if (!ACE_OS::strcmp ("IDL:PortableServer/POA/WrongAdapter:1.0", exc->_id ())) // same type + return ACE_dynamic_cast (WrongAdapter *, exc); + else + return 0; +} + + +void PortableServer::POA::WrongAdapter::_raise () +{ + TAO_RAISE(*this); +} + + +void PortableServer::POA::WrongAdapter::_tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &ACE_TRY_ENV) const +{ + ACE_THROW (CORBA::MARSHAL ()); +} + + +void PortableServer::POA::WrongAdapter::_tao_decode ( + TAO_InputCDR &, + CORBA::Environment &ACE_TRY_ENV) +{ + ACE_THROW (CORBA::MARSHAL ()); +} + +// TAO extension - the _alloc method +CORBA::Exception *PortableServer::POA::WrongAdapter::_alloc (void) +{ + CORBA::Exception *retval = 0; + ACE_NEW_RETURN (retval, ::PortableServer::POA::WrongAdapter, 0); + return retval; +} + +// default constructor +PortableServer::POA::WrongPolicy::WrongPolicy (void) +{ +} + +// destructor - all members are of self managing types +PortableServer::POA::WrongPolicy::~WrongPolicy (void) +{ +} + +// copy constructor +PortableServer::POA::WrongPolicy::WrongPolicy (const ::PortableServer::POA::WrongPolicy &_tao_excp) + : CORBA_UserException (_tao_excp._id ()) +{ +} + +// assignment operator +PortableServer::POA::WrongPolicy& +PortableServer::POA::WrongPolicy::operator= (const ::PortableServer::POA::WrongPolicy &_tao_excp) +{ + + this->CORBA_UserException::operator= (_tao_excp); + return *this; +} + +// narrow +PortableServer::POA::WrongPolicy * +PortableServer::POA::WrongPolicy::_downcast (CORBA::Exception *exc) +{ + if (!ACE_OS::strcmp ("IDL:PortableServer/POA/WrongPolicy:1.0", exc->_id ())) // same type + return ACE_dynamic_cast (WrongPolicy *, exc); + else + return 0; +} + + +void PortableServer::POA::WrongPolicy::_raise () +{ + TAO_RAISE(*this); +} + + +void PortableServer::POA::WrongPolicy::_tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &ACE_TRY_ENV) const +{ + ACE_THROW (CORBA::MARSHAL ()); +} + + +void PortableServer::POA::WrongPolicy::_tao_decode ( + TAO_InputCDR &, + CORBA::Environment &ACE_TRY_ENV) +{ + ACE_THROW (CORBA::MARSHAL ()); +} + +// TAO extension - the _alloc method +CORBA::Exception *PortableServer::POA::WrongPolicy::_alloc (void) +{ + CORBA::Exception *retval = 0; + ACE_NEW_RETURN (retval, ::PortableServer::POA::WrongPolicy, 0); + return retval; +} + +void *PortableServer::POA::_tao_QueryInterface (ptr_arith_t type) +{ + void *retv = 0; + if (type == ACE_reinterpret_cast + (ptr_arith_t, + &ACE_NESTED_CLASS (::PortableServer, POA)::_narrow)) + retv = ACE_reinterpret_cast (void*, this); + else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow)) + retv = ACE_reinterpret_cast (void *, + ACE_static_cast (CORBA::Object_ptr, this)); + + if (retv) + this->_add_ref (); + return retv; +} + +const char* PortableServer::POA::_interface_repository_id (void) const +{ + return "IDL:PortableServer/POA:1.0"; +} + + +// default constructor +PortableServer::Current::Current (void) +{} + +// destructor +PortableServer::Current::~Current (void) +{} + +PortableServer::Current_ptr PortableServer::Current::_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV + ) +{ + return Current::_unchecked_narrow (obj, ACE_TRY_ENV); +} + +PortableServer::Current_ptr PortableServer::Current::_unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment & + ) +{ + if (CORBA::is_nil (obj)) + return Current::_nil (); + return + ACE_reinterpret_cast + ( + Current_ptr, + obj->_tao_QueryInterface + ( + ACE_reinterpret_cast + ( + ptr_arith_t, + &Current::_narrow + ) + ) + ); +} + +PortableServer::Current_ptr +PortableServer::Current::_duplicate (Current_ptr obj) +{ + if (!CORBA::is_nil (obj)) + obj->_add_ref (); + return obj; +} + +// default constructor +PortableServer::Current::NoContext::NoContext (void) +{ +} + +// destructor - all members are of self managing types +PortableServer::Current::NoContext::~NoContext (void) +{ +} + +// copy constructor +PortableServer::Current::NoContext::NoContext (const ::PortableServer::Current::NoContext &_tao_excp) + : CORBA_UserException (_tao_excp._id ()) +{ +} + +// assignment operator +PortableServer::Current::NoContext& +PortableServer::Current::NoContext::operator= (const ::PortableServer::Current::NoContext &_tao_excp) +{ + + this->CORBA_UserException::operator= (_tao_excp); + return *this; +} + +// narrow +PortableServer::Current::NoContext * +PortableServer::Current::NoContext::_downcast (CORBA::Exception *exc) +{ + if (!ACE_OS::strcmp ("IDL:PortableServer/Current/NoContext:1.0", exc->_id ())) // same type + return ACE_dynamic_cast (NoContext *, exc); + else + return 0; +} + + +void PortableServer::Current::NoContext::_raise () +{ + TAO_RAISE(*this); +} + + +void PortableServer::Current::NoContext::_tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &ACE_TRY_ENV) const +{ + ACE_THROW (CORBA::MARSHAL ()); +} + + +void PortableServer::Current::NoContext::_tao_decode ( + TAO_InputCDR &, + CORBA::Environment &ACE_TRY_ENV) +{ + ACE_THROW (CORBA::MARSHAL ()); +} + +// TAO extension - the _alloc method +CORBA::Exception *PortableServer::Current::NoContext::_alloc (void) +{ + CORBA::Exception *retval = 0; + ACE_NEW_RETURN (retval, ::PortableServer::Current::NoContext, 0); + return retval; +} + +void *PortableServer::Current::_tao_QueryInterface (ptr_arith_t type) +{ + void *retv = 0; + if (type == ACE_reinterpret_cast + (ptr_arith_t, + &ACE_NESTED_CLASS (::PortableServer, Current)::_narrow)) + retv = ACE_reinterpret_cast (void*, this); + else if (type == ACE_reinterpret_cast + (ptr_arith_t, + &::CORBA::Current::_narrow)) + retv = ACE_reinterpret_cast + ( + void *, + ACE_static_cast + ( + CORBA::Current_ptr, + this + ) + ); + else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow)) + retv = ACE_reinterpret_cast (void *, + ACE_static_cast (CORBA::Object_ptr, this)); + + if (retv) + this->_add_ref (); + return retv; +} + +const char* PortableServer::Current::_interface_repository_id (void) const +{ + return "IDL:PortableServer/Current:1.0"; +} + +char * +PortableServer::ObjectId_to_string (const PortableServer::ObjectId &id) +{ + return TAO_POA::ObjectId_to_string (id); +} + +CORBA::WChar * +PortableServer::ObjectId_to_wstring (const PortableServer::ObjectId &id) +{ + return TAO_POA::ObjectId_to_wstring (id); +} + +PortableServer::ObjectId * +PortableServer::string_to_ObjectId (const char *id) +{ + return TAO_POA::string_to_ObjectId (id); +} + +PortableServer::ObjectId * +PortableServer::wstring_to_ObjectId (const CORBA::WChar *id) +{ + return TAO_POA::wstring_to_ObjectId (id); +} + +void operator<<= ( + CORBA::Any &_tao_any, + const PortableServer::ObjectId &_tao_elem + ) // copying +{ + TAO_OutputCDR stream; + if (stream << _tao_elem) + { + _tao_any._tao_replace ( + PortableServer::_tc_ObjectId, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); + } +} + +void operator<<= (CORBA::Any &_tao_any, PortableServer::ObjectId *_tao_elem) // non copying +{ + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + PortableServer::_tc_ObjectId, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + PortableServer::ObjectId::_tao_any_destructor + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ObjectId *&_tao_elem) +{ + return _tao_any >>= ACE_const_cast( + const PortableServer::ObjectId*&, + _tao_elem + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::ObjectId *&_tao_elem) +{ + _tao_elem = 0; + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (PortableServer::_tc_ObjectId, ACE_TRY_ENV)) // not equal + { + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = ACE_static_cast( + const PortableServer::ObjectId*, + _tao_any.value () + ); + return 1; + } + else + { + PortableServer::ObjectId *tmp; + ACE_NEW_RETURN (tmp, PortableServer::ObjectId, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *tmp) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + PortableServer::_tc_ObjectId, + 1, + ACE_static_cast (void *, tmp), + PortableServer::ObjectId::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; + } + else + { + delete tmp; + } + } + } + ACE_CATCHANY + { + } + ACE_ENDTRY; + return 0; +} + +#if (TAO_HAS_MINIMUM_CORBA == 0) + +void operator<<= (CORBA::Any &_tao_any, const PortableServer::ForwardRequest &_tao_elem) // copying +{ + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + PortableServer::_tc_ForwardRequest, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); +} + +void operator<<= (CORBA::Any &_tao_any, PortableServer::ForwardRequest *_tao_elem) // non copying +{ + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + PortableServer::_tc_ForwardRequest, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + PortableServer::ForwardRequest::_tao_any_destructor + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ForwardRequest *&_tao_elem) +{ + return _tao_any >>= ACE_const_cast( + const PortableServer::ForwardRequest*&, + _tao_elem + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::ForwardRequest *&_tao_elem) +{ + _tao_elem = 0; + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (PortableServer::_tc_ForwardRequest, ACE_TRY_ENV)) // not equal + { + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (PortableServer::ForwardRequest *)_tao_any.value (); + return 1; + } + else + { + PortableServer::ForwardRequest *tmp; + ACE_NEW_RETURN (tmp, PortableServer::ForwardRequest, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + CORBA::String_var interface_repository_id; + if (!(stream >> interface_repository_id.out ())) + return 0; + if (ACE_OS::strcmp ( + interface_repository_id.in (), + "IDL:PortableServer/ForwardRequest:1.0")) + return 0; + if (stream >> *tmp) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + PortableServer::_tc_ForwardRequest, + 1, + tmp, + PortableServer::ForwardRequest::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; + } + else + { + delete tmp; + } + } + } + ACE_CATCHANY + { + } + ACE_ENDTRY; + return 0; +} + +#endif /* TAO_HAS_MINIMUM_CORBA == 0 */ + +#if (TAO_HAS_MINIMUM_POA == 0) + +void operator<<= (CORBA::Any &_tao_any, PortableServer::ThreadPolicyValue _tao_elem) +{ + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + PortableServer::_tc_ThreadPolicyValue, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ThreadPolicyValue &_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (PortableServer::_tc_ThreadPolicyValue, ACE_TRY_ENV)) // not equal + { + return 0; + } + ACE_TRY_CHECK; + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> _tao_elem) + { + return 1; + } + } + ACE_CATCHANY + { + return 0; + } + ACE_ENDTRY; + return 0; +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Manager<PortableServer::ThreadPolicy,PortableServer::ThreadPolicy_var>; + #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + # pragma instantiate TAO_Object_Manager<PortableServer::ThreadPolicy,PortableServer::ThreadPolicy_var> +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +#endif /* TAO_HAS_MINIMUM_POA == 0 */ + +void operator<<= (CORBA::Any &_tao_any, PortableServer::LifespanPolicyValue _tao_elem) +{ + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + PortableServer::_tc_LifespanPolicyValue, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::LifespanPolicyValue &_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (PortableServer::_tc_LifespanPolicyValue, ACE_TRY_ENV)) // not equal + { + return 0; + } + ACE_TRY_CHECK; + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> _tao_elem) + { + return 1; + } + } + ACE_CATCHANY + { + return 0; + } + ACE_ENDTRY; + return 0; +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Manager<PortableServer::LifespanPolicy,PortableServer::LifespanPolicy_var>; + #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + # pragma instantiate TAO_Object_Manager<PortableServer::LifespanPolicy,PortableServer::LifespanPolicy_var> +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +void operator<<= (CORBA::Any &_tao_any, PortableServer::IdUniquenessPolicyValue _tao_elem) +{ + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + PortableServer::_tc_IdUniquenessPolicyValue, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::IdUniquenessPolicyValue &_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (PortableServer::_tc_IdUniquenessPolicyValue, ACE_TRY_ENV)) // not equal + { + return 0; + } + ACE_TRY_CHECK; + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> _tao_elem) + { + return 1; + } + } + ACE_CATCHANY + { + return 0; + } + ACE_ENDTRY; + return 0; +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Manager<PortableServer::IdUniquenessPolicy,PortableServer::IdUniquenessPolicy_var>; + #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + # pragma instantiate TAO_Object_Manager<PortableServer::IdUniquenessPolicy,PortableServer::IdUniquenessPolicy_var> +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +void operator<<= (CORBA::Any &_tao_any, PortableServer::IdAssignmentPolicyValue _tao_elem) +{ + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + PortableServer::_tc_IdAssignmentPolicyValue, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::IdAssignmentPolicyValue &_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (PortableServer::_tc_IdAssignmentPolicyValue, ACE_TRY_ENV)) // not equal + { + return 0; + } + ACE_TRY_CHECK; + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> _tao_elem) + { + return 1; + } + } + ACE_CATCHANY + { + return 0; + } + ACE_ENDTRY; + return 0; +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Manager<PortableServer::IdAssignmentPolicy,PortableServer::IdAssignmentPolicy_var>; + #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + # pragma instantiate TAO_Object_Manager<PortableServer::IdAssignmentPolicy,PortableServer::IdAssignmentPolicy_var> +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +#if (TAO_HAS_MINIMUM_POA == 0) + +void operator<<= (CORBA::Any &_tao_any, PortableServer::ImplicitActivationPolicyValue _tao_elem) +{ + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + PortableServer::_tc_ImplicitActivationPolicyValue, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ImplicitActivationPolicyValue &_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (PortableServer::_tc_ImplicitActivationPolicyValue, ACE_TRY_ENV)) // not equal + { + return 0; + } + ACE_TRY_CHECK; + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> _tao_elem) + { + return 1; + } + } + ACE_CATCHANY + { + return 0; + } + ACE_ENDTRY; + return 0; +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Manager<PortableServer::ImplicitActivationPolicy,PortableServer::ImplicitActivationPolicy_var>; + #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + # pragma instantiate TAO_Object_Manager<PortableServer::ImplicitActivationPolicy,PortableServer::ImplicitActivationPolicy_var> +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +void operator<<= (CORBA::Any &_tao_any, PortableServer::ServantRetentionPolicyValue _tao_elem) +{ + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + PortableServer::_tc_ServantRetentionPolicyValue, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ServantRetentionPolicyValue &_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (PortableServer::_tc_ServantRetentionPolicyValue, ACE_TRY_ENV)) // not equal + { + return 0; + } + ACE_TRY_CHECK; + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> _tao_elem) + { + return 1; + } + } + ACE_CATCHANY + { + return 0; + } + ACE_ENDTRY; + return 0; +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Manager<PortableServer::ServantRetentionPolicy,PortableServer::ServantRetentionPolicy_var>; + #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + # pragma instantiate TAO_Object_Manager<PortableServer::ServantRetentionPolicy,PortableServer::ServantRetentionPolicy_var> +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +void operator<<= (CORBA::Any &_tao_any, PortableServer::RequestProcessingPolicyValue _tao_elem) +{ + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + PortableServer::_tc_RequestProcessingPolicyValue, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::RequestProcessingPolicyValue &_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (PortableServer::_tc_RequestProcessingPolicyValue, ACE_TRY_ENV)) // not equal + { + return 0; + } + ACE_TRY_CHECK; + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> _tao_elem) + { + return 1; + } + } + ACE_CATCHANY + { + return 0; + } + ACE_ENDTRY; + return 0; +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Manager<PortableServer::RequestProcessingPolicy,PortableServer::RequestProcessingPolicy_var>; + #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + # pragma instantiate TAO_Object_Manager<PortableServer::RequestProcessingPolicy,PortableServer::RequestProcessingPolicy_var> +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +#endif /* TAO_HAS_MINIMUM_POA == 0 */ + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Manager<PortableServer::POAManager,PortableServer::POAManager_var>; + #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + # pragma instantiate TAO_Object_Manager<PortableServer::POAManager,PortableServer::POAManager_var> +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +#if (TAO_HAS_MINIMUM_POA == 0) + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Manager<PortableServer::AdapterActivator,PortableServer::AdapterActivator_var>; + #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + # pragma instantiate TAO_Object_Manager<PortableServer::AdapterActivator,PortableServer::AdapterActivator_var> +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Manager<PortableServer::ServantManager,PortableServer::ServantManager_var>; + #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + # pragma instantiate TAO_Object_Manager<PortableServer::ServantManager,PortableServer::ServantManager_var> +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Manager<PortableServer::ServantActivator,PortableServer::ServantActivator_var>; + #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + # pragma instantiate TAO_Object_Manager<PortableServer::ServantActivator,PortableServer::ServantActivator_var> +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Manager<PortableServer::ServantLocator,PortableServer::ServantLocator_var>; + #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + # pragma instantiate TAO_Object_Manager<PortableServer::ServantLocator,PortableServer::ServantLocator_var> +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +#endif /* TAO_HAS_MINIMUM_POA == 0 */ + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Manager<PortableServer::POA,PortableServer::POA_var>; + #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + # pragma instantiate TAO_Object_Manager<PortableServer::POA,PortableServer::POA_var> +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Manager<PortableServer::Current,PortableServer::Current_var>; + #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + # pragma instantiate TAO_Object_Manager<PortableServer::Current,PortableServer::Current_var> +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +CORBA::Boolean operator<< ( + TAO_OutputCDR &strm, + const PortableServer::ObjectId &_tao_sequence + ) +{ + if (strm << _tao_sequence.length ()) + { + // encode all elements + +#if (TAO_NO_COPY_OCTET_SEQUENCES == 1) + { + TAO_Unbounded_Sequence<CORBA::Octet> *oseq = + ACE_static_cast (TAO_Unbounded_Sequence<CORBA::Octet>*, (PortableServer::ObjectId *)&_tao_sequence); + if (oseq->mb ()) + return strm.write_octet_array_mb (oseq->mb ()); + else + return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ()); + } + +#else /* TAO_NO_COPY_OCTET_SEQUENCES == 0 */ + return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ()); + +#endif /* TAO_NO_COPY_OCTET_SEQUENCES == 0 */ + } + return 0; // error +} + +CORBA::Boolean operator>> ( + TAO_InputCDR &strm, + PortableServer::ObjectId &_tao_sequence + ) +{ + CORBA::ULong _tao_seq_len; + if (strm >> _tao_seq_len) + { + // set the length of the sequence + _tao_sequence.length (_tao_seq_len); + // If length is 0 we return true. + if (0 >= _tao_seq_len) + return 1; + // retrieve all the elements + +#if (TAO_NO_COPY_OCTET_SEQUENCES == 1) + if (ACE_BIT_DISABLED (strm.start ()->flags (),ACE_Message_Block::DONT_DELETE)) + { + TAO_Unbounded_Sequence<CORBA::Octet> *oseq = + ACE_static_cast(TAO_Unbounded_Sequence<CORBA::Octet>*, &_tao_sequence); + oseq->replace (_tao_seq_len, strm.start ()); + oseq->mb ()->wr_ptr (oseq->mb()->rd_ptr () + _tao_seq_len); + strm.skip_bytes (_tao_seq_len); + return 1; + } + else + return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_seq_len); + +#else /* TAO_NO_COPY_OCTET_SEQUENCES == 0 */ + return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ()); + +#endif /* TAO_NO_COPY_OCTET_SEQUENCES == 0 */ + } + return 0; // error +} |