// $Id$ // // ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* // TAO ORB and the TAO IDL Compiler have been developed by Washington // University Computer Science's Distributed Object Computing Group. // // Information on TAO is available at // http://www.cs.wustl.edu/~schmidt/TAO.html // Take care: The typecodes are platform dependent, therefore // a ifdef is needed right now. This is going to be changed in // the future. #include "tao/POAC.h" #include "tao/POAS.h" #include "tao/POA.h" #include "tao/Typecode.h" #include "tao/Any.h" #include "tao/Invocation.h" #include "tao/Stub.h" #if !defined (__ACE_INLINE__) #include "tao/POAC.i" #endif // !defined INLINE ACE_RCSID(tao, POAC, "$Id$") #if !defined (_PORTABLESERVER__TAO_SEQ_OCTET_CS_) #define _PORTABLESERVER__TAO_SEQ_OCTET_CS_ static const CORBA::Long _oc_PortableServer__tao_seq_Octet[] = { TAO_ENCAP_BYTE_ORDER, // byte order CORBA::tk_octet, 0, }; static CORBA::TypeCode _tc_TAO_tc_PortableServer__tao_seq_Octet (CORBA::tk_sequence, sizeof (_oc_PortableServer__tao_seq_Octet), (char *) &_oc_PortableServer__tao_seq_Octet, 0, sizeof (PortableServer::_tao_seq_Octet)); TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) TAO_NAMESPACE_BEGIN (PortableServer) TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc__tao_seq_Octet, &_tc_TAO_tc_PortableServer__tao_seq_Octet) TAO_NAMESPACE_END #endif /* end #if !defined */ static const CORBA::Long _oc_PortableServer_ObjectId[] = { TAO_ENCAP_BYTE_ORDER, // byte order 40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f4f), ACE_NTOHL (0x626a6563), ACE_NTOHL (0x7449643a), ACE_NTOHL (0x312e3000), // repository ID = IDL:omg.org/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, 0, }; 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 !defined (TAO_HAS_MINIMUM_CORBA) // default constructor PortableServer::ForwardRequest::ForwardRequest (void) : CORBA_UserException (PortableServer::_tc_ForwardRequest) { } // destructor - all members are of self managing types PortableServer::ForwardRequest::~ForwardRequest (void) { } // copy constructor PortableServer::ForwardRequest::ForwardRequest (const PortableServer::ForwardRequest &_tao_excp) : CORBA_UserException (_tao_excp._type ()) { 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; } PortableServer::ForwardRequest::ForwardRequest( const CORBA::Object_ptr _tao_forward_reference) : CORBA_UserException (PortableServer::_tc_ForwardRequest) { this->forward_reference = CORBA::Object::_duplicate (_tao_forward_reference); } void PortableServer::ForwardRequest::_raise (void) { 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 ()); } // narrow PortableServer::ForwardRequest_ptr PortableServer::ForwardRequest::_narrow (CORBA::Exception *exc) { if (!ACE_OS::strcmp ("IDL:omg.org/PortableServer/ForwardRequest:1.0", exc->_id ())) // same type return ACE_dynamic_cast (PortableServer::ForwardRequest_ptr, exc); else return 0; } // = TAO extension CORBA::Exception *PortableServer::ForwardRequest::_alloc (void) { CORBA::Exception *retval = 0; ACE_NEW_RETURN (retval, PortableServer::ForwardRequest, 0); return retval; } void operator<<= (CORBA::Any &_tao_any, const PortableServer::ForwardRequest &_tao_elem) // copying { PortableServer::ForwardRequest *_tao_any_val = 0; ACE_NEW (_tao_any_val, PortableServer::ForwardRequest (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_any_val; _tao_any._tao_replace ( PortableServer::_tc_ForwardRequest, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_any_val, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { delete _tao_any_val; } ACE_ENDTRY; } void operator<<= (CORBA::Any &_tao_any, PortableServer::ForwardRequest *_tao_elem) // non copying { ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( PortableServer::_tc_ForwardRequest, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_elem, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { delete _tao_elem; _tao_elem = 0; } ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ForwardRequest *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::_tc_ForwardRequest, ACE_TRY_ENV)) // not equal { _tao_elem = 0; return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (PortableServer::ForwardRequest *)_tao_any.value (); return 1; } else { ACE_NEW_RETURN (_tao_elem, PortableServer::ForwardRequest, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); if (stream >> *_tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::_tc_ForwardRequest, 1, ACE_reinterpret_cast (void *, _tao_elem), ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else { delete _tao_elem; _tao_elem = 0; } } } ACE_CATCHANY { delete _tao_elem; _tao_elem = 0; return 0; } ACE_ENDTRY; return 0; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::ForwardRequest *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::_tc_ForwardRequest, ACE_TRY_ENV)) // not equal { _tao_elem = 0; return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (PortableServer::ForwardRequest *)_tao_any.value (); return 1; } else { ACE_NEW_RETURN (_tao_elem, PortableServer::ForwardRequest, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); if (stream >> *(PortableServer::ForwardRequest *)_tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::_tc_ForwardRequest, 1, ACE_reinterpret_cast (void *, ACE_const_cast (PortableServer::ForwardRequest *&, _tao_elem)), ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else { delete ACE_const_cast (PortableServer::ForwardRequest *&, _tao_elem); _tao_elem = 0; } } } ACE_CATCHANY { delete ACE_const_cast (PortableServer::ForwardRequest *&, _tao_elem); _tao_elem = 0; return 0; } ACE_ENDTRY; return 0; } static const CORBA::Long _oc_PortableServer_ForwardRequest[] = { TAO_ENCAP_BYTE_ORDER, // byte order 46, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), 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:omg.org/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 #endif /* TAO_HAS_MINIMUM_CORBA */ TAO_NAMESPACE_TYPE (const CORBA::ULong) TAO_NAMESPACE_BEGIN (PortableServer) TAO_NAMESPACE_DEFINE (const CORBA::ULong, THREAD_POLICY_ID, 16) TAO_NAMESPACE_END TAO_NAMESPACE_TYPE (const CORBA::ULong) TAO_NAMESPACE_BEGIN (PortableServer) TAO_NAMESPACE_DEFINE (const CORBA::ULong, LIFESPAN_POLICY_ID, 17) TAO_NAMESPACE_END TAO_NAMESPACE_TYPE (const CORBA::ULong) TAO_NAMESPACE_BEGIN (PortableServer) TAO_NAMESPACE_DEFINE (const CORBA::ULong, ID_UNIQUENESS_POLICY_ID, 18) TAO_NAMESPACE_END TAO_NAMESPACE_TYPE (const CORBA::ULong) TAO_NAMESPACE_BEGIN (PortableServer) TAO_NAMESPACE_DEFINE (const CORBA::ULong, ID_ASSIGNMENT_POLICY_ID, 19) TAO_NAMESPACE_END TAO_NAMESPACE_TYPE (const CORBA::ULong) TAO_NAMESPACE_BEGIN (PortableServer) TAO_NAMESPACE_DEFINE (const CORBA::ULong, IMPLICIT_ACTIVATION_POLICY_ID, 20) TAO_NAMESPACE_END TAO_NAMESPACE_TYPE (const CORBA::ULong) TAO_NAMESPACE_BEGIN (PortableServer) TAO_NAMESPACE_DEFINE (const CORBA::ULong, SERVANT_RETENTION_POLICY_ID, 21) TAO_NAMESPACE_END TAO_NAMESPACE_TYPE (const CORBA::ULong) TAO_NAMESPACE_BEGIN (PortableServer) TAO_NAMESPACE_DEFINE (const CORBA::ULong, REQUEST_PROCESSING_POLICY_ID, 22) TAO_NAMESPACE_END #if (TAO_HAS_MINIMUM_POA == 0) static const CORBA::Long _oc_PortableServer_ThreadPolicyValue[] = { TAO_ENCAP_BYTE_ORDER, // byte order 49, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), 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:omg.org/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 PortableServer::ThreadPolicy_ptr PortableServer::ThreadPolicy::_duplicate (PortableServer::ThreadPolicy_ptr obj) { if (!CORBA::is_nil (obj)) obj->_incr_refcnt (); return obj; } // end of _duplicate PortableServer::ThreadPolicy_ptr PortableServer::ThreadPolicy::_narrow ( CORBA::Object_ptr obj, CORBA::Environment &ACE_TRY_ENV ) { if (CORBA::is_nil (obj)) return PortableServer::ThreadPolicy::_nil (); CORBA::Boolean check = !obj->_is_a ("IDL:omg.org/PortableServer/ThreadPolicy:1.0", ACE_TRY_ENV); ACE_CHECK_RETURN (PortableServer::ThreadPolicy::_nil ()); if (check) return PortableServer::ThreadPolicy::_nil (); void* servant = 0; TAO_Stub* stub = obj->_stubobj (); if (obj->_is_collocated () && obj->_servant() != 0) servant = obj->_servant()->_downcast ("IDL:omg.org/PortableServer/ThreadPolicy:1.0"); #if defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES) if (servant == 0) ACE_THROW_RETURN (CORBA::MARSHAL (), PortableServer::ThreadPolicy::_nil ()); #else stub->_incr_refcnt (); if (servant == 0) { PortableServer::ThreadPolicy_ptr rval = PortableServer::ThreadPolicy::_nil (); ACE_NEW_RETURN (rval, PortableServer::ThreadPolicy (stub), PortableServer::ThreadPolicy::_nil ()); return rval; } #endif /* TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */ PortableServer::ThreadPolicy_ptr retval = PortableServer::ThreadPolicy::_nil (); ACE_NEW_RETURN ( retval, POA_PortableServer::_tao_collocated_ThreadPolicy ( ACE_reinterpret_cast (POA_PortableServer::ThreadPolicy_ptr, servant), stub ), PortableServer::ThreadPolicy::_nil () ); return retval; } #if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES) PortableServer::ThreadPolicyValue PortableServer::ThreadPolicy::value(CORBA::Environment &ACE_TRY_ENV) { PortableServer::ThreadPolicyValue _tao_retval = (PortableServer::ThreadPolicyValue)0; TAO_Stub *istub = this->_stubobj (); if (istub == 0) ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval); TAO_GIOP_Twoway_Invocation _tao_call ( istub, "_get_""value", 10, istub->orb_core () ); for (;;) { _tao_call.start (ACE_TRY_ENV); ACE_CHECK_RETURN (_tao_retval); CORBA::Short flag = 131; _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); ACE_CHECK_RETURN (_tao_retval); int _invoke_status = _tao_call.invoke (0, 0, ACE_TRY_ENV); ACE_CHECK_RETURN (_tao_retval); if (_invoke_status == TAO_INVOKE_RESTART) continue; // if (_invoke_status == TAO_INVOKE_EXCEPTION) // cannot happen if (_invoke_status != TAO_INVOKE_OK) { ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval); } break; } TAO_InputCDR &_tao_in = _tao_call.inp_stream (); if (! (_tao_in >> _tao_retval)) ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval); return _tao_retval; } #endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */ CORBA::Boolean PortableServer::ThreadPolicy::_is_a (const CORBA::Char *value, CORBA::Environment &_tao_environment) { if ( (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/PortableServer/ThreadPolicy:1.0")) || (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/PortableServer/Policy:1.0")) || (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (_tao_environment)))) return 1; // success using local knowledge else return this->CORBA_Object::_is_a (value, _tao_environment); // remote call } const char* PortableServer::ThreadPolicy::_interface_repository_id (void) const { return "IDL:omg.org/PortableServer/ThreadPolicy:1.0"; } static const CORBA::Long _oc_PortableServer_ThreadPolicy[] = { TAO_ENCAP_BYTE_ORDER, // byte order 44, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f54), ACE_NTOHL (0x68726561), ACE_NTOHL (0x64506f6c), ACE_NTOHL (0x6963793a), ACE_NTOHL (0x312e3000), // repository ID = IDL:omg.org/PortableServer/ThreadPolicy:1.0 13, ACE_NTOHL (0x54687265), ACE_NTOHL (0x6164506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x0), // name = ThreadPolicy, }; static CORBA::TypeCode _tc_TAO_tc_PortableServer_ThreadPolicy (CORBA::tk_objref, sizeof (_oc_PortableServer_ThreadPolicy), (char *) &_oc_PortableServer_ThreadPolicy, 0, sizeof (PortableServer::ThreadPolicy)); TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) TAO_NAMESPACE_BEGIN (PortableServer) TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ThreadPolicy, &_tc_TAO_tc_PortableServer_ThreadPolicy) TAO_NAMESPACE_END #endif /* TAO_HAS_MINIMUM_POA == 0 */ static const CORBA::Long _oc_PortableServer_LifespanPolicyValue[] = { TAO_ENCAP_BYTE_ORDER, // byte order 51, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), 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:omg.org/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 PortableServer::LifespanPolicy_ptr PortableServer::LifespanPolicy::_duplicate (PortableServer::LifespanPolicy_ptr obj) { if (!CORBA::is_nil (obj)) obj->_incr_refcnt (); return obj; } // end of _duplicate PortableServer::LifespanPolicy_ptr PortableServer::LifespanPolicy::_narrow ( CORBA::Object_ptr obj, CORBA::Environment &ACE_TRY_ENV ) { if (CORBA::is_nil (obj)) return PortableServer::LifespanPolicy::_nil (); CORBA::Boolean check = !obj->_is_a ("IDL:omg.org/PortableServer/LifespanPolicy:1.0", ACE_TRY_ENV); ACE_CHECK_RETURN (PortableServer::LifespanPolicy::_nil ()); if (check) return PortableServer::LifespanPolicy::_nil (); TAO_Stub* stub = obj->_stubobj (); void* servant = 0; if (obj->_is_collocated () && obj->_servant() != 0) servant = obj->_servant()->_downcast ("IDL:omg.org/PortableServer/LifespanPolicy:1.0"); #if defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES) if (servant == 0) ACE_THROW_RETURN (CORBA::MARSHAL (), PortableServer::LifespanPolicy::_nil ()); #else stub->_incr_refcnt (); if (servant == 0) { PortableServer::LifespanPolicy_ptr rval = PortableServer::LifespanPolicy::_nil (); ACE_NEW_RETURN (rval, PortableServer::LifespanPolicy (stub), PortableServer::LifespanPolicy::_nil ()); return rval; } #endif /* TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */ PortableServer::LifespanPolicy_ptr retval = PortableServer::LifespanPolicy::_nil (); ACE_NEW_RETURN ( retval, POA_PortableServer::_tao_collocated_LifespanPolicy ( ACE_reinterpret_cast (POA_PortableServer::LifespanPolicy_ptr, servant), stub ), PortableServer::LifespanPolicy::_nil () ); return retval; } #if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES) PortableServer::LifespanPolicyValue PortableServer::LifespanPolicy::value(CORBA::Environment &ACE_TRY_ENV) { PortableServer::LifespanPolicyValue _tao_retval = (PortableServer::LifespanPolicyValue)0; TAO_Stub *istub = this->_stubobj (); if (istub == 0) ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval); TAO_GIOP_Twoway_Invocation _tao_call ( istub, "_get_""value", 10, istub->orb_core () ); for (;;) { _tao_call.start (ACE_TRY_ENV); ACE_CHECK_RETURN (_tao_retval); CORBA::Short flag = 131; _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); ACE_CHECK_RETURN (_tao_retval); int _invoke_status = _tao_call.invoke (0, 0, ACE_TRY_ENV); ACE_CHECK_RETURN (_tao_retval); if (_invoke_status == TAO_INVOKE_RESTART) continue; // if (_invoke_status == TAO_INVOKE_EXCEPTION) // cannot happen if (_invoke_status != TAO_INVOKE_OK) { ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval); } break; } TAO_InputCDR &_tao_in = _tao_call.inp_stream (); if (!( (_tao_in >> _tao_retval) )) ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval); return _tao_retval; } #endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */ CORBA::Boolean PortableServer::LifespanPolicy::_is_a (const CORBA::Char *value, CORBA::Environment &_tao_environment) { if ( (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/PortableServer/LifespanPolicy:1.0")) || (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/PortableServer/Policy:1.0")) || (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (_tao_environment)))) return 1; // success using local knowledge else return this->CORBA_Object::_is_a (value, _tao_environment); // remote call } const char* PortableServer::LifespanPolicy::_interface_repository_id (void) const { return "IDL:omg.org/PortableServer/LifespanPolicy:1.0"; } static const CORBA::Long _oc_PortableServer_LifespanPolicy[] = { TAO_ENCAP_BYTE_ORDER, // byte order 46, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f4c), ACE_NTOHL (0x69666573), ACE_NTOHL (0x70616e50), ACE_NTOHL (0x6f6c6963), ACE_NTOHL (0x793a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/PortableServer/LifespanPolicy:1.0 15, ACE_NTOHL (0x4c696665), ACE_NTOHL (0x7370616e), ACE_NTOHL (0x506f6c69), ACE_NTOHL (0x63790000), // name = LifespanPolicy, }; static CORBA::TypeCode _tc_TAO_tc_PortableServer_LifespanPolicy (CORBA::tk_objref, sizeof (_oc_PortableServer_LifespanPolicy), (char *) &_oc_PortableServer_LifespanPolicy, 0, sizeof (PortableServer::LifespanPolicy)); TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) TAO_NAMESPACE_BEGIN (PortableServer) TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_LifespanPolicy, &_tc_TAO_tc_PortableServer_LifespanPolicy) TAO_NAMESPACE_END static const CORBA::Long _oc_PortableServer_IdUniquenessPolicyValue[] = { TAO_ENCAP_BYTE_ORDER, // byte order 55, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), 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:omg.org/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 PortableServer::IdUniquenessPolicy_ptr PortableServer::IdUniquenessPolicy::_duplicate (PortableServer::IdUniquenessPolicy_ptr obj) { if (!CORBA::is_nil (obj)) obj->_incr_refcnt (); return obj; } // end of _duplicate PortableServer::IdUniquenessPolicy_ptr PortableServer::IdUniquenessPolicy::_narrow ( CORBA::Object_ptr obj, CORBA::Environment &ACE_TRY_ENV ) { if (CORBA::is_nil (obj)) return PortableServer::IdUniquenessPolicy::_nil (); CORBA::Boolean check = !obj->_is_a ("IDL:omg.org/PortableServer/IdUniquenessPolicy:1.0", ACE_TRY_ENV); ACE_CHECK_RETURN (PortableServer::IdUniquenessPolicy::_nil ()); if (check) return PortableServer::IdUniquenessPolicy::_nil (); TAO_Stub* stub = obj->_stubobj (); void* servant = 0; if (obj->_is_collocated () && obj->_servant() != 0) servant = obj->_servant()->_downcast ("IDL:omg.org/PortableServer/IdUniquenessPolicy:1.0"); #if defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES) if (servant == 0) ACE_THROW_RETURN (CORBA::MARSHAL (), PortableServer::IdUniquenessPolicy::_nil ()); #else stub->_incr_refcnt (); if (servant == 0) { PortableServer::IdUniquenessPolicy_ptr rval = PortableServer::IdUniquenessPolicy::_nil (); ACE_NEW_RETURN (rval, PortableServer::IdUniquenessPolicy (stub), PortableServer::IdUniquenessPolicy::_nil ()); return rval; } #endif /* TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */ PortableServer::IdUniquenessPolicy_ptr retval = PortableServer::IdUniquenessPolicy::_nil (); ACE_NEW_RETURN ( retval, POA_PortableServer::_tao_collocated_IdUniquenessPolicy ( ACE_reinterpret_cast (POA_PortableServer::IdUniquenessPolicy_ptr, servant), stub ), PortableServer::IdUniquenessPolicy::_nil () ); return retval; } #if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES) PortableServer::IdUniquenessPolicyValue PortableServer::IdUniquenessPolicy::value(CORBA::Environment &ACE_TRY_ENV) { PortableServer::IdUniquenessPolicyValue _tao_retval = (PortableServer::IdUniquenessPolicyValue)0; TAO_Stub *istub = this->_stubobj (); if (istub == 0) ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval); TAO_GIOP_Twoway_Invocation _tao_call ( istub, "_get_""value", 10, istub->orb_core () ); for (;;) { _tao_call.start (ACE_TRY_ENV); ACE_CHECK_RETURN (_tao_retval); CORBA::Short flag = 131; _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); ACE_CHECK_RETURN (_tao_retval); int _invoke_status = _tao_call.invoke (0, 0, ACE_TRY_ENV); ACE_CHECK_RETURN (_tao_retval); if (_invoke_status == TAO_INVOKE_RESTART) continue; // if (_invoke_status == TAO_INVOKE_EXCEPTION) // cannot happen if (_invoke_status != TAO_INVOKE_OK) { ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval); } break; } TAO_InputCDR &_tao_in = _tao_call.inp_stream (); if (!( (_tao_in >> _tao_retval) )) ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval); return _tao_retval; } #endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */ CORBA::Boolean PortableServer::IdUniquenessPolicy::_is_a (const CORBA::Char *value, CORBA::Environment &_tao_environment) { if ( (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/PortableServer/IdUniquenessPolicy:1.0")) || (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/PortableServer/Policy:1.0")) || (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (_tao_environment)))) return 1; // success using local knowledge else return this->CORBA_Object::_is_a (value, _tao_environment); // remote call } const char* PortableServer::IdUniquenessPolicy::_interface_repository_id (void) const { return "IDL:omg.org/PortableServer/IdUniquenessPolicy:1.0"; } static const CORBA::Long _oc_PortableServer_IdUniquenessPolicy[] = { TAO_ENCAP_BYTE_ORDER, // byte order 50, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), 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 (0x793a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/PortableServer/IdUniquenessPolicy:1.0 19, ACE_NTOHL (0x4964556e), ACE_NTOHL (0x69717565), ACE_NTOHL (0x6e657373), ACE_NTOHL (0x506f6c69), ACE_NTOHL (0x63790000), // name = IdUniquenessPolicy, }; static CORBA::TypeCode _tc_TAO_tc_PortableServer_IdUniquenessPolicy (CORBA::tk_objref, sizeof (_oc_PortableServer_IdUniquenessPolicy), (char *) &_oc_PortableServer_IdUniquenessPolicy, 0, sizeof (PortableServer::IdUniquenessPolicy)); TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) TAO_NAMESPACE_BEGIN (PortableServer) TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_IdUniquenessPolicy, &_tc_TAO_tc_PortableServer_IdUniquenessPolicy) TAO_NAMESPACE_END static const CORBA::Long _oc_PortableServer_IdAssignmentPolicyValue[] = { TAO_ENCAP_BYTE_ORDER, // byte order 55, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), 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:omg.org/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 PortableServer::IdAssignmentPolicy_ptr PortableServer::IdAssignmentPolicy::_duplicate (PortableServer::IdAssignmentPolicy_ptr obj) { if (!CORBA::is_nil (obj)) obj->_incr_refcnt (); return obj; } // end of _duplicate PortableServer::IdAssignmentPolicy_ptr PortableServer::IdAssignmentPolicy::_narrow ( CORBA::Object_ptr obj, CORBA::Environment &ACE_TRY_ENV ) { if (CORBA::is_nil (obj)) return PortableServer::IdAssignmentPolicy::_nil (); CORBA::Boolean check = !obj->_is_a ("IDL:omg.org/PortableServer/IdAssignmentPolicy:1.0", ACE_TRY_ENV); ACE_CHECK_RETURN (PortableServer::IdAssignmentPolicy::_nil ()); if (check) return PortableServer::IdAssignmentPolicy::_nil (); TAO_Stub* stub = obj->_stubobj (); void* servant = 0; if (obj->_is_collocated () && obj->_servant() != 0) servant = obj->_servant()->_downcast ("IDL:omg.org/PortableServer/IdAssignmentPolicy:1.0"); #if defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES) if (servant == 0) ACE_THROW_RETURN (CORBA::MARSHAL (), PortableServer::IdAssignmentPolicy::_nil ()); #else stub->_incr_refcnt (); if (servant == 0) { PortableServer::IdAssignmentPolicy_ptr rval = PortableServer::IdAssignmentPolicy::_nil (); ACE_NEW_RETURN (rval, PortableServer::IdAssignmentPolicy (stub), PortableServer::IdAssignmentPolicy::_nil ()); return rval; } #endif /* TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */ PortableServer::IdAssignmentPolicy_ptr retval = PortableServer::IdAssignmentPolicy::_nil (); ACE_NEW_RETURN ( retval, POA_PortableServer::_tao_collocated_IdAssignmentPolicy ( ACE_reinterpret_cast (POA_PortableServer::IdAssignmentPolicy_ptr, servant), stub ), PortableServer::IdAssignmentPolicy::_nil () ); return retval; } #if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES) PortableServer::IdAssignmentPolicyValue PortableServer::IdAssignmentPolicy::value(CORBA::Environment &ACE_TRY_ENV) { PortableServer::IdAssignmentPolicyValue _tao_retval = (PortableServer::IdAssignmentPolicyValue)0; TAO_Stub *istub = this->_stubobj (); if (istub == 0) ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval); TAO_GIOP_Twoway_Invocation _tao_call ( istub, "_get_""value", 10, istub->orb_core () ); for (;;) { _tao_call.start (ACE_TRY_ENV); ACE_CHECK_RETURN (_tao_retval); CORBA::Short flag = 131; _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); ACE_CHECK_RETURN (_tao_retval); int _invoke_status = _tao_call.invoke (0, 0, ACE_TRY_ENV); ACE_CHECK_RETURN (_tao_retval); if (_invoke_status == TAO_INVOKE_RESTART) continue; // if (_invoke_status == TAO_INVOKE_EXCEPTION) // cannot happen if (_invoke_status != TAO_INVOKE_OK) { ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval); } break; } TAO_InputCDR &_tao_in = _tao_call.inp_stream (); if (!( (_tao_in >> _tao_retval) )) ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval); return _tao_retval; } #endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */ CORBA::Boolean PortableServer::IdAssignmentPolicy::_is_a (const CORBA::Char *value, CORBA::Environment &_tao_environment) { if ( (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/PortableServer/IdAssignmentPolicy:1.0")) || (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/PortableServer/Policy:1.0")) || (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (_tao_environment)))) return 1; // success using local knowledge else return this->CORBA_Object::_is_a (value, _tao_environment); // remote call } const char* PortableServer::IdAssignmentPolicy::_interface_repository_id (void) const { return "IDL:omg.org/PortableServer/IdAssignmentPolicy:1.0"; } static const CORBA::Long _oc_PortableServer_IdAssignmentPolicy[] = { TAO_ENCAP_BYTE_ORDER, // byte order 50, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), 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 (0x793a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/PortableServer/IdAssignmentPolicy:1.0 19, ACE_NTOHL (0x49644173), ACE_NTOHL (0x7369676e), ACE_NTOHL (0x6d656e74), ACE_NTOHL (0x506f6c69), ACE_NTOHL (0x63790000), // name = IdAssignmentPolicy, }; static CORBA::TypeCode _tc_TAO_tc_PortableServer_IdAssignmentPolicy (CORBA::tk_objref, sizeof (_oc_PortableServer_IdAssignmentPolicy), (char *) &_oc_PortableServer_IdAssignmentPolicy, 0, sizeof (PortableServer::IdAssignmentPolicy)); TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) TAO_NAMESPACE_BEGIN (PortableServer) TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_IdAssignmentPolicy, &_tc_TAO_tc_PortableServer_IdAssignmentPolicy) TAO_NAMESPACE_END #if (TAO_HAS_MINIMUM_POA == 0) static const CORBA::Long _oc_PortableServer_ImplicitActivationPolicyValue[] = { TAO_ENCAP_BYTE_ORDER, // byte order 61, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), 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:omg.org/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 PortableServer::ImplicitActivationPolicy_ptr PortableServer::ImplicitActivationPolicy::_duplicate (PortableServer::ImplicitActivationPolicy_ptr obj) { if (!CORBA::is_nil (obj)) obj->_incr_refcnt (); return obj; } // end of _duplicate PortableServer::ImplicitActivationPolicy_ptr PortableServer::ImplicitActivationPolicy::_narrow ( CORBA::Object_ptr obj, CORBA::Environment &ACE_TRY_ENV ) { if (CORBA::is_nil (obj)) return PortableServer::ImplicitActivationPolicy::_nil (); CORBA::Boolean check = !obj->_is_a ("IDL:omg.org/PortableServer/ImplicitActivationPolicy:1.0", ACE_TRY_ENV); ACE_CHECK_RETURN (PortableServer::ImplicitActivationPolicy::_nil ()); if (check) return PortableServer::ImplicitActivationPolicy::_nil (); TAO_Stub* stub = obj->_stubobj (); void* servant = 0; if (obj->_is_collocated () && obj->_servant() != 0) servant = obj->_servant()->_downcast ("IDL:omg.org/PortableServer/ImplicitActivationPolicy:1.0"); #if defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES) if (servant == 0) ACE_THROW_RETURN (CORBA::MARSHAL (), PortableServer::ImplicitActivationPolicy::_nil ()); #else stub->_incr_refcnt (); if (servant == 0) { PortableServer::ImplicitActivationPolicy_ptr rval = PortableServer::ImplicitActivationPolicy::_nil (); ACE_NEW_RETURN (rval, PortableServer::ImplicitActivationPolicy (stub), PortableServer::ImplicitActivationPolicy::_nil ()); return rval; } #endif /* TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */ PortableServer::ImplicitActivationPolicy_ptr retval = PortableServer::ImplicitActivationPolicy::_nil (); ACE_NEW_RETURN ( retval, POA_PortableServer::_tao_collocated_ImplicitActivationPolicy ( ACE_reinterpret_cast (POA_PortableServer::ImplicitActivationPolicy_ptr, servant), stub ), PortableServer::ImplicitActivationPolicy::_nil () ); return retval; } #if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES) PortableServer::ImplicitActivationPolicyValue PortableServer::ImplicitActivationPolicy::value(CORBA::Environment &ACE_TRY_ENV) { PortableServer::ImplicitActivationPolicyValue _tao_retval = (PortableServer::ImplicitActivationPolicyValue)0; TAO_Stub *istub = this->_stubobj (); if (istub == 0) ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval); TAO_GIOP_Twoway_Invocation _tao_call ( istub, "_get_""value", 10, istub->orb_core () ); for (;;) { _tao_call.start (ACE_TRY_ENV); ACE_CHECK_RETURN (_tao_retval); CORBA::Short flag = 131; _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); ACE_CHECK_RETURN (_tao_retval); int _invoke_status = _tao_call.invoke (0, 0, ACE_TRY_ENV); ACE_CHECK_RETURN (_tao_retval); if (_invoke_status == TAO_INVOKE_RESTART) continue; // if (_invoke_status == TAO_INVOKE_EXCEPTION) // cannot happen if (_invoke_status != TAO_INVOKE_OK) { ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval); } break; } TAO_InputCDR &_tao_in = _tao_call.inp_stream (); if (!( (_tao_in >> _tao_retval) )) ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval); return _tao_retval; } #endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */ CORBA::Boolean PortableServer::ImplicitActivationPolicy::_is_a (const CORBA::Char *value, CORBA::Environment &_tao_environment) { if ( (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/PortableServer/ImplicitActivationPolicy:1.0")) || (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/PortableServer/Policy:1.0")) || (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (_tao_environment)))) return 1; // success using local knowledge else return this->CORBA_Object::_is_a (value, _tao_environment); // remote call } const char* PortableServer::ImplicitActivationPolicy::_interface_repository_id (void) const { return "IDL:omg.org/PortableServer/ImplicitActivationPolicy:1.0"; } static const CORBA::Long _oc_PortableServer_ImplicitActivationPolicy[] = { TAO_ENCAP_BYTE_ORDER, // byte order 56, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), 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 (0x6963793a), ACE_NTOHL (0x312e3000), // repository ID = IDL:omg.org/PortableServer/ImplicitActivationPolicy:1.0 25, ACE_NTOHL (0x496d706c), ACE_NTOHL (0x69636974), ACE_NTOHL (0x41637469), ACE_NTOHL (0x76617469), ACE_NTOHL (0x6f6e506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x0), // name = ImplicitActivationPolicy, }; static CORBA::TypeCode _tc_TAO_tc_PortableServer_ImplicitActivationPolicy (CORBA::tk_objref, sizeof (_oc_PortableServer_ImplicitActivationPolicy), (char *) &_oc_PortableServer_ImplicitActivationPolicy, 0, sizeof (PortableServer::ImplicitActivationPolicy)); TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) TAO_NAMESPACE_BEGIN (PortableServer) TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ImplicitActivationPolicy, &_tc_TAO_tc_PortableServer_ImplicitActivationPolicy) TAO_NAMESPACE_END static const CORBA::Long _oc_PortableServer_ServantRetentionPolicyValue[] = { TAO_ENCAP_BYTE_ORDER, // byte order 59, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), 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:omg.org/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 PortableServer::ServantRetentionPolicy_ptr PortableServer::ServantRetentionPolicy::_duplicate (PortableServer::ServantRetentionPolicy_ptr obj) { if (!CORBA::is_nil (obj)) obj->_incr_refcnt (); return obj; } // end of _duplicate PortableServer::ServantRetentionPolicy_ptr PortableServer::ServantRetentionPolicy::_narrow ( CORBA::Object_ptr obj, CORBA::Environment &ACE_TRY_ENV ) { if (CORBA::is_nil (obj)) return PortableServer::ServantRetentionPolicy::_nil (); CORBA::Boolean check = !obj->_is_a ("IDL:omg.org/PortableServer/ServantRetentionPolicy:1.0", ACE_TRY_ENV); ACE_CHECK_RETURN (PortableServer::ServantRetentionPolicy::_nil ()); if (check) return PortableServer::ServantRetentionPolicy::_nil (); TAO_Stub* stub = obj->_stubobj (); void* servant = 0; if (obj->_is_collocated () && obj->_servant() != 0) servant = obj->_servant()->_downcast ("IDL:omg.org/PortableServer/ServantRetentionPolicy:1.0"); #if defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES) if (servant == 0) ACE_THROW_RETURN (CORBA::MARSHAL (), PortableServer::ServantRetentionPolicy::_nil ()); #else stub->_incr_refcnt (); if (servant == 0) { PortableServer::ServantRetentionPolicy_ptr rval = PortableServer::ServantRetentionPolicy::_nil (); ACE_NEW_RETURN (rval, PortableServer::ServantRetentionPolicy (stub), PortableServer::ServantRetentionPolicy::_nil ()); return rval; } #endif /* TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */ PortableServer::ServantRetentionPolicy_ptr retval = PortableServer::ServantRetentionPolicy::_nil (); ACE_NEW_RETURN ( retval, POA_PortableServer::_tao_collocated_ServantRetentionPolicy ( ACE_reinterpret_cast (POA_PortableServer::ServantRetentionPolicy_ptr, servant), stub ), PortableServer::ServantRetentionPolicy::_nil () ); return retval; } #if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES) PortableServer::ServantRetentionPolicyValue PortableServer::ServantRetentionPolicy::value(CORBA::Environment &ACE_TRY_ENV) { PortableServer::ServantRetentionPolicyValue _tao_retval = (PortableServer::ServantRetentionPolicyValue)0; TAO_Stub *istub = this->_stubobj (); if (istub == 0) ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval); TAO_GIOP_Twoway_Invocation _tao_call ( istub, "_get_""value", 10, istub->orb_core () ); for (;;) { _tao_call.start (ACE_TRY_ENV); ACE_CHECK_RETURN (_tao_retval); CORBA::Short flag = 131; _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); ACE_CHECK_RETURN (_tao_retval); int _invoke_status = _tao_call.invoke (0, 0, ACE_TRY_ENV); ACE_CHECK_RETURN (_tao_retval); if (_invoke_status == TAO_INVOKE_RESTART) continue; // if (_invoke_status == TAO_INVOKE_EXCEPTION) // cannot happen if (_invoke_status != TAO_INVOKE_OK) { ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval); } break; } TAO_InputCDR &_tao_in = _tao_call.inp_stream (); if (!( (_tao_in >> _tao_retval) )) ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval); return _tao_retval; } #endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */ CORBA::Boolean PortableServer::ServantRetentionPolicy::_is_a (const CORBA::Char *value, CORBA::Environment &_tao_environment) { if ( (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/PortableServer/ServantRetentionPolicy:1.0")) || (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/PortableServer/Policy:1.0")) || (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (_tao_environment)))) return 1; // success using local knowledge else return this->CORBA_Object::_is_a (value, _tao_environment); // remote call } const char* PortableServer::ServantRetentionPolicy::_interface_repository_id (void) const { return "IDL:omg.org/PortableServer/ServantRetentionPolicy:1.0"; } static const CORBA::Long _oc_PortableServer_ServantRetentionPolicy[] = { TAO_ENCAP_BYTE_ORDER, // byte order 54, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), 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 (0x793a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/PortableServer/ServantRetentionPolicy:1.0 23, ACE_NTOHL (0x53657276), ACE_NTOHL (0x616e7452), ACE_NTOHL (0x6574656e), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x506f6c69), ACE_NTOHL (0x63790000), // name = ServantRetentionPolicy, }; static CORBA::TypeCode _tc_TAO_tc_PortableServer_ServantRetentionPolicy (CORBA::tk_objref, sizeof (_oc_PortableServer_ServantRetentionPolicy), (char *) &_oc_PortableServer_ServantRetentionPolicy, 0, sizeof (PortableServer::ServantRetentionPolicy)); TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) TAO_NAMESPACE_BEGIN (PortableServer) TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ServantRetentionPolicy, &_tc_TAO_tc_PortableServer_ServantRetentionPolicy) TAO_NAMESPACE_END static const CORBA::Long _oc_PortableServer_RequestProcessingPolicyValue[] = { TAO_ENCAP_BYTE_ORDER, // byte order 60, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), 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:omg.org/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 PortableServer::RequestProcessingPolicy_ptr PortableServer::RequestProcessingPolicy::_duplicate (PortableServer::RequestProcessingPolicy_ptr obj) { if (!CORBA::is_nil (obj)) obj->_incr_refcnt (); return obj; } // end of _duplicate PortableServer::RequestProcessingPolicy_ptr PortableServer::RequestProcessingPolicy::_narrow ( CORBA::Object_ptr obj, CORBA::Environment &ACE_TRY_ENV ) { if (CORBA::is_nil (obj)) return PortableServer::RequestProcessingPolicy::_nil (); CORBA::Boolean check = !obj->_is_a ("IDL:omg.org/PortableServer/RequestProcessingPolicy:1.0", ACE_TRY_ENV); ACE_CHECK_RETURN (PortableServer::RequestProcessingPolicy::_nil ()); if (check) return PortableServer::RequestProcessingPolicy::_nil (); TAO_Stub* stub = obj->_stubobj (); void* servant = 0; if (obj->_is_collocated () && obj->_servant() != 0) servant = obj->_servant()->_downcast ("IDL:omg.org/PortableServer/RequestProcessingPolicy:1.0"); #if defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES) if (servant == 0) ACE_THROW_RETURN (CORBA::MARSHAL (), PortableServer::RequestProcessingPolicy::_nil ()); #else stub->_incr_refcnt (); if (servant == 0) { PortableServer::RequestProcessingPolicy_ptr rval = PortableServer::RequestProcessingPolicy::_nil (); ACE_NEW_RETURN (rval, PortableServer::RequestProcessingPolicy (stub), PortableServer::RequestProcessingPolicy::_nil ()); return rval; } #endif /* TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */ PortableServer::RequestProcessingPolicy_ptr retval = PortableServer::RequestProcessingPolicy::_nil (); ACE_NEW_RETURN ( retval, POA_PortableServer::_tao_collocated_RequestProcessingPolicy ( ACE_reinterpret_cast (POA_PortableServer::RequestProcessingPolicy_ptr, servant), stub ), PortableServer::RequestProcessingPolicy::_nil () ); return retval; } #if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES) PortableServer::RequestProcessingPolicyValue PortableServer::RequestProcessingPolicy::value(CORBA::Environment &ACE_TRY_ENV) { PortableServer::RequestProcessingPolicyValue _tao_retval = (PortableServer::RequestProcessingPolicyValue)0; TAO_Stub *istub = this->_stubobj (); if (istub == 0) ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval); TAO_GIOP_Twoway_Invocation _tao_call ( istub, "_get_""value", 10, istub->orb_core () ); for (;;) { _tao_call.start (ACE_TRY_ENV); ACE_CHECK_RETURN (_tao_retval); CORBA::Short flag = 131; _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); ACE_CHECK_RETURN (_tao_retval); int _invoke_status = _tao_call.invoke (0, 0, ACE_TRY_ENV); ACE_CHECK_RETURN (_tao_retval); if (_invoke_status == TAO_INVOKE_RESTART) continue; // if (_invoke_status == TAO_INVOKE_EXCEPTION) // cannot happen if (_invoke_status != TAO_INVOKE_OK) { ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval); } break; } TAO_InputCDR &_tao_in = _tao_call.inp_stream (); if (!( (_tao_in >> _tao_retval) )) ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval); return _tao_retval; } #endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */ CORBA::Boolean PortableServer::RequestProcessingPolicy::_is_a (const CORBA::Char *value, CORBA::Environment &_tao_environment) { if ( (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/PortableServer/RequestProcessingPolicy:1.0")) || (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/PortableServer/Policy:1.0")) || (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (_tao_environment)))) return 1; // success using local knowledge else return this->CORBA_Object::_is_a (value, _tao_environment); // remote call } const char* PortableServer::RequestProcessingPolicy::_interface_repository_id (void) const { return "IDL:omg.org/PortableServer/RequestProcessingPolicy:1.0"; } static const CORBA::Long _oc_PortableServer_RequestProcessingPolicy[] = { TAO_ENCAP_BYTE_ORDER, // byte order 55, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), 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 (0x63793a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/PortableServer/RequestProcessingPolicy:1.0 24, ACE_NTOHL (0x52657175), ACE_NTOHL (0x65737450), ACE_NTOHL (0x726f6365), ACE_NTOHL (0x7373696e), ACE_NTOHL (0x67506f6c), ACE_NTOHL (0x69637900), // name = RequestProcessingPolicy, }; static CORBA::TypeCode _tc_TAO_tc_PortableServer_RequestProcessingPolicy (CORBA::tk_objref, sizeof (_oc_PortableServer_RequestProcessingPolicy), (char *) &_oc_PortableServer_RequestProcessingPolicy, 0, sizeof (PortableServer::RequestProcessingPolicy)); TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) TAO_NAMESPACE_BEGIN (PortableServer) TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_RequestProcessingPolicy, &_tc_TAO_tc_PortableServer_RequestProcessingPolicy) TAO_NAMESPACE_END #endif /* TAO_HAS_MINIMUM_POA == 0 */ PortableServer::POAManager_ptr PortableServer::POAManager::_duplicate (PortableServer::POAManager_ptr obj) { if (!CORBA::is_nil (obj)) obj->_incr_refcnt (); return obj; } // end of _duplicate static const CORBA::Long _oc_PortableServer_POAManager_State[] = { TAO_ENCAP_BYTE_ORDER, // byte order 48, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f50), ACE_NTOHL (0x4f414d61), ACE_NTOHL (0x6e616765), ACE_NTOHL (0x722f5374), ACE_NTOHL (0x6174653a), ACE_NTOHL (0x312e3000), // repository ID = IDL:omg.org/PortableServer/POAManager/State:1.0 6, ACE_NTOHL (0x53746174), ACE_NTOHL (0x65000000), // name = State 4, // member count 8, ACE_NTOHL (0x484f4c44), ACE_NTOHL (0x494e4700), // name = HOLDING 7, ACE_NTOHL (0x41435449), ACE_NTOHL (0x56450000), // name = ACTIVE 11, ACE_NTOHL (0x44495343), ACE_NTOHL (0x41524449), ACE_NTOHL (0x4e470000), // name = DISCARDING 9, ACE_NTOHL (0x494e4143), ACE_NTOHL (0x54495645), ACE_NTOHL (0x0), // name = INACTIVE }; static CORBA::TypeCode _tc_TAO_tc_PortableServer_POAManager_State (CORBA::tk_enum, sizeof (_oc_PortableServer_POAManager_State), (char *) &_oc_PortableServer_POAManager_State, 0, sizeof (PortableServer::POAManager::State)); CORBA::TypeCode_ptr PortableServer::POAManager::_tc_State = &_tc_TAO_tc_PortableServer_POAManager_State; PortableServer::POAManager_ptr PortableServer::POAManager::_narrow ( CORBA::Object_ptr obj, CORBA::Environment &ACE_TRY_ENV ) { if (CORBA::is_nil (obj)) return PortableServer::POAManager::_nil (); CORBA::Boolean check = !obj->_is_a ("IDL:omg.org/PortableServer/POAManager:1.0", ACE_TRY_ENV); ACE_CHECK_RETURN (PortableServer::POAManager::_nil ()); if (check) return PortableServer::POAManager::_nil (); void* servant = 0; if (!obj->_is_collocated () || !obj->_servant() || (servant = obj->_servant ()->_downcast ("IDL:omg.org/PortableServer/POAManager:1.0")) == 0) // This can only be colocated ACE_THROW_RETURN (CORBA::MARSHAL (), PortableServer::POAManager::_nil ()); PortableServer::POAManager_ptr retval = PortableServer::POAManager::_nil (); ACE_NEW_RETURN ( retval, POA_PortableServer::_tao_collocated_POAManager ( ACE_reinterpret_cast (POA_PortableServer::POAManager_ptr, servant), 0 ), PortableServer::POAManager::_nil () ); return retval; } // default constructor PortableServer::POAManager::AdapterInactive::AdapterInactive (void) : CORBA_UserException (PortableServer::POAManager::_tc_AdapterInactive) { } // destructor - all members are of self managing types PortableServer::POAManager::AdapterInactive::~AdapterInactive (void) { } // copy constructor PortableServer::POAManager::AdapterInactive::AdapterInactive (const PortableServer::POAManager::AdapterInactive &_tao_excp) : CORBA_UserException (_tao_excp._type ()) { } // assignment operator PortableServer::POAManager::AdapterInactive& PortableServer::POAManager::AdapterInactive::operator= (const PortableServer::POAManager::AdapterInactive &_tao_excp) { this->CORBA_UserException::operator= (_tao_excp); return *this; } void PortableServer::POAManager::AdapterInactive::_raise (void) { TAO_RAISE(*this); } void PortableServer::POAManager::AdapterInactive::_tao_encode (TAO_OutputCDR &cdr, CORBA::Environment &ACE_TRY_ENV) const { if (cdr << *this) return; ACE_THROW (CORBA::MARSHAL ()); } void PortableServer::POAManager::AdapterInactive::_tao_decode (TAO_InputCDR &cdr, CORBA::Environment &ACE_TRY_ENV) { if (cdr >> *this) return; ACE_THROW (CORBA::MARSHAL ()); } // narrow PortableServer::POAManager::AdapterInactive_ptr PortableServer::POAManager::AdapterInactive::_narrow (CORBA::Exception *exc) { if (!ACE_OS::strcmp ("IDL:omg.org/PortableServer/POAManager/AdapterInactive:1.0", exc->_id ())) // same type return ACE_dynamic_cast (PortableServer::POAManager::AdapterInactive_ptr, 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; } static const CORBA::Long _oc_PortableServer_POAManager_AdapterInactive[] = { TAO_ENCAP_BYTE_ORDER, // byte order 58, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f50), ACE_NTOHL (0x4f414d61), ACE_NTOHL (0x6e616765), ACE_NTOHL (0x722f4164), ACE_NTOHL (0x61707465), ACE_NTOHL (0x72496e61), ACE_NTOHL (0x63746976), ACE_NTOHL (0x653a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/PortableServer/POAManager/AdapterInactive:1.0 16, ACE_NTOHL (0x41646170), ACE_NTOHL (0x74657249), ACE_NTOHL (0x6e616374), ACE_NTOHL (0x69766500), // name = AdapterInactive 0, // member count }; static CORBA::TypeCode _tc_TAO_tc_PortableServer_POAManager_AdapterInactive (CORBA::tk_except, sizeof (_oc_PortableServer_POAManager_AdapterInactive), (char *) &_oc_PortableServer_POAManager_AdapterInactive, 0, sizeof (PortableServer::POAManager::AdapterInactive)); CORBA::TypeCode_ptr PortableServer::POAManager::_tc_AdapterInactive = &_tc_TAO_tc_PortableServer_POAManager_AdapterInactive; CORBA::Boolean PortableServer::POAManager::_is_a (const CORBA::Char *value, CORBA::Environment &_tao_environment) { if ( (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/PortableServer/POAManager:1.0")) || (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (_tao_environment)))) return 1; // success using local knowledge else return this->CORBA_Object::_is_a (value, _tao_environment); // remote call } const char* PortableServer::POAManager::_interface_repository_id (void) const { return "IDL:omg.org/PortableServer/POAManager:1.0"; } static const CORBA::Long _oc_PortableServer_POAManager[] = { TAO_ENCAP_BYTE_ORDER, // byte order 42, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f50), ACE_NTOHL (0x4f414d61), ACE_NTOHL (0x6e616765), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/PortableServer/POAManager:1.0 11, ACE_NTOHL (0x504f414d), ACE_NTOHL (0x616e6167), ACE_NTOHL (0x65720000), // name = POAManager, }; static CORBA::TypeCode _tc_TAO_tc_PortableServer_POAManager (CORBA::tk_objref, sizeof (_oc_PortableServer_POAManager), (char *) &_oc_PortableServer_POAManager, 0, sizeof (PortableServer::POAManager)); TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) TAO_NAMESPACE_BEGIN (PortableServer) TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_POAManager, &_tc_TAO_tc_PortableServer_POAManager) TAO_NAMESPACE_END #if (TAO_HAS_MINIMUM_POA == 0) PortableServer::AdapterActivator_ptr PortableServer::AdapterActivator::_duplicate (PortableServer::AdapterActivator_ptr obj) { if (!CORBA::is_nil (obj)) obj->_incr_refcnt (); return obj; } // end of _duplicate PortableServer::AdapterActivator_ptr PortableServer::AdapterActivator::_narrow ( CORBA::Object_ptr obj, CORBA::Environment &ACE_TRY_ENV ) { if (CORBA::is_nil (obj)) return PortableServer::AdapterActivator::_nil (); CORBA::Boolean check = !obj->_is_a ("IDL:omg.org/PortableServer/AdapterActivator:1.0", ACE_TRY_ENV); ACE_CHECK_RETURN (PortableServer::AdapterActivator::_nil ()); if (check) return PortableServer::AdapterActivator::_nil (); void *servant = 0; if (!obj->_is_collocated () || !obj->_servant() || (servant = obj->_servant ()->_downcast ("IDL:omg.org/PortableServer/AdapterActivator:1.0")) == 0) // This can only be colocated ACE_THROW_RETURN (CORBA::MARSHAL (), PortableServer::AdapterActivator::_nil ()); PortableServer::AdapterActivator_ptr retval = PortableServer::AdapterActivator::_nil (); ACE_NEW_RETURN ( retval, POA_PortableServer::_tao_collocated_AdapterActivator ( ACE_reinterpret_cast (POA_PortableServer::AdapterActivator_ptr, servant), 0 ), PortableServer::AdapterActivator::_nil () ); return retval; } CORBA::Boolean PortableServer::AdapterActivator::_is_a (const CORBA::Char *value, CORBA::Environment &_tao_environment) { if ( (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/PortableServer/AdapterActivator:1.0")) || (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (_tao_environment)))) return 1; // success using local knowledge else return this->CORBA_Object::_is_a (value, _tao_environment); // remote call } const char* PortableServer::AdapterActivator::_interface_repository_id (void) const { return "IDL:omg.org/PortableServer/AdapterActivator:1.0"; } static const CORBA::Long _oc_PortableServer_AdapterActivator[] = { TAO_ENCAP_BYTE_ORDER, // byte order 48, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f41), ACE_NTOHL (0x64617074), ACE_NTOHL (0x65724163), ACE_NTOHL (0x74697661), ACE_NTOHL (0x746f723a), ACE_NTOHL (0x312e3000), // repository ID = IDL:omg.org/PortableServer/AdapterActivator:1.0 17, ACE_NTOHL (0x41646170), ACE_NTOHL (0x74657241), ACE_NTOHL (0x63746976), ACE_NTOHL (0x61746f72), ACE_NTOHL (0x0), // name = AdapterActivator, }; static CORBA::TypeCode _tc_TAO_tc_PortableServer_AdapterActivator (CORBA::tk_objref, sizeof (_oc_PortableServer_AdapterActivator), (char *) &_oc_PortableServer_AdapterActivator, 0, sizeof (PortableServer::AdapterActivator)); TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) TAO_NAMESPACE_BEGIN (PortableServer) TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_AdapterActivator, &_tc_TAO_tc_PortableServer_AdapterActivator) TAO_NAMESPACE_END PortableServer::ServantManager_ptr PortableServer::ServantManager::_duplicate (PortableServer::ServantManager_ptr obj) { if (!CORBA::is_nil (obj)) obj->_incr_refcnt (); return obj; } // end of _duplicate PortableServer::ServantManager_ptr PortableServer::ServantManager::_narrow ( CORBA::Object_ptr obj, CORBA::Environment &ACE_TRY_ENV ) { if (CORBA::is_nil (obj)) return PortableServer::ServantManager::_nil (); CORBA::Boolean check = !obj->_is_a ("IDL:omg.org/PortableServer/ServantManager:1.0", ACE_TRY_ENV); ACE_CHECK_RETURN (PortableServer::ServantManager::_nil ()); if (check) return PortableServer::ServantManager::_nil (); void *servant = 0; if (!obj->_is_collocated () || !obj->_servant() || (servant = obj->_servant ()->_downcast ("IDL:omg.org/PortableServer/ServantManager:1.0")) == 0) // This can only be colocated ACE_THROW_RETURN (CORBA::MARSHAL (), PortableServer::ServantManager::_nil ()); PortableServer::ServantManager_ptr retval = PortableServer::ServantManager::_nil (); ACE_NEW_RETURN ( retval, POA_PortableServer::_tao_collocated_ServantManager ( ACE_reinterpret_cast (POA_PortableServer::ServantManager_ptr, servant), 0 ), PortableServer::ServantManager::_nil () ); return retval; } CORBA::Boolean PortableServer::ServantManager::_is_a (const CORBA::Char *value, CORBA::Environment &_tao_environment) { if ( (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/PortableServer/ServantManager:1.0")) || (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (_tao_environment)))) return 1; // success using local knowledge else return this->CORBA_Object::_is_a (value, _tao_environment); // remote call } const char* PortableServer::ServantManager::_interface_repository_id (void) const { return "IDL:omg.org/PortableServer/ServantManager:1.0"; } static const CORBA::Long _oc_PortableServer_ServantManager[] = { TAO_ENCAP_BYTE_ORDER, // byte order 46, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f53), ACE_NTOHL (0x65727661), ACE_NTOHL (0x6e744d61), ACE_NTOHL (0x6e616765), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/PortableServer/ServantManager:1.0 15, ACE_NTOHL (0x53657276), ACE_NTOHL (0x616e744d), ACE_NTOHL (0x616e6167), ACE_NTOHL (0x65720000), // name = ServantManager, }; static CORBA::TypeCode _tc_TAO_tc_PortableServer_ServantManager (CORBA::tk_objref, sizeof (_oc_PortableServer_ServantManager), (char *) &_oc_PortableServer_ServantManager, 0, sizeof (PortableServer::ServantManager)); TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) TAO_NAMESPACE_BEGIN (PortableServer) TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ServantManager, &_tc_TAO_tc_PortableServer_ServantManager) TAO_NAMESPACE_END PortableServer::ServantActivator_ptr PortableServer::ServantActivator::_duplicate (PortableServer::ServantActivator_ptr obj) { if (!CORBA::is_nil (obj)) obj->_incr_refcnt (); return obj; } // end of _duplicate PortableServer::ServantActivator_ptr PortableServer::ServantActivator::_narrow ( CORBA::Object_ptr obj, CORBA::Environment &ACE_TRY_ENV ) { if (CORBA::is_nil (obj)) return PortableServer::ServantActivator::_nil (); CORBA::Boolean check = !obj->_is_a ("IDL:omg.org/PortableServer/ServantActivator:1.0", ACE_TRY_ENV); ACE_CHECK_RETURN (PortableServer::ServantActivator::_nil ()); if (check) return PortableServer::ServantActivator::_nil (); void *servant = 0; if (!obj->_is_collocated () || !obj->_servant() || (servant = obj->_servant ()->_downcast ("IDL:omg.org/PortableServer/ServantActivator:1.0")) == 0) // This can only be colocated ACE_THROW_RETURN (CORBA::MARSHAL (), PortableServer::ServantActivator::_nil ()); PortableServer::ServantActivator_ptr retval = PortableServer::ServantActivator::_nil (); ACE_NEW_RETURN ( retval, POA_PortableServer::_tao_collocated_ServantActivator ( ACE_reinterpret_cast (POA_PortableServer::ServantActivator_ptr, servant), 0 ), PortableServer::ServantActivator::_nil () ); return retval; } CORBA::Boolean PortableServer::ServantActivator::_is_a (const CORBA::Char *value, CORBA::Environment &_tao_environment) { if ( (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/PortableServer/ServantActivator:1.0")) || (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/PortableServer/ServantManager:1.0")) || (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (_tao_environment)))) return 1; // success using local knowledge else return this->CORBA_Object::_is_a (value, _tao_environment); // remote call } const char* PortableServer::ServantActivator::_interface_repository_id (void) const { return "IDL:omg.org/PortableServer/ServantActivator:1.0"; } static const CORBA::Long _oc_PortableServer_ServantActivator[] = { TAO_ENCAP_BYTE_ORDER, // byte order 48, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f53), ACE_NTOHL (0x65727661), ACE_NTOHL (0x6e744163), ACE_NTOHL (0x74697661), ACE_NTOHL (0x746f723a), ACE_NTOHL (0x312e3000), // repository ID = IDL:omg.org/PortableServer/ServantActivator:1.0 17, ACE_NTOHL (0x53657276), ACE_NTOHL (0x616e7441), ACE_NTOHL (0x63746976), ACE_NTOHL (0x61746f72), ACE_NTOHL (0x0), // name = ServantActivator, }; static CORBA::TypeCode _tc_TAO_tc_PortableServer_ServantActivator (CORBA::tk_objref, sizeof (_oc_PortableServer_ServantActivator), (char *) &_oc_PortableServer_ServantActivator, 0, sizeof (PortableServer::ServantActivator)); TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) TAO_NAMESPACE_BEGIN (PortableServer) TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ServantActivator, &_tc_TAO_tc_PortableServer_ServantActivator) TAO_NAMESPACE_END PortableServer::ServantLocator_ptr PortableServer::ServantLocator::_duplicate (PortableServer::ServantLocator_ptr obj) { if (!CORBA::is_nil (obj)) obj->_incr_refcnt (); return obj; } // end of _duplicate PortableServer::ServantLocator_ptr PortableServer::ServantLocator::_narrow ( CORBA::Object_ptr obj, CORBA::Environment &ACE_TRY_ENV ) { if (CORBA::is_nil (obj)) return PortableServer::ServantLocator::_nil (); CORBA::Boolean check = !obj->_is_a ("IDL:omg.org/PortableServer/ServantLocator:1.0", ACE_TRY_ENV); ACE_CHECK_RETURN (PortableServer::ServantLocator::_nil ()); if (check) return PortableServer::ServantLocator::_nil (); void *servant = 0; if (!obj->_is_collocated () || !obj->_servant() || (servant = obj->_servant ()->_downcast ("IDL:omg.org/PortableServer/ServantLocator:1.0")) == 0) // This can only be colocated ACE_THROW_RETURN (CORBA::MARSHAL (), PortableServer::ServantLocator::_nil ()); PortableServer::ServantLocator_ptr retval = PortableServer::ServantLocator::_nil (); ACE_NEW_RETURN ( retval, POA_PortableServer::_tao_collocated_ServantLocator ( ACE_reinterpret_cast (POA_PortableServer::ServantLocator_ptr, servant), 0 ), PortableServer::ServantLocator::_nil () ); return retval; } CORBA::Boolean PortableServer::ServantLocator::_is_a (const CORBA::Char *value, CORBA::Environment &_tao_environment) { if ( (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/PortableServer/ServantLocator:1.0")) || (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/PortableServer/ServantManager:1.0")) || (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (_tao_environment)))) return 1; // success using local knowledge else return this->CORBA_Object::_is_a (value, _tao_environment); // remote call } const char* PortableServer::ServantLocator::_interface_repository_id (void) const { return "IDL:omg.org/PortableServer/ServantLocator:1.0"; } static const CORBA::Long _oc_PortableServer_ServantLocator[] = { TAO_ENCAP_BYTE_ORDER, // byte order 46, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f53), ACE_NTOHL (0x65727661), ACE_NTOHL (0x6e744c6f), ACE_NTOHL (0x6361746f), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/PortableServer/ServantLocator:1.0 15, ACE_NTOHL (0x53657276), ACE_NTOHL (0x616e744c), ACE_NTOHL (0x6f636174), ACE_NTOHL (0x6f720000), // name = ServantLocator, }; static CORBA::TypeCode _tc_TAO_tc_PortableServer_ServantLocator (CORBA::tk_objref, sizeof (_oc_PortableServer_ServantLocator), (char *) &_oc_PortableServer_ServantLocator, 0, sizeof (PortableServer::ServantLocator)); TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) TAO_NAMESPACE_BEGIN (PortableServer) TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ServantLocator, &_tc_TAO_tc_PortableServer_ServantLocator) TAO_NAMESPACE_END #endif /* TAO_HAS_MINIMUM_POA == 0 */ PortableServer::POA_ptr PortableServer::POA::_duplicate (PortableServer::POA_ptr obj) { if (!CORBA::is_nil (obj)) obj->_incr_refcnt (); return obj; } // end of _duplicate PortableServer::POA_ptr PortableServer::POA::_narrow ( CORBA::Object_ptr obj, CORBA::Environment &ACE_TRY_ENV ) { if (CORBA::is_nil (obj)) return PortableServer::POA::_nil (); CORBA::Boolean check = !obj->_is_a ("IDL:omg.org/PortableServer/POA:1.0", ACE_TRY_ENV); ACE_CHECK_RETURN (PortableServer::POA::_nil ()); if (check) return PortableServer::POA::_nil (); void *servant = 0; if (!obj->_is_collocated () || !obj->_servant() || (servant = obj->_servant ()->_downcast ("IDL:omg.org/PortableServer/POA:1.0")) == 0) // This can only be colocated ACE_THROW_RETURN (CORBA::MARSHAL (), PortableServer::POA::_nil ()); PortableServer::POA_ptr retval = PortableServer::POA::_nil (); ACE_NEW_RETURN ( retval, POA_PortableServer::_tao_collocated_POA ( ACE_reinterpret_cast (POA_PortableServer::POA_ptr, servant), 0 ), PortableServer::POA::_nil () ); return retval; } // default constructor PortableServer::POA::AdapterAlreadyExists::AdapterAlreadyExists (void) : CORBA_UserException (PortableServer::POA::_tc_AdapterAlreadyExists) { } // 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._type ()) { } // assignment operator PortableServer::POA::AdapterAlreadyExists& PortableServer::POA::AdapterAlreadyExists::operator= (const PortableServer::POA::AdapterAlreadyExists &_tao_excp) { this->CORBA_UserException::operator= (_tao_excp); return *this; } void PortableServer::POA::AdapterAlreadyExists::_raise (void) { TAO_RAISE(*this); } void PortableServer::POA::AdapterAlreadyExists::_tao_encode (TAO_OutputCDR &cdr, CORBA::Environment &ACE_TRY_ENV) const { if (cdr << *this) return; ACE_THROW (CORBA::MARSHAL ()); } void PortableServer::POA::AdapterAlreadyExists::_tao_decode (TAO_InputCDR &cdr, CORBA::Environment &ACE_TRY_ENV) { if (cdr >> *this) return; ACE_THROW (CORBA::MARSHAL ()); } // narrow PortableServer::POA::AdapterAlreadyExists_ptr PortableServer::POA::AdapterAlreadyExists::_narrow (CORBA::Exception *exc) { if (!ACE_OS::strcmp ("IDL:omg.org/PortableServer/POA/AdapterAlreadyExists:1.0", exc->_id ())) // same type return ACE_dynamic_cast (PortableServer::POA::AdapterAlreadyExists_ptr, exc); else return 0; } // 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; } static const CORBA::Long _oc_PortableServer_POA_AdapterAlreadyExists[] = { TAO_ENCAP_BYTE_ORDER, // byte order 56, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f50), ACE_NTOHL (0x4f412f41), ACE_NTOHL (0x64617074), ACE_NTOHL (0x6572416c), ACE_NTOHL (0x72656164), ACE_NTOHL (0x79457869), ACE_NTOHL (0x7374733a), ACE_NTOHL (0x312e3000), // repository ID = IDL:omg.org/PortableServer/POA/AdapterAlreadyExists:1.0 21, ACE_NTOHL (0x41646170), ACE_NTOHL (0x74657241), ACE_NTOHL (0x6c726561), ACE_NTOHL (0x64794578), ACE_NTOHL (0x69737473), ACE_NTOHL (0x0), // name = AdapterAlreadyExists 0, // member count }; static CORBA::TypeCode _tc_TAO_tc_PortableServer_POA_AdapterAlreadyExists (CORBA::tk_except, sizeof (_oc_PortableServer_POA_AdapterAlreadyExists), (char *) &_oc_PortableServer_POA_AdapterAlreadyExists, 0, sizeof (PortableServer::POA::AdapterAlreadyExists)); CORBA::TypeCode_ptr PortableServer::POA::_tc_AdapterAlreadyExists = &_tc_TAO_tc_PortableServer_POA_AdapterAlreadyExists; #if (TAO_HAS_MINIMUM_POA == 0) // default constructor PortableServer::POA::AdapterInactive::AdapterInactive (void) : CORBA_UserException (PortableServer::POA::_tc_AdapterInactive) { } // destructor - all members are of self managing types PortableServer::POA::AdapterInactive::~AdapterInactive (void) { } // copy constructor PortableServer::POA::AdapterInactive::AdapterInactive (const PortableServer::POA::AdapterInactive &_tao_excp) : CORBA_UserException (_tao_excp._type ()) { } // assignment operator PortableServer::POA::AdapterInactive& PortableServer::POA::AdapterInactive::operator= (const PortableServer::POA::AdapterInactive &_tao_excp) { this->CORBA_UserException::operator= (_tao_excp); return *this; } void PortableServer::POA::AdapterInactive::_raise (void) { TAO_RAISE(*this); } void PortableServer::POA::AdapterInactive::_tao_encode (TAO_OutputCDR &cdr, CORBA::Environment &ACE_TRY_ENV) const { if (cdr << *this) return; ACE_THROW (CORBA::MARSHAL ()); } void PortableServer::POA::AdapterInactive::_tao_decode (TAO_InputCDR &cdr, CORBA::Environment &ACE_TRY_ENV) { if (cdr >> *this) return; ACE_THROW (CORBA::MARSHAL ()); } // narrow PortableServer::POA::AdapterInactive_ptr PortableServer::POA::AdapterInactive::_narrow (CORBA::Exception *exc) { if (!ACE_OS::strcmp ("IDL:omg.org/PortableServer/POA/AdapterInactive:1.0", exc->_id ())) // same type return ACE_dynamic_cast (PortableServer::POA::AdapterInactive_ptr, exc); else return 0; } // TAO extension - the _alloc method CORBA::Exception *PortableServer::POA::AdapterInactive::_alloc (void) { CORBA::Exception *retval = 0; ACE_NEW_RETURN (retval, PortableServer::POA::AdapterInactive, 0); return retval; } static const CORBA::Long _oc_PortableServer_POA_AdapterInactive[] = { TAO_ENCAP_BYTE_ORDER, // byte order 51, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f50), ACE_NTOHL (0x4f412f41), ACE_NTOHL (0x64617074), ACE_NTOHL (0x6572496e), ACE_NTOHL (0x61637469), ACE_NTOHL (0x76653a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/PortableServer/POA/AdapterInactive:1.0 16, ACE_NTOHL (0x41646170), ACE_NTOHL (0x74657249), ACE_NTOHL (0x6e616374), ACE_NTOHL (0x69766500), // name = AdapterInactive 0, // member count }; static CORBA::TypeCode _tc_TAO_tc_PortableServer_POA_AdapterInactive (CORBA::tk_except, sizeof (_oc_PortableServer_POA_AdapterInactive), (char *) &_oc_PortableServer_POA_AdapterInactive, 0, sizeof (PortableServer::POA::AdapterInactive)); CORBA::TypeCode_ptr PortableServer::POA::_tc_AdapterInactive = &_tc_TAO_tc_PortableServer_POA_AdapterInactive; #endif /* TAO_HAS_MINIMUM_POA == 0 */ // default constructor PortableServer::POA::AdapterNonExistent::AdapterNonExistent (void) : CORBA_UserException (PortableServer::POA::_tc_AdapterNonExistent) { } // 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._type ()) { } // assignment operator PortableServer::POA::AdapterNonExistent& PortableServer::POA::AdapterNonExistent::operator= (const PortableServer::POA::AdapterNonExistent &_tao_excp) { this->CORBA_UserException::operator= (_tao_excp); return *this; } void PortableServer::POA::AdapterNonExistent::_raise (void) { TAO_RAISE(*this); } void PortableServer::POA::AdapterNonExistent::_tao_encode (TAO_OutputCDR &cdr, CORBA::Environment &ACE_TRY_ENV) const { if (cdr << *this) return; ACE_THROW (CORBA::MARSHAL ()); } void PortableServer::POA::AdapterNonExistent::_tao_decode (TAO_InputCDR &cdr, CORBA::Environment &ACE_TRY_ENV) { if (cdr >> *this) return; ACE_THROW (CORBA::MARSHAL ()); } // narrow PortableServer::POA::AdapterNonExistent_ptr PortableServer::POA::AdapterNonExistent::_narrow (CORBA::Exception *exc) { if (!ACE_OS::strcmp ("IDL:omg.org/PortableServer/POA/AdapterNonExistent:1.0", exc->_id ())) // same type return ACE_dynamic_cast (PortableServer::POA::AdapterNonExistent_ptr, exc); else return 0; } // 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; } static const CORBA::Long _oc_PortableServer_POA_AdapterNonExistent[] = { TAO_ENCAP_BYTE_ORDER, // byte order 54, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f50), ACE_NTOHL (0x4f412f41), ACE_NTOHL (0x64617074), ACE_NTOHL (0x65724e6f), ACE_NTOHL (0x6e457869), ACE_NTOHL (0x7374656e), ACE_NTOHL (0x743a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/PortableServer/POA/AdapterNonExistent:1.0 19, ACE_NTOHL (0x41646170), ACE_NTOHL (0x7465724e), ACE_NTOHL (0x6f6e4578), ACE_NTOHL (0x69737465), ACE_NTOHL (0x6e740000), // name = AdapterNonExistent 0, // member count }; static CORBA::TypeCode _tc_TAO_tc_PortableServer_POA_AdapterNonExistent (CORBA::tk_except, sizeof (_oc_PortableServer_POA_AdapterNonExistent), (char *) &_oc_PortableServer_POA_AdapterNonExistent, 0, sizeof (PortableServer::POA::AdapterNonExistent)); CORBA::TypeCode_ptr PortableServer::POA::_tc_AdapterNonExistent = &_tc_TAO_tc_PortableServer_POA_AdapterNonExistent; // default constructor PortableServer::POA::InvalidPolicy::InvalidPolicy (void) : CORBA_UserException (PortableServer::POA::_tc_InvalidPolicy) { } // 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._type ()) { 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; } PortableServer::POA::InvalidPolicy::InvalidPolicy( CORBA::UShort _tao_index) : CORBA_UserException (PortableServer::POA::_tc_InvalidPolicy) { this->index = _tao_index; } void PortableServer::POA::InvalidPolicy::_raise (void) { TAO_RAISE(*this); } void PortableServer::POA::InvalidPolicy::_tao_encode (TAO_OutputCDR &cdr, CORBA::Environment &ACE_TRY_ENV) const { if (cdr << *this) return; ACE_THROW (CORBA::MARSHAL ()); } void PortableServer::POA::InvalidPolicy::_tao_decode (TAO_InputCDR &cdr, CORBA::Environment &ACE_TRY_ENV) { if (cdr >> *this) return; ACE_THROW (CORBA::MARSHAL ()); } // narrow PortableServer::POA::InvalidPolicy_ptr PortableServer::POA::InvalidPolicy::_narrow (CORBA::Exception *exc) { if (!ACE_OS::strcmp ("IDL:omg.org/PortableServer/POA/InvalidPolicy:1.0", exc->_id ())) // same type return ACE_dynamic_cast (PortableServer::POA::InvalidPolicy_ptr, exc); else return 0; } // 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; } static const CORBA::Long _oc_PortableServer_POA_InvalidPolicy[] = { TAO_ENCAP_BYTE_ORDER, // byte order 49, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f50), ACE_NTOHL (0x4f412f49), ACE_NTOHL (0x6e76616c), ACE_NTOHL (0x6964506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:omg.org/PortableServer/POA/InvalidPolicy:1.0 14, ACE_NTOHL (0x496e7661), ACE_NTOHL (0x6c696450), ACE_NTOHL (0x6f6c6963), ACE_NTOHL (0x79000000), // name = InvalidPolicy 1, // member count 6, ACE_NTOHL (0x696e6465), ACE_NTOHL (0x78000000), // name = index CORBA::tk_ushort, }; static CORBA::TypeCode _tc_TAO_tc_PortableServer_POA_InvalidPolicy (CORBA::tk_except, sizeof (_oc_PortableServer_POA_InvalidPolicy), (char *) &_oc_PortableServer_POA_InvalidPolicy, 0, sizeof (PortableServer::POA::InvalidPolicy)); CORBA::TypeCode_ptr PortableServer::POA::_tc_InvalidPolicy = &_tc_TAO_tc_PortableServer_POA_InvalidPolicy; #if (TAO_HAS_MINIMUM_POA == 0) // default constructor PortableServer::POA::NoServant::NoServant (void) : CORBA_UserException (PortableServer::POA::_tc_NoServant) { } // 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._type ()) { } // assignment operator PortableServer::POA::NoServant& PortableServer::POA::NoServant::operator= (const PortableServer::POA::NoServant &_tao_excp) { this->CORBA_UserException::operator= (_tao_excp); return *this; } void PortableServer::POA::NoServant::_raise (void) { TAO_RAISE(*this); } void PortableServer::POA::NoServant::_tao_encode (TAO_OutputCDR &cdr, CORBA::Environment &ACE_TRY_ENV) const { if (cdr << *this) return; ACE_THROW (CORBA::MARSHAL ()); } void PortableServer::POA::NoServant::_tao_decode (TAO_InputCDR &cdr, CORBA::Environment &ACE_TRY_ENV) { if (cdr >> *this) return; ACE_THROW (CORBA::MARSHAL ()); } // narrow PortableServer::POA::NoServant_ptr PortableServer::POA::NoServant::_narrow (CORBA::Exception *exc) { if (!ACE_OS::strcmp ("IDL:omg.org/PortableServer/POA/NoServant:1.0", exc->_id ())) // same type return ACE_dynamic_cast (PortableServer::POA::NoServant_ptr, exc); else return 0; } // 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; } static const CORBA::Long _oc_PortableServer_POA_NoServant[] = { TAO_ENCAP_BYTE_ORDER, // byte order 45, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f50), ACE_NTOHL (0x4f412f4e), ACE_NTOHL (0x6f536572), ACE_NTOHL (0x76616e74), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:omg.org/PortableServer/POA/NoServant:1.0 10, ACE_NTOHL (0x4e6f5365), ACE_NTOHL (0x7276616e), ACE_NTOHL (0x74000000), // name = NoServant 0, // member count }; static CORBA::TypeCode _tc_TAO_tc_PortableServer_POA_NoServant (CORBA::tk_except, sizeof (_oc_PortableServer_POA_NoServant), (char *) &_oc_PortableServer_POA_NoServant, 0, sizeof (PortableServer::POA::NoServant)); CORBA::TypeCode_ptr PortableServer::POA::_tc_NoServant = &_tc_TAO_tc_PortableServer_POA_NoServant; #endif /* TAO_HAS_MINIMUM_POA == 0 */ // default constructor PortableServer::POA::ObjectAlreadyActive::ObjectAlreadyActive (void) : CORBA_UserException (PortableServer::POA::_tc_ObjectAlreadyActive) { } // 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._type ()) { } // assignment operator PortableServer::POA::ObjectAlreadyActive& PortableServer::POA::ObjectAlreadyActive::operator= (const PortableServer::POA::ObjectAlreadyActive &_tao_excp) { this->CORBA_UserException::operator= (_tao_excp); return *this; } void PortableServer::POA::ObjectAlreadyActive::_raise (void) { TAO_RAISE(*this); } void PortableServer::POA::ObjectAlreadyActive::_tao_encode (TAO_OutputCDR &cdr, CORBA::Environment &ACE_TRY_ENV) const { if (cdr << *this) return; ACE_THROW (CORBA::MARSHAL ()); } void PortableServer::POA::ObjectAlreadyActive::_tao_decode (TAO_InputCDR &cdr, CORBA::Environment &ACE_TRY_ENV) { if (cdr >> *this) return; ACE_THROW (CORBA::MARSHAL ()); } // narrow PortableServer::POA::ObjectAlreadyActive_ptr PortableServer::POA::ObjectAlreadyActive::_narrow (CORBA::Exception *exc) { if (!ACE_OS::strcmp ("IDL:omg.org/PortableServer/POA/ObjectAlreadyActive:1.0", exc->_id ())) // same type return ACE_dynamic_cast (PortableServer::POA::ObjectAlreadyActive_ptr, exc); else return 0; } // 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; } static const CORBA::Long _oc_PortableServer_POA_ObjectAlreadyActive[] = { TAO_ENCAP_BYTE_ORDER, // byte order 55, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f50), ACE_NTOHL (0x4f412f4f), ACE_NTOHL (0x626a6563), ACE_NTOHL (0x74416c72), ACE_NTOHL (0x65616479), ACE_NTOHL (0x41637469), ACE_NTOHL (0x76653a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/PortableServer/POA/ObjectAlreadyActive:1.0 20, ACE_NTOHL (0x4f626a65), ACE_NTOHL (0x6374416c), ACE_NTOHL (0x72656164), ACE_NTOHL (0x79416374), ACE_NTOHL (0x69766500), // name = ObjectAlreadyActive 0, // member count }; static CORBA::TypeCode _tc_TAO_tc_PortableServer_POA_ObjectAlreadyActive (CORBA::tk_except, sizeof (_oc_PortableServer_POA_ObjectAlreadyActive), (char *) &_oc_PortableServer_POA_ObjectAlreadyActive, 0, sizeof (PortableServer::POA::ObjectAlreadyActive)); CORBA::TypeCode_ptr PortableServer::POA::_tc_ObjectAlreadyActive = &_tc_TAO_tc_PortableServer_POA_ObjectAlreadyActive; // default constructor PortableServer::POA::ObjectNotActive::ObjectNotActive (void) : CORBA_UserException (PortableServer::POA::_tc_ObjectNotActive) { } // 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._type ()) { } // assignment operator PortableServer::POA::ObjectNotActive& PortableServer::POA::ObjectNotActive::operator= (const PortableServer::POA::ObjectNotActive &_tao_excp) { this->CORBA_UserException::operator= (_tao_excp); return *this; } void PortableServer::POA::ObjectNotActive::_raise (void) { TAO_RAISE(*this); } void PortableServer::POA::ObjectNotActive::_tao_encode (TAO_OutputCDR &cdr, CORBA::Environment &ACE_TRY_ENV) const { if (cdr << *this) return; ACE_THROW (CORBA::MARSHAL ()); } void PortableServer::POA::ObjectNotActive::_tao_decode (TAO_InputCDR &cdr, CORBA::Environment &ACE_TRY_ENV) { if (cdr >> *this) return; ACE_THROW (CORBA::MARSHAL ()); } // narrow PortableServer::POA::ObjectNotActive_ptr PortableServer::POA::ObjectNotActive::_narrow (CORBA::Exception *exc) { if (!ACE_OS::strcmp ("IDL:omg.org/PortableServer/POA/ObjectNotActive:1.0", exc->_id ())) // same type return ACE_dynamic_cast (PortableServer::POA::ObjectNotActive_ptr, exc); else return 0; } // 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; } static const CORBA::Long _oc_PortableServer_POA_ObjectNotActive[] = { TAO_ENCAP_BYTE_ORDER, // byte order 51, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f50), ACE_NTOHL (0x4f412f4f), ACE_NTOHL (0x626a6563), ACE_NTOHL (0x744e6f74), ACE_NTOHL (0x41637469), ACE_NTOHL (0x76653a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/PortableServer/POA/ObjectNotActive:1.0 16, ACE_NTOHL (0x4f626a65), ACE_NTOHL (0x63744e6f), ACE_NTOHL (0x74416374), ACE_NTOHL (0x69766500), // name = ObjectNotActive 0, // member count }; static CORBA::TypeCode _tc_TAO_tc_PortableServer_POA_ObjectNotActive (CORBA::tk_except, sizeof (_oc_PortableServer_POA_ObjectNotActive), (char *) &_oc_PortableServer_POA_ObjectNotActive, 0, sizeof (PortableServer::POA::ObjectNotActive)); CORBA::TypeCode_ptr PortableServer::POA::_tc_ObjectNotActive = &_tc_TAO_tc_PortableServer_POA_ObjectNotActive; // default constructor PortableServer::POA::ServantAlreadyActive::ServantAlreadyActive (void) : CORBA_UserException (PortableServer::POA::_tc_ServantAlreadyActive) { } // 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._type ()) { } // assignment operator PortableServer::POA::ServantAlreadyActive& PortableServer::POA::ServantAlreadyActive::operator= (const PortableServer::POA::ServantAlreadyActive &_tao_excp) { this->CORBA_UserException::operator= (_tao_excp); return *this; } void PortableServer::POA::ServantAlreadyActive::_raise (void) { TAO_RAISE(*this); } void PortableServer::POA::ServantAlreadyActive::_tao_encode (TAO_OutputCDR &cdr, CORBA::Environment &ACE_TRY_ENV) const { if (cdr << *this) return; ACE_THROW (CORBA::MARSHAL ()); } void PortableServer::POA::ServantAlreadyActive::_tao_decode (TAO_InputCDR &cdr, CORBA::Environment &ACE_TRY_ENV) { if (cdr >> *this) return; ACE_THROW (CORBA::MARSHAL ()); } // narrow PortableServer::POA::ServantAlreadyActive_ptr PortableServer::POA::ServantAlreadyActive::_narrow (CORBA::Exception *exc) { if (!ACE_OS::strcmp ("IDL:omg.org/PortableServer/POA/ServantAlreadyActive:1.0", exc->_id ())) // same type return ACE_dynamic_cast (PortableServer::POA::ServantAlreadyActive_ptr, exc); else return 0; } // 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; } static const CORBA::Long _oc_PortableServer_POA_ServantAlreadyActive[] = { TAO_ENCAP_BYTE_ORDER, // byte order 56, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f50), ACE_NTOHL (0x4f412f53), ACE_NTOHL (0x65727661), ACE_NTOHL (0x6e74416c), ACE_NTOHL (0x72656164), ACE_NTOHL (0x79416374), ACE_NTOHL (0x6976653a), ACE_NTOHL (0x312e3000), // repository ID = IDL:omg.org/PortableServer/POA/ServantAlreadyActive:1.0 21, ACE_NTOHL (0x53657276), ACE_NTOHL (0x616e7441), ACE_NTOHL (0x6c726561), ACE_NTOHL (0x64794163), ACE_NTOHL (0x74697665), ACE_NTOHL (0x0), // name = ServantAlreadyActive 0, // member count }; static CORBA::TypeCode _tc_TAO_tc_PortableServer_POA_ServantAlreadyActive (CORBA::tk_except, sizeof (_oc_PortableServer_POA_ServantAlreadyActive), (char *) &_oc_PortableServer_POA_ServantAlreadyActive, 0, sizeof (PortableServer::POA::ServantAlreadyActive)); CORBA::TypeCode_ptr PortableServer::POA::_tc_ServantAlreadyActive = &_tc_TAO_tc_PortableServer_POA_ServantAlreadyActive; // default constructor PortableServer::POA::ServantNotActive::ServantNotActive (void) : CORBA_UserException (PortableServer::POA::_tc_ServantNotActive) { } // 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._type ()) { } // assignment operator PortableServer::POA::ServantNotActive& PortableServer::POA::ServantNotActive::operator= (const PortableServer::POA::ServantNotActive &_tao_excp) { this->CORBA_UserException::operator= (_tao_excp); return *this; } void PortableServer::POA::ServantNotActive::_raise (void) { TAO_RAISE(*this); } void PortableServer::POA::ServantNotActive::_tao_encode (TAO_OutputCDR &cdr, CORBA::Environment &ACE_TRY_ENV) const { if (cdr << *this) return; ACE_THROW (CORBA::MARSHAL ()); } void PortableServer::POA::ServantNotActive::_tao_decode (TAO_InputCDR &cdr, CORBA::Environment &ACE_TRY_ENV) { if (cdr >> *this) return; ACE_THROW (CORBA::MARSHAL ()); } // narrow PortableServer::POA::ServantNotActive_ptr PortableServer::POA::ServantNotActive::_narrow (CORBA::Exception *exc) { if (!ACE_OS::strcmp ("IDL:omg.org/PortableServer/POA/ServantNotActive:1.0", exc->_id ())) // same type return ACE_dynamic_cast (PortableServer::POA::ServantNotActive_ptr, exc); else return 0; } // 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; } static const CORBA::Long _oc_PortableServer_POA_ServantNotActive[] = { TAO_ENCAP_BYTE_ORDER, // byte order 52, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f50), ACE_NTOHL (0x4f412f53), ACE_NTOHL (0x65727661), ACE_NTOHL (0x6e744e6f), ACE_NTOHL (0x74416374), ACE_NTOHL (0x6976653a), ACE_NTOHL (0x312e3000), // repository ID = IDL:omg.org/PortableServer/POA/ServantNotActive:1.0 17, ACE_NTOHL (0x53657276), ACE_NTOHL (0x616e744e), ACE_NTOHL (0x6f744163), ACE_NTOHL (0x74697665), ACE_NTOHL (0x0), // name = ServantNotActive 0, // member count }; static CORBA::TypeCode _tc_TAO_tc_PortableServer_POA_ServantNotActive (CORBA::tk_except, sizeof (_oc_PortableServer_POA_ServantNotActive), (char *) &_oc_PortableServer_POA_ServantNotActive, 0, sizeof (PortableServer::POA::ServantNotActive)); CORBA::TypeCode_ptr PortableServer::POA::_tc_ServantNotActive = &_tc_TAO_tc_PortableServer_POA_ServantNotActive; // default constructor PortableServer::POA::WrongAdapter::WrongAdapter (void) : CORBA_UserException (PortableServer::POA::_tc_WrongAdapter) { } // 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._type ()) { } // assignment operator PortableServer::POA::WrongAdapter& PortableServer::POA::WrongAdapter::operator= (const PortableServer::POA::WrongAdapter &_tao_excp) { this->CORBA_UserException::operator= (_tao_excp); return *this; } void PortableServer::POA::WrongAdapter::_raise (void) { TAO_RAISE(*this); } void PortableServer::POA::WrongAdapter::_tao_encode (TAO_OutputCDR &cdr, CORBA::Environment &ACE_TRY_ENV) const { if (cdr << *this) return; ACE_THROW (CORBA::MARSHAL ()); } void PortableServer::POA::WrongAdapter::_tao_decode (TAO_InputCDR &cdr, CORBA::Environment &ACE_TRY_ENV) { if (cdr >> *this) return; ACE_THROW (CORBA::MARSHAL ()); } // narrow PortableServer::POA::WrongAdapter_ptr PortableServer::POA::WrongAdapter::_narrow (CORBA::Exception *exc) { if (!ACE_OS::strcmp ("IDL:omg.org/PortableServer/POA/WrongAdapter:1.0", exc->_id ())) // same type return ACE_dynamic_cast (PortableServer::POA::WrongAdapter_ptr, exc); else return 0; } // 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; } static const CORBA::Long _oc_PortableServer_POA_WrongAdapter[] = { TAO_ENCAP_BYTE_ORDER, // byte order 48, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f50), ACE_NTOHL (0x4f412f57), ACE_NTOHL (0x726f6e67), ACE_NTOHL (0x41646170), ACE_NTOHL (0x7465723a), ACE_NTOHL (0x312e3000), // repository ID = IDL:omg.org/PortableServer/POA/WrongAdapter:1.0 13, ACE_NTOHL (0x57726f6e), ACE_NTOHL (0x67416461), ACE_NTOHL (0x70746572), ACE_NTOHL (0x0), // name = WrongAdapter 0, // member count }; static CORBA::TypeCode _tc_TAO_tc_PortableServer_POA_WrongAdapter (CORBA::tk_except, sizeof (_oc_PortableServer_POA_WrongAdapter), (char *) &_oc_PortableServer_POA_WrongAdapter, 0, sizeof (PortableServer::POA::WrongAdapter)); CORBA::TypeCode_ptr PortableServer::POA::_tc_WrongAdapter = &_tc_TAO_tc_PortableServer_POA_WrongAdapter; // default constructor PortableServer::POA::WrongPolicy::WrongPolicy (void) : CORBA_UserException (PortableServer::POA::_tc_WrongPolicy) { } // 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._type ()) { } // assignment operator PortableServer::POA::WrongPolicy& PortableServer::POA::WrongPolicy::operator= (const PortableServer::POA::WrongPolicy &_tao_excp) { this->CORBA_UserException::operator= (_tao_excp); return *this; } void PortableServer::POA::WrongPolicy::_raise (void) { TAO_RAISE(*this); } void PortableServer::POA::WrongPolicy::_tao_encode (TAO_OutputCDR &cdr, CORBA::Environment &ACE_TRY_ENV) const { if (cdr << *this) return; ACE_THROW (CORBA::MARSHAL ()); } void PortableServer::POA::WrongPolicy::_tao_decode (TAO_InputCDR &cdr, CORBA::Environment &ACE_TRY_ENV) { if (cdr >> *this) return; ACE_THROW (CORBA::MARSHAL ()); } // narrow PortableServer::POA::WrongPolicy_ptr PortableServer::POA::WrongPolicy::_narrow (CORBA::Exception *exc) { if (!ACE_OS::strcmp ("IDL:omg.org/PortableServer/POA/WrongPolicy:1.0", exc->_id ())) // same type return ACE_dynamic_cast (PortableServer::POA::WrongPolicy_ptr, exc); else return 0; } // 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; } static const CORBA::Long _oc_PortableServer_POA_WrongPolicy[] = { TAO_ENCAP_BYTE_ORDER, // byte order 47, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f50), ACE_NTOHL (0x4f412f57), ACE_NTOHL (0x726f6e67), ACE_NTOHL (0x506f6c69), ACE_NTOHL (0x63793a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/PortableServer/POA/WrongPolicy:1.0 12, ACE_NTOHL (0x57726f6e), ACE_NTOHL (0x67506f6c), ACE_NTOHL (0x69637900), // name = WrongPolicy 0, // member count }; static CORBA::TypeCode _tc_TAO_tc_PortableServer_POA_WrongPolicy (CORBA::tk_except, sizeof (_oc_PortableServer_POA_WrongPolicy), (char *) &_oc_PortableServer_POA_WrongPolicy, 0, sizeof (PortableServer::POA::WrongPolicy)); CORBA::TypeCode_ptr PortableServer::POA::_tc_WrongPolicy = &_tc_TAO_tc_PortableServer_POA_WrongPolicy; CORBA::Boolean PortableServer::POA::_is_a (const CORBA::Char *value, CORBA::Environment &_tao_environment) { if ( (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/PortableServer/POA:1.0")) || (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (_tao_environment)))) return 1; // success using local knowledge else return this->CORBA_Object::_is_a (value, _tao_environment); // remote call } const char* PortableServer::POA::_interface_repository_id (void) const { return "IDL:omg.org/PortableServer/POA:1.0"; } static const CORBA::Long _oc_PortableServer_POA[] = { TAO_ENCAP_BYTE_ORDER, // byte order 35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f50), ACE_NTOHL (0x4f413a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/PortableServer/POA:1.0 4, ACE_NTOHL (0x504f4100), // name = POA, }; static CORBA::TypeCode _tc_TAO_tc_PortableServer_POA (CORBA::tk_objref, sizeof (_oc_PortableServer_POA), (char *) &_oc_PortableServer_POA, 0, sizeof (PortableServer::POA)); TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) TAO_NAMESPACE_BEGIN (PortableServer) TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_POA, &_tc_TAO_tc_PortableServer_POA) TAO_NAMESPACE_END PortableServer::Current_ptr PortableServer::Current::_duplicate (PortableServer::Current_ptr obj) { if (!CORBA::is_nil (obj)) obj->_incr_refcnt (); return obj; } // end of _duplicate PortableServer::Current_ptr PortableServer::Current::_narrow ( CORBA::Object_ptr obj, CORBA::Environment &ACE_TRY_ENV ) { if (CORBA::is_nil (obj)) return PortableServer::Current::_nil (); CORBA::Boolean check = !obj->_is_a ("IDL:omg.org/PortableServer/Current:1.0", ACE_TRY_ENV); ACE_CHECK_RETURN (PortableServer::Current::_nil ()); if (check) return PortableServer::Current::_nil (); void *servant = 0; if (!obj->_is_collocated () || !obj->_servant() || (servant = obj->_servant ()->_downcast ("IDL:omg.org/PortableServer/Current:1.0")) == 0) // This can only be colocated ACE_THROW_RETURN (CORBA::MARSHAL (), PortableServer::Current::_nil ()); PortableServer::Current_ptr retval = PortableServer::Current::_nil (); ACE_NEW_RETURN ( retval, POA_PortableServer::_tao_collocated_Current ( ACE_reinterpret_cast (POA_PortableServer::Current_ptr, servant), 0 ), PortableServer::Current::_nil () ); return retval; } // default constructor PortableServer::Current::NoContext::NoContext (void) : CORBA_UserException (PortableServer::Current::_tc_NoContext) { } // 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._type ()) { } // assignment operator PortableServer::Current::NoContext& PortableServer::Current::NoContext::operator= (const PortableServer::Current::NoContext &_tao_excp) { this->CORBA_UserException::operator= (_tao_excp); return *this; } void PortableServer::Current::NoContext::_raise (void) { TAO_RAISE(*this); } void PortableServer::Current::NoContext::_tao_encode (TAO_OutputCDR &cdr, CORBA::Environment &ACE_TRY_ENV) const { if (cdr << *this) return; ACE_THROW (CORBA::MARSHAL ()); } void PortableServer::Current::NoContext::_tao_decode (TAO_InputCDR &cdr, CORBA::Environment &ACE_TRY_ENV) { if (cdr >> *this) return; ACE_THROW (CORBA::MARSHAL ()); } // narrow PortableServer::Current::NoContext_ptr PortableServer::Current::NoContext::_narrow (CORBA::Exception *exc) { if (!ACE_OS::strcmp ("IDL:omg.org/PortableServer/Current/NoContext:1.0", exc->_id ())) // same type return ACE_dynamic_cast (PortableServer::Current::NoContext_ptr, exc); else return 0; } // 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; } static const CORBA::Long _oc_PortableServer_Current_NoContext[] = { TAO_ENCAP_BYTE_ORDER, // byte order 49, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f43), ACE_NTOHL (0x75727265), ACE_NTOHL (0x6e742f4e), ACE_NTOHL (0x6f436f6e), ACE_NTOHL (0x74657874), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:omg.org/PortableServer/Current/NoContext:1.0 10, ACE_NTOHL (0x4e6f436f), ACE_NTOHL (0x6e746578), ACE_NTOHL (0x74000000), // name = NoContext 0, // member count }; static CORBA::TypeCode _tc_TAO_tc_PortableServer_Current_NoContext (CORBA::tk_except, sizeof (_oc_PortableServer_Current_NoContext), (char *) &_oc_PortableServer_Current_NoContext, 0, sizeof (PortableServer::Current::NoContext)); CORBA::TypeCode_ptr PortableServer::Current::_tc_NoContext = &_tc_TAO_tc_PortableServer_Current_NoContext; PortableServer::POA_ptr PortableServer::Current::get_POA (CORBA::Environment &ACE_TRY_ENV) { ACE_THROW_RETURN (CORBA::MARSHAL (), PortableServer::POA::_nil ()); } PortableServer::ObjectId * PortableServer::Current::get_object_id (CORBA::Environment &ACE_TRY_ENV) { // @@ This doesn't look right at all. - nw. static TAO_Exception_Data _tao_PortableServer_Current_get_object_id_exceptiondata [] = { {PortableServer::Current::_tc_NoContext, PortableServer::Current::NoContext::_alloc} }; PortableServer::ObjectId *_tao_retval = 0; TAO_Stub *istub = this->_stubobj (); if (istub == 0) ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval); ACE_NEW_RETURN (_tao_retval, PortableServer::ObjectId, _tao_retval); TAO_GIOP_Twoway_Invocation _tao_call ( istub, "get_object_id", 13, istub->orb_core () ); for (;;) { _tao_call.start (ACE_TRY_ENV); ACE_CHECK_RETURN (_tao_retval); CORBA::Short flag = 131; _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); ACE_CHECK_RETURN (_tao_retval); int _invoke_status = _tao_call.invoke (_tao_PortableServer_Current_get_object_id_exceptiondata, 1, ACE_TRY_ENV); ACE_CHECK_RETURN (_tao_retval); if (_invoke_status == TAO_INVOKE_RESTART) continue; // if (_invoke_status == TAO_INVOKE_EXCEPTION) // cannot happen if (_invoke_status != TAO_INVOKE_OK) { ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval); } break; } TAO_InputCDR &_tao_in = _tao_call.inp_stream (); if (!( (_tao_in >> *_tao_retval) )) ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval); return _tao_retval; } CORBA::Boolean PortableServer::Current::_is_a (const CORBA::Char *value, CORBA::Environment &_tao_environment) { if ( (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/PortableServer/Current:1.0")) || (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Current:1.0")) || (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (_tao_environment)))) return 1; // success using local knowledge else return this->CORBA_Object::_is_a (value, _tao_environment); // remote call } const char* PortableServer::Current::_interface_repository_id (void) const { return "IDL:omg.org/PortableServer/Current:1.0"; } static const CORBA::Long _oc_PortableServer_Current[] = { TAO_ENCAP_BYTE_ORDER, // byte order 31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x506f7274), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x53657276), ACE_NTOHL (0x65722f43), ACE_NTOHL (0x75727265), ACE_NTOHL (0x6e743a31), ACE_NTOHL (0x2e3000fd), // repository ID = IDL:PortableServer/Current:1.0 8, ACE_NTOHL (0x43757272), ACE_NTOHL (0x656e7400), // name = Current, }; static CORBA::TypeCode _tc_TAO_tc_PortableServer_Current (CORBA::tk_objref, sizeof (_oc_PortableServer_Current), (char *) &_oc_PortableServer_Current, 0, sizeof (PortableServer::Current)); TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) TAO_NAMESPACE_BEGIN (PortableServer) TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Current, &_tc_TAO_tc_PortableServer_Current) TAO_NAMESPACE_END 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 { PortableServer::ObjectId *_tao_any_val; ACE_NEW (_tao_any_val, PortableServer::ObjectId (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { TAO_OutputCDR stream; if (stream << *_tao_any_val) { _tao_any._tao_replace ( PortableServer::_tc_ObjectId, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_any_val, ACE_TRY_ENV ); ACE_TRY_CHECK; } else { delete _tao_any_val; } } ACE_CATCHANY { delete _tao_any_val; } ACE_ENDTRY; } void operator<<= (CORBA::Any &_tao_any, PortableServer::ObjectId *_tao_elem) // non copying { ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( PortableServer::_tc_ObjectId, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_elem, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { delete _tao_elem; _tao_elem = 0; } ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ObjectId *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::_tc_ObjectId, ACE_TRY_ENV)) // not equal { _tao_elem = 0; return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (PortableServer::ObjectId *)_tao_any.value (); return 1; } else { ACE_NEW_RETURN (_tao_elem, PortableServer::ObjectId, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); if (stream >> *_tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::_tc_ObjectId, 1, ACE_reinterpret_cast (void *, _tao_elem), ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else { delete _tao_elem; _tao_elem = 0; } } } ACE_CATCHANY { delete _tao_elem; _tao_elem = 0; return 0; } ACE_ENDTRY; return 0; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::ObjectId *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::_tc_ObjectId, ACE_TRY_ENV)) // not equal { _tao_elem = 0; return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (PortableServer::ObjectId *)_tao_any.value (); return 1; } else { ACE_NEW_RETURN (_tao_elem, PortableServer::ObjectId, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); if (stream >> *(PortableServer::ObjectId *)_tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::_tc_ObjectId, 1, ACE_reinterpret_cast (void *, ACE_const_cast (PortableServer::ObjectId *&, _tao_elem)), ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else { delete ACE_const_cast (PortableServer::ObjectId *&, _tao_elem); _tao_elem = 0; } } } ACE_CATCHANY { delete ACE_const_cast (PortableServer::ObjectId *&, _tao_elem); _tao_elem = 0; return 0; } ACE_ENDTRY; return 0; } #if (TAO_HAS_MINIMUM_POA == 0) void operator<<= (CORBA::Any & _tao_any, PortableServer::ThreadPolicyValue _tao_elem) { PortableServer::ThreadPolicyValue *_tao_any_val; ACE_NEW (_tao_any_val, PortableServer::ThreadPolicyValue (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_any_val; _tao_any._tao_replace ( PortableServer::_tc_ThreadPolicyValue, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_any_val, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { // free allocated storage delete _tao_any_val; } ACE_ENDTRY; } 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; } void operator<<= (CORBA::Any &_tao_any, PortableServer::ThreadPolicy_ptr _tao_elem) { CORBA::Object_ptr *_tao_obj_ptr = 0; ACE_TRY_NEW_ENV { ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); *_tao_obj_ptr = PortableServer::ThreadPolicy::_duplicate (_tao_elem); TAO_OutputCDR stream; if (stream << *_tao_obj_ptr) { _tao_any._tao_replace ( PortableServer::_tc_ThreadPolicy, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_obj_ptr, ACE_TRY_ENV ); ACE_TRY_CHECK; } else { delete _tao_obj_ptr; } } ACE_CATCHANY { delete _tao_obj_ptr; } ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ThreadPolicy_ptr &_tao_elem) { CORBA::Object_ptr *tmp = 0; ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = PortableServer::ThreadPolicy::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::_tc_ThreadPolicy, ACE_TRY_ENV)) // not equal { delete tmp; return 0; } ACE_TRY_CHECK; TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); CORBA::Object_var _tao_obj_var; if (stream >> _tao_obj_var.out ()) { _tao_elem = PortableServer::ThreadPolicy::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); ACE_TRY_CHECK; *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::_tc_ThreadPolicy, 1, tmp, ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else // failure { delete tmp; } } ACE_CATCHANY { delete tmp; _tao_elem = PortableServer::ThreadPolicy::_nil (); return 0; } ACE_ENDTRY; _tao_elem = PortableServer::ThreadPolicy::_nil (); return 0; } #endif /* TAO_HAS_MINIMUM_POA == 0 */ void operator<<= (CORBA::Any &_tao_any, PortableServer::LifespanPolicyValue _tao_elem) { PortableServer::LifespanPolicyValue *_tao_any_val; ACE_NEW (_tao_any_val, PortableServer::LifespanPolicyValue (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_any_val; _tao_any._tao_replace ( PortableServer::_tc_LifespanPolicyValue, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_any_val, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { // free allocated storage delete _tao_any_val; } ACE_ENDTRY; } 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; } void operator<<= (CORBA::Any &_tao_any, PortableServer::LifespanPolicy_ptr _tao_elem) { CORBA::Object_ptr *_tao_obj_ptr = 0; ACE_TRY_NEW_ENV { ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); *_tao_obj_ptr = PortableServer::LifespanPolicy::_duplicate (_tao_elem); TAO_OutputCDR stream; if (stream << *_tao_obj_ptr) { _tao_any._tao_replace ( PortableServer::_tc_LifespanPolicy, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_obj_ptr, ACE_TRY_ENV ); ACE_TRY_CHECK; } else { delete _tao_obj_ptr; } } ACE_CATCHANY { delete _tao_obj_ptr; } ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::LifespanPolicy_ptr &_tao_elem) { CORBA::Object_ptr *tmp = 0; ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = PortableServer::LifespanPolicy::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::_tc_LifespanPolicy, ACE_TRY_ENV)) // not equal { delete tmp; return 0; } ACE_TRY_CHECK; TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); CORBA::Object_var _tao_obj_var; if (stream >> _tao_obj_var.out ()) { _tao_elem = PortableServer::LifespanPolicy::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); ACE_TRY_CHECK; *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::_tc_LifespanPolicy, 1, tmp, ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else // failure { delete tmp; } } ACE_CATCHANY { delete tmp; _tao_elem = PortableServer::LifespanPolicy::_nil (); return 0; } ACE_ENDTRY; _tao_elem = PortableServer::LifespanPolicy::_nil (); return 0; } void operator<<= (CORBA::Any &_tao_any, PortableServer::IdUniquenessPolicyValue _tao_elem) { PortableServer::IdUniquenessPolicyValue *_tao_any_val; ACE_NEW (_tao_any_val, PortableServer::IdUniquenessPolicyValue (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_any_val; _tao_any._tao_replace ( PortableServer::_tc_IdUniquenessPolicyValue, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_any_val, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { // free allocated storage delete _tao_any_val; } ACE_ENDTRY; } 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; } void operator<<= (CORBA::Any &_tao_any, PortableServer::IdUniquenessPolicy_ptr _tao_elem) { CORBA::Object_ptr *_tao_obj_ptr = 0; ACE_TRY_NEW_ENV { ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); *_tao_obj_ptr = PortableServer::IdUniquenessPolicy::_duplicate (_tao_elem); TAO_OutputCDR stream; if (stream << *_tao_obj_ptr) { _tao_any._tao_replace ( PortableServer::_tc_IdUniquenessPolicy, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_obj_ptr, ACE_TRY_ENV ); ACE_TRY_CHECK; } else { delete _tao_obj_ptr; } } ACE_CATCHANY { delete _tao_obj_ptr; } ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::IdUniquenessPolicy_ptr &_tao_elem) { CORBA::Object_ptr *tmp = 0; ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = PortableServer::IdUniquenessPolicy::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::_tc_IdUniquenessPolicy, ACE_TRY_ENV)) // not equal { delete tmp; return 0; } ACE_TRY_CHECK; TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); CORBA::Object_var _tao_obj_var; if (stream >> _tao_obj_var.out ()) { _tao_elem = PortableServer::IdUniquenessPolicy::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); ACE_TRY_CHECK; *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::_tc_IdUniquenessPolicy, 1, tmp, ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else // failure { delete tmp; } } ACE_CATCHANY { delete tmp; _tao_elem = PortableServer::IdUniquenessPolicy::_nil (); return 0; } ACE_ENDTRY; _tao_elem = PortableServer::IdUniquenessPolicy::_nil (); return 0; } void operator<<= (CORBA::Any &_tao_any, PortableServer::IdAssignmentPolicyValue _tao_elem) { PortableServer::IdAssignmentPolicyValue *_tao_any_val; ACE_NEW (_tao_any_val, PortableServer::IdAssignmentPolicyValue (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_any_val; _tao_any._tao_replace ( PortableServer::_tc_IdAssignmentPolicyValue, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_any_val, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { // free allocated storage delete _tao_any_val; } ACE_ENDTRY; } 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; } void operator<<= (CORBA::Any &_tao_any, PortableServer::IdAssignmentPolicy_ptr _tao_elem) { CORBA::Object_ptr *_tao_obj_ptr = 0; ACE_TRY_NEW_ENV { ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); *_tao_obj_ptr = PortableServer::IdAssignmentPolicy::_duplicate (_tao_elem); TAO_OutputCDR stream; if (stream << *_tao_obj_ptr) { _tao_any._tao_replace ( PortableServer::_tc_IdAssignmentPolicy, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_obj_ptr, ACE_TRY_ENV ); ACE_TRY_CHECK; } else { delete _tao_obj_ptr; } } ACE_CATCHANY { delete _tao_obj_ptr; } ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::IdAssignmentPolicy_ptr &_tao_elem) { CORBA::Object_ptr *tmp = 0; ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = PortableServer::IdAssignmentPolicy::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::_tc_IdAssignmentPolicy, ACE_TRY_ENV)) // not equal { delete tmp; return 0; } ACE_TRY_CHECK; TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); CORBA::Object_var _tao_obj_var; if (stream >> _tao_obj_var.out ()) { _tao_elem = PortableServer::IdAssignmentPolicy::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); ACE_TRY_CHECK; *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::_tc_IdAssignmentPolicy, 1, tmp, ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else // failure { delete tmp; } } ACE_CATCHANY { delete tmp; _tao_elem = PortableServer::IdAssignmentPolicy::_nil (); return 0; } ACE_ENDTRY; _tao_elem = PortableServer::IdAssignmentPolicy::_nil (); return 0; } #if (TAO_HAS_MINIMUM_POA == 0) void operator<<= (CORBA::Any &_tao_any, PortableServer::ImplicitActivationPolicyValue _tao_elem) { PortableServer::ImplicitActivationPolicyValue *_tao_any_val; ACE_NEW (_tao_any_val, PortableServer::ImplicitActivationPolicyValue (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_any_val; _tao_any._tao_replace ( PortableServer::_tc_ImplicitActivationPolicyValue, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_any_val, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { // free allocated storage delete _tao_any_val; } ACE_ENDTRY; } 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; } void operator<<= (CORBA::Any &_tao_any, PortableServer::ImplicitActivationPolicy_ptr _tao_elem) { CORBA::Object_ptr *_tao_obj_ptr = 0; ACE_TRY_NEW_ENV { ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); *_tao_obj_ptr = PortableServer::ImplicitActivationPolicy::_duplicate (_tao_elem); TAO_OutputCDR stream; if (stream << *_tao_obj_ptr) { _tao_any._tao_replace ( PortableServer::_tc_ImplicitActivationPolicy, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_obj_ptr, ACE_TRY_ENV ); ACE_TRY_CHECK; } else { delete _tao_obj_ptr; } } ACE_CATCHANY { delete _tao_obj_ptr; } ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ImplicitActivationPolicy_ptr &_tao_elem) { CORBA::Object_ptr *tmp = 0; ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = PortableServer::ImplicitActivationPolicy::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::_tc_ImplicitActivationPolicy, ACE_TRY_ENV)) // not equal { delete tmp; return 0; } ACE_TRY_CHECK; TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); CORBA::Object_var _tao_obj_var; if (stream >> _tao_obj_var.out ()) { _tao_elem = PortableServer::ImplicitActivationPolicy::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); ACE_TRY_CHECK; *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::_tc_ImplicitActivationPolicy, 1, tmp, ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else // failure { delete tmp; } } ACE_CATCHANY { delete tmp; _tao_elem = PortableServer::ImplicitActivationPolicy::_nil (); return 0; } ACE_ENDTRY; _tao_elem = PortableServer::ImplicitActivationPolicy::_nil (); return 0; } void operator<<= (CORBA::Any &_tao_any, PortableServer::ServantRetentionPolicyValue _tao_elem) { PortableServer::ServantRetentionPolicyValue *_tao_any_val; ACE_NEW (_tao_any_val, PortableServer::ServantRetentionPolicyValue (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_any_val; _tao_any._tao_replace ( PortableServer::_tc_ServantRetentionPolicyValue, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_any_val, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { // free allocated storage delete _tao_any_val; } ACE_ENDTRY; } 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; } void operator<<= (CORBA::Any &_tao_any, PortableServer::ServantRetentionPolicy_ptr _tao_elem) { CORBA::Object_ptr *_tao_obj_ptr = 0; ACE_TRY_NEW_ENV { ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); *_tao_obj_ptr = PortableServer::ServantRetentionPolicy::_duplicate (_tao_elem); TAO_OutputCDR stream; if (stream << *_tao_obj_ptr) { _tao_any._tao_replace ( PortableServer::_tc_ServantRetentionPolicy, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_obj_ptr, ACE_TRY_ENV ); ACE_TRY_CHECK; } else { delete _tao_obj_ptr; } } ACE_CATCHANY { delete _tao_obj_ptr; } ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ServantRetentionPolicy_ptr &_tao_elem) { CORBA::Object_ptr *tmp = 0; ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = PortableServer::ServantRetentionPolicy::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::_tc_ServantRetentionPolicy, ACE_TRY_ENV)) // not equal { delete tmp; return 0; } ACE_TRY_CHECK; TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); CORBA::Object_var _tao_obj_var; if (stream >> _tao_obj_var.out ()) { _tao_elem = PortableServer::ServantRetentionPolicy::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); ACE_TRY_CHECK; *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::_tc_ServantRetentionPolicy, 1, tmp, ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else // failure { delete tmp; } } ACE_CATCHANY { delete tmp; _tao_elem = PortableServer::ServantRetentionPolicy::_nil (); return 0; } ACE_ENDTRY; _tao_elem = PortableServer::ServantRetentionPolicy::_nil (); return 0; } void operator<<= (CORBA::Any &_tao_any, PortableServer::RequestProcessingPolicyValue _tao_elem) { PortableServer::RequestProcessingPolicyValue *_tao_any_val; ACE_NEW (_tao_any_val, PortableServer::RequestProcessingPolicyValue (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_any_val; _tao_any._tao_replace ( PortableServer::_tc_RequestProcessingPolicyValue, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_any_val, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { // free allocated storage delete _tao_any_val; } ACE_ENDTRY; } 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; } void operator<<= (CORBA::Any &_tao_any, PortableServer::RequestProcessingPolicy_ptr _tao_elem) { CORBA::Object_ptr *_tao_obj_ptr = 0; ACE_TRY_NEW_ENV { ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); *_tao_obj_ptr = PortableServer::RequestProcessingPolicy::_duplicate (_tao_elem); TAO_OutputCDR stream; if (stream << *_tao_obj_ptr) { _tao_any._tao_replace ( PortableServer::_tc_RequestProcessingPolicy, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_obj_ptr, ACE_TRY_ENV ); ACE_TRY_CHECK; } else { delete _tao_obj_ptr; } } ACE_CATCHANY { delete _tao_obj_ptr; } ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::RequestProcessingPolicy_ptr &_tao_elem) { CORBA::Object_ptr *tmp = 0; ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = PortableServer::RequestProcessingPolicy::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::_tc_RequestProcessingPolicy, ACE_TRY_ENV)) // not equal { delete tmp; return 0; } ACE_TRY_CHECK; TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); CORBA::Object_var _tao_obj_var; if (stream >> _tao_obj_var.out ()) { _tao_elem = PortableServer::RequestProcessingPolicy::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); ACE_TRY_CHECK; *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::_tc_RequestProcessingPolicy, 1, tmp, ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else // failure { delete tmp; } } ACE_CATCHANY { delete tmp; _tao_elem = PortableServer::RequestProcessingPolicy::_nil (); return 0; } ACE_ENDTRY; _tao_elem = PortableServer::RequestProcessingPolicy::_nil (); return 0; } #endif /* TAO_HAS_MINIMUM_POA == 0 */ void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::AdapterAlreadyExists &_tao_elem) // copying { PortableServer::POA::AdapterAlreadyExists *_tao_any_val = 0; ACE_NEW (_tao_any_val, PortableServer::POA::AdapterAlreadyExists (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_any_val; _tao_any._tao_replace ( PortableServer::POA::_tc_AdapterAlreadyExists, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_any_val, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { delete _tao_any_val; } ACE_ENDTRY; } void operator<<= (CORBA::Any &_tao_any, PortableServer::POA::AdapterAlreadyExists *_tao_elem) // non copying { ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( PortableServer::POA::_tc_AdapterAlreadyExists, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_elem, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { delete _tao_elem; _tao_elem = 0; } ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::AdapterAlreadyExists *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::POA::_tc_AdapterAlreadyExists, ACE_TRY_ENV)) // not equal { _tao_elem = 0; return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (PortableServer::POA::AdapterAlreadyExists *)_tao_any.value (); return 1; } else { ACE_NEW_RETURN (_tao_elem, PortableServer::POA::AdapterAlreadyExists, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); if (stream >> *_tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::POA::_tc_AdapterAlreadyExists, 1, ACE_reinterpret_cast (void *, _tao_elem), ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else { delete _tao_elem; _tao_elem = 0; } } } ACE_CATCHANY { delete _tao_elem; _tao_elem = 0; return 0; } ACE_ENDTRY; return 0; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::POA::AdapterAlreadyExists *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::POA::_tc_AdapterAlreadyExists, ACE_TRY_ENV)) // not equal { _tao_elem = 0; return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (PortableServer::POA::AdapterAlreadyExists *)_tao_any.value (); return 1; } else { ACE_NEW_RETURN (_tao_elem, PortableServer::POA::AdapterAlreadyExists, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); if (stream >> *(PortableServer::POA::AdapterAlreadyExists *)_tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::POA::_tc_AdapterAlreadyExists, 1, ACE_reinterpret_cast (void *, ACE_const_cast (PortableServer::POA::AdapterAlreadyExists *&, _tao_elem)), ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else { delete ACE_const_cast (PortableServer::POA::AdapterAlreadyExists *&, _tao_elem); _tao_elem = 0; } } } ACE_CATCHANY { delete ACE_const_cast (PortableServer::POA::AdapterAlreadyExists *&, _tao_elem); _tao_elem = 0; return 0; } ACE_ENDTRY; return 0; } #if (TAO_HAS_MINIMUM_POA == 0) void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::AdapterInactive &_tao_elem) // copying { PortableServer::POA::AdapterInactive *_tao_any_val = 0; ACE_NEW (_tao_any_val, PortableServer::POA::AdapterInactive (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_any_val; _tao_any._tao_replace ( PortableServer::POA::_tc_AdapterInactive, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_any_val, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { delete _tao_any_val; } ACE_ENDTRY; } void operator<<= (CORBA::Any &_tao_any, PortableServer::POA::AdapterInactive *_tao_elem) // non copying { ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( PortableServer::POA::_tc_AdapterInactive, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_elem, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { delete _tao_elem; _tao_elem = 0; } ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::AdapterInactive *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::POA::_tc_AdapterInactive, ACE_TRY_ENV)) // not equal { _tao_elem = 0; return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (PortableServer::POA::AdapterInactive *)_tao_any.value (); return 1; } else { ACE_NEW_RETURN (_tao_elem, PortableServer::POA::AdapterInactive, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); if (stream >> *_tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::POA::_tc_AdapterInactive, 1, ACE_reinterpret_cast (void *, _tao_elem), ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else { delete _tao_elem; _tao_elem = 0; } } } ACE_CATCHANY { delete _tao_elem; _tao_elem = 0; return 0; } ACE_ENDTRY; return 0; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::POA::AdapterInactive *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::POA::_tc_AdapterInactive, ACE_TRY_ENV)) // not equal { _tao_elem = 0; return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (PortableServer::POA::AdapterInactive *)_tao_any.value (); return 1; } else { ACE_NEW_RETURN (_tao_elem, PortableServer::POA::AdapterInactive, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); if (stream >> *(PortableServer::POA::AdapterInactive *)_tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::POA::_tc_AdapterInactive, 1, ACE_reinterpret_cast (void *, ACE_const_cast (PortableServer::POA::AdapterInactive *&, _tao_elem)), ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else { delete ACE_const_cast (PortableServer::POA::AdapterInactive *&, _tao_elem); _tao_elem = 0; } } } ACE_CATCHANY { delete ACE_const_cast (PortableServer::POA::AdapterInactive *&, _tao_elem); _tao_elem = 0; return 0; } ACE_ENDTRY; return 0; } #endif /* TAO_HAS_MINIMUM_POA == 0 */ void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::AdapterNonExistent &_tao_elem) // copying { PortableServer::POA::AdapterNonExistent *_tao_any_val = 0; ACE_NEW (_tao_any_val, PortableServer::POA::AdapterNonExistent (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_any_val; _tao_any._tao_replace ( PortableServer::POA::_tc_AdapterNonExistent, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_any_val, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { delete _tao_any_val; } ACE_ENDTRY; } void operator<<= (CORBA::Any &_tao_any, PortableServer::POA::AdapterNonExistent *_tao_elem) // non copying { ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( PortableServer::POA::_tc_AdapterNonExistent, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_elem, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { delete _tao_elem; _tao_elem = 0; } ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::AdapterNonExistent *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::POA::_tc_AdapterNonExistent, ACE_TRY_ENV)) // not equal { _tao_elem = 0; return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (PortableServer::POA::AdapterNonExistent *)_tao_any.value (); return 1; } else { ACE_NEW_RETURN (_tao_elem, PortableServer::POA::AdapterNonExistent, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); if (stream >> *_tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::POA::_tc_AdapterNonExistent, 1, ACE_reinterpret_cast (void *, _tao_elem), ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else { delete _tao_elem; _tao_elem = 0; } } } ACE_CATCHANY { delete _tao_elem; _tao_elem = 0; return 0; } ACE_ENDTRY; return 0; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::POA::AdapterNonExistent *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::POA::_tc_AdapterNonExistent, ACE_TRY_ENV)) // not equal { _tao_elem = 0; return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (PortableServer::POA::AdapterNonExistent *)_tao_any.value (); return 1; } else { ACE_NEW_RETURN (_tao_elem, PortableServer::POA::AdapterNonExistent, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); if (stream >> *(PortableServer::POA::AdapterNonExistent *)_tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::POA::_tc_AdapterNonExistent, 1, ACE_reinterpret_cast (void *, ACE_const_cast (PortableServer::POA::AdapterNonExistent *&, _tao_elem)), ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else { delete ACE_const_cast (PortableServer::POA::AdapterNonExistent *&, _tao_elem); _tao_elem = 0; } } } ACE_CATCHANY { delete ACE_const_cast (PortableServer::POA::AdapterNonExistent *&, _tao_elem); _tao_elem = 0; return 0; } ACE_ENDTRY; return 0; } void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::InvalidPolicy &_tao_elem) // copying { PortableServer::POA::InvalidPolicy *_tao_any_val = 0; ACE_NEW (_tao_any_val, PortableServer::POA::InvalidPolicy (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_any_val; _tao_any._tao_replace ( PortableServer::POA::_tc_InvalidPolicy, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_any_val, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { delete _tao_any_val; } ACE_ENDTRY; } void operator<<= (CORBA::Any &_tao_any, PortableServer::POA::InvalidPolicy *_tao_elem) // non copying { ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( PortableServer::POA::_tc_InvalidPolicy, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_elem, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { delete _tao_elem; _tao_elem = 0; } ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::InvalidPolicy *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::POA::_tc_InvalidPolicy, ACE_TRY_ENV)) // not equal { _tao_elem = 0; return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (PortableServer::POA::InvalidPolicy *)_tao_any.value (); return 1; } else { ACE_NEW_RETURN (_tao_elem, PortableServer::POA::InvalidPolicy, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); if (stream >> *_tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::POA::_tc_InvalidPolicy, 1, ACE_reinterpret_cast (void *, _tao_elem), ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else { delete _tao_elem; _tao_elem = 0; } } } ACE_CATCHANY { delete _tao_elem; _tao_elem = 0; return 0; } ACE_ENDTRY; return 0; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::POA::InvalidPolicy *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::POA::_tc_InvalidPolicy, ACE_TRY_ENV)) // not equal { _tao_elem = 0; return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (PortableServer::POA::InvalidPolicy *)_tao_any.value (); return 1; } else { ACE_NEW_RETURN (_tao_elem, PortableServer::POA::InvalidPolicy, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); if (stream >> *(PortableServer::POA::InvalidPolicy *)_tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::POA::_tc_InvalidPolicy, 1, ACE_reinterpret_cast (void *, ACE_const_cast (PortableServer::POA::InvalidPolicy *&, _tao_elem)), ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else { delete ACE_const_cast (PortableServer::POA::InvalidPolicy *&, _tao_elem); _tao_elem = 0; } } } ACE_CATCHANY { delete ACE_const_cast (PortableServer::POA::InvalidPolicy *&, _tao_elem); _tao_elem = 0; return 0; } ACE_ENDTRY; return 0; } #if (TAO_HAS_MINIMUM_POA == 0) void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::NoServant &_tao_elem) // copying { PortableServer::POA::NoServant *_tao_any_val = 0; ACE_NEW (_tao_any_val, PortableServer::POA::NoServant (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_any_val; _tao_any._tao_replace ( PortableServer::POA::_tc_NoServant, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_any_val, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { delete _tao_any_val; } ACE_ENDTRY; } void operator<<= (CORBA::Any &_tao_any, PortableServer::POA::NoServant *_tao_elem) // non copying { ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( PortableServer::POA::_tc_NoServant, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_elem, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { delete _tao_elem; _tao_elem = 0; } ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::NoServant *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::POA::_tc_NoServant, ACE_TRY_ENV)) // not equal { _tao_elem = 0; return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (PortableServer::POA::NoServant *)_tao_any.value (); return 1; } else { ACE_NEW_RETURN (_tao_elem, PortableServer::POA::NoServant, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); if (stream >> *_tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::POA::_tc_NoServant, 1, ACE_reinterpret_cast (void *, _tao_elem), ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else { delete _tao_elem; _tao_elem = 0; } } } ACE_CATCHANY { delete _tao_elem; _tao_elem = 0; return 0; } ACE_ENDTRY; return 0; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::POA::NoServant *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::POA::_tc_NoServant, ACE_TRY_ENV)) // not equal { _tao_elem = 0; return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (PortableServer::POA::NoServant *)_tao_any.value (); return 1; } else { ACE_NEW_RETURN (_tao_elem, PortableServer::POA::NoServant, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); if (stream >> *(PortableServer::POA::NoServant *)_tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::POA::_tc_NoServant, 1, ACE_reinterpret_cast (void *, ACE_const_cast (PortableServer::POA::NoServant *&, _tao_elem)), ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else { delete ACE_const_cast (PortableServer::POA::NoServant *&, _tao_elem); _tao_elem = 0; } } } ACE_CATCHANY { delete ACE_const_cast (PortableServer::POA::NoServant *&, _tao_elem); _tao_elem = 0; return 0; } ACE_ENDTRY; return 0; } #endif /* TAO_HAS_MINIMUM_POA == 0 */ void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::ObjectAlreadyActive &_tao_elem) // copying { PortableServer::POA::ObjectAlreadyActive *_tao_any_val = 0; ACE_NEW (_tao_any_val, PortableServer::POA::ObjectAlreadyActive (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_any_val; _tao_any._tao_replace ( PortableServer::POA::_tc_ObjectAlreadyActive, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_any_val, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { delete _tao_any_val; } ACE_ENDTRY; } void operator<<= (CORBA::Any &_tao_any, PortableServer::POA::ObjectAlreadyActive *_tao_elem) // non copying { ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( PortableServer::POA::_tc_ObjectAlreadyActive, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_elem, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { delete _tao_elem; _tao_elem = 0; } ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::ObjectAlreadyActive *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::POA::_tc_ObjectAlreadyActive, ACE_TRY_ENV)) // not equal { _tao_elem = 0; return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (PortableServer::POA::ObjectAlreadyActive *)_tao_any.value (); return 1; } else { ACE_NEW_RETURN (_tao_elem, PortableServer::POA::ObjectAlreadyActive, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); if (stream >> *_tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::POA::_tc_ObjectAlreadyActive, 1, ACE_reinterpret_cast (void *, _tao_elem), ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else { delete _tao_elem; _tao_elem = 0; } } } ACE_CATCHANY { delete _tao_elem; _tao_elem = 0; return 0; } ACE_ENDTRY; return 0; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::POA::ObjectAlreadyActive *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::POA::_tc_ObjectAlreadyActive, ACE_TRY_ENV)) // not equal { _tao_elem = 0; return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (PortableServer::POA::ObjectAlreadyActive *)_tao_any.value (); return 1; } else { ACE_NEW_RETURN (_tao_elem, PortableServer::POA::ObjectAlreadyActive, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); if (stream >> *(PortableServer::POA::ObjectAlreadyActive *)_tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::POA::_tc_ObjectAlreadyActive, 1, ACE_reinterpret_cast (void *, ACE_const_cast (PortableServer::POA::ObjectAlreadyActive *&, _tao_elem)), ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else { delete ACE_const_cast (PortableServer::POA::ObjectAlreadyActive *&, _tao_elem); _tao_elem = 0; } } } ACE_CATCHANY { delete ACE_const_cast (PortableServer::POA::ObjectAlreadyActive *&, _tao_elem); _tao_elem = 0; return 0; } ACE_ENDTRY; return 0; } void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::ObjectNotActive &_tao_elem) // copying { PortableServer::POA::ObjectNotActive *_tao_any_val = 0; ACE_NEW (_tao_any_val, PortableServer::POA::ObjectNotActive (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_any_val; _tao_any._tao_replace ( PortableServer::POA::_tc_ObjectNotActive, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_any_val, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { delete _tao_any_val; } ACE_ENDTRY; } void operator<<= (CORBA::Any &_tao_any, PortableServer::POA::ObjectNotActive *_tao_elem) // non copying { ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( PortableServer::POA::_tc_ObjectNotActive, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_elem, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { delete _tao_elem; _tao_elem = 0; } ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::ObjectNotActive *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::POA::_tc_ObjectNotActive, ACE_TRY_ENV)) // not equal { _tao_elem = 0; return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (PortableServer::POA::ObjectNotActive *)_tao_any.value (); return 1; } else { ACE_NEW_RETURN (_tao_elem, PortableServer::POA::ObjectNotActive, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); if (stream >> *_tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::POA::_tc_ObjectNotActive, 1, ACE_reinterpret_cast (void *, _tao_elem), ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else { delete _tao_elem; _tao_elem = 0; } } } ACE_CATCHANY { delete _tao_elem; _tao_elem = 0; return 0; } ACE_ENDTRY; return 0; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::POA::ObjectNotActive *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::POA::_tc_ObjectNotActive, ACE_TRY_ENV)) // not equal { _tao_elem = 0; return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (PortableServer::POA::ObjectNotActive *)_tao_any.value (); return 1; } else { ACE_NEW_RETURN (_tao_elem, PortableServer::POA::ObjectNotActive, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); if (stream >> *(PortableServer::POA::ObjectNotActive *)_tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::POA::_tc_ObjectNotActive, 1, ACE_reinterpret_cast (void *, ACE_const_cast (PortableServer::POA::ObjectNotActive *&, _tao_elem)), ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else { delete ACE_const_cast (PortableServer::POA::ObjectNotActive *&, _tao_elem); _tao_elem = 0; } } } ACE_CATCHANY { delete ACE_const_cast (PortableServer::POA::ObjectNotActive *&, _tao_elem); _tao_elem = 0; return 0; } ACE_ENDTRY; return 0; } void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::ServantAlreadyActive &_tao_elem) // copying { PortableServer::POA::ServantAlreadyActive *_tao_any_val = 0; ACE_NEW (_tao_any_val, PortableServer::POA::ServantAlreadyActive (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_any_val; _tao_any._tao_replace ( PortableServer::POA::_tc_ServantAlreadyActive, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_any_val, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { delete _tao_any_val; } ACE_ENDTRY; } void operator<<= (CORBA::Any &_tao_any, PortableServer::POA::ServantAlreadyActive *_tao_elem) // non copying { ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( PortableServer::POA::_tc_ServantAlreadyActive, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_elem, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { delete _tao_elem; _tao_elem = 0; } ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::ServantAlreadyActive *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::POA::_tc_ServantAlreadyActive, ACE_TRY_ENV)) // not equal { _tao_elem = 0; return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (PortableServer::POA::ServantAlreadyActive *)_tao_any.value (); return 1; } else { ACE_NEW_RETURN (_tao_elem, PortableServer::POA::ServantAlreadyActive, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); if (stream >> *_tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::POA::_tc_ServantAlreadyActive, 1, ACE_reinterpret_cast (void *, _tao_elem), ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else { delete _tao_elem; _tao_elem = 0; } } } ACE_CATCHANY { delete _tao_elem; _tao_elem = 0; return 0; } ACE_ENDTRY; return 0; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::POA::ServantAlreadyActive *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::POA::_tc_ServantAlreadyActive, ACE_TRY_ENV)) // not equal { _tao_elem = 0; return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (PortableServer::POA::ServantAlreadyActive *)_tao_any.value (); return 1; } else { ACE_NEW_RETURN (_tao_elem, PortableServer::POA::ServantAlreadyActive, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); if (stream >> *(PortableServer::POA::ServantAlreadyActive *)_tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::POA::_tc_ServantAlreadyActive, 1, ACE_reinterpret_cast (void *, ACE_const_cast (PortableServer::POA::ServantAlreadyActive *&, _tao_elem)), ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else { delete ACE_const_cast (PortableServer::POA::ServantAlreadyActive *&, _tao_elem); _tao_elem = 0; } } } ACE_CATCHANY { delete ACE_const_cast (PortableServer::POA::ServantAlreadyActive *&, _tao_elem); _tao_elem = 0; return 0; } ACE_ENDTRY; return 0; } void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::ServantNotActive &_tao_elem) // copying { PortableServer::POA::ServantNotActive *_tao_any_val = 0; ACE_NEW (_tao_any_val, PortableServer::POA::ServantNotActive (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_any_val; _tao_any._tao_replace ( PortableServer::POA::_tc_ServantNotActive, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_any_val, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { delete _tao_any_val; } ACE_ENDTRY; } void operator<<= (CORBA::Any &_tao_any, PortableServer::POA::ServantNotActive *_tao_elem) // non copying { ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( PortableServer::POA::_tc_ServantNotActive, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_elem, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { delete _tao_elem; _tao_elem = 0; } ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::ServantNotActive *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::POA::_tc_ServantNotActive, ACE_TRY_ENV)) // not equal { _tao_elem = 0; return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (PortableServer::POA::ServantNotActive *)_tao_any.value (); return 1; } else { ACE_NEW_RETURN (_tao_elem, PortableServer::POA::ServantNotActive, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); if (stream >> *_tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::POA::_tc_ServantNotActive, 1, ACE_reinterpret_cast (void *, _tao_elem), ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else { delete _tao_elem; _tao_elem = 0; } } } ACE_CATCHANY { delete _tao_elem; _tao_elem = 0; return 0; } ACE_ENDTRY; return 0; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::POA::ServantNotActive *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::POA::_tc_ServantNotActive, ACE_TRY_ENV)) // not equal { _tao_elem = 0; return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (PortableServer::POA::ServantNotActive *)_tao_any.value (); return 1; } else { ACE_NEW_RETURN (_tao_elem, PortableServer::POA::ServantNotActive, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); if (stream >> *(PortableServer::POA::ServantNotActive *)_tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::POA::_tc_ServantNotActive, 1, ACE_reinterpret_cast (void *, ACE_const_cast (PortableServer::POA::ServantNotActive *&, _tao_elem)), ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else { delete ACE_const_cast (PortableServer::POA::ServantNotActive *&, _tao_elem); _tao_elem = 0; } } } ACE_CATCHANY { delete ACE_const_cast (PortableServer::POA::ServantNotActive *&, _tao_elem); _tao_elem = 0; return 0; } ACE_ENDTRY; return 0; } void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::WrongAdapter &_tao_elem) // copying { PortableServer::POA::WrongAdapter *_tao_any_val = 0; ACE_NEW (_tao_any_val, PortableServer::POA::WrongAdapter (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_any_val; _tao_any._tao_replace ( PortableServer::POA::_tc_WrongAdapter, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_any_val, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { delete _tao_any_val; } ACE_ENDTRY; } void operator<<= (CORBA::Any &_tao_any, PortableServer::POA::WrongAdapter *_tao_elem) // non copying { ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( PortableServer::POA::_tc_WrongAdapter, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_elem, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { delete _tao_elem; _tao_elem = 0; } ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::WrongAdapter *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::POA::_tc_WrongAdapter, ACE_TRY_ENV)) // not equal { _tao_elem = 0; return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (PortableServer::POA::WrongAdapter *)_tao_any.value (); return 1; } else { ACE_NEW_RETURN (_tao_elem, PortableServer::POA::WrongAdapter, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); if (stream >> *_tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::POA::_tc_WrongAdapter, 1, ACE_reinterpret_cast (void *, _tao_elem), ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else { delete _tao_elem; _tao_elem = 0; } } } ACE_CATCHANY { delete _tao_elem; _tao_elem = 0; return 0; } ACE_ENDTRY; return 0; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::POA::WrongAdapter *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::POA::_tc_WrongAdapter, ACE_TRY_ENV)) // not equal { _tao_elem = 0; return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (PortableServer::POA::WrongAdapter *)_tao_any.value (); return 1; } else { ACE_NEW_RETURN (_tao_elem, PortableServer::POA::WrongAdapter, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); if (stream >> *(PortableServer::POA::WrongAdapter *)_tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::POA::_tc_WrongAdapter, 1, ACE_reinterpret_cast (void *, ACE_const_cast (PortableServer::POA::WrongAdapter *&, _tao_elem)), ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else { delete ACE_const_cast (PortableServer::POA::WrongAdapter *&, _tao_elem); _tao_elem = 0; } } } ACE_CATCHANY { delete ACE_const_cast (PortableServer::POA::WrongAdapter *&, _tao_elem); _tao_elem = 0; return 0; } ACE_ENDTRY; return 0; } void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::WrongPolicy &_tao_elem) // copying { PortableServer::POA::WrongPolicy *_tao_any_val = 0; ACE_NEW (_tao_any_val, PortableServer::POA::WrongPolicy (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_any_val; _tao_any._tao_replace ( PortableServer::POA::_tc_WrongPolicy, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_any_val, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { delete _tao_any_val; } ACE_ENDTRY; } void operator<<= (CORBA::Any &_tao_any, PortableServer::POA::WrongPolicy *_tao_elem) // non copying { ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( PortableServer::POA::_tc_WrongPolicy, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_elem, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { delete _tao_elem; _tao_elem = 0; } ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::WrongPolicy *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::POA::_tc_WrongPolicy, ACE_TRY_ENV)) // not equal { _tao_elem = 0; return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (PortableServer::POA::WrongPolicy *)_tao_any.value (); return 1; } else { ACE_NEW_RETURN (_tao_elem, PortableServer::POA::WrongPolicy, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); if (stream >> *_tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::POA::_tc_WrongPolicy, 1, ACE_reinterpret_cast (void *, _tao_elem), ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else { delete _tao_elem; _tao_elem = 0; } } } ACE_CATCHANY { delete _tao_elem; _tao_elem = 0; return 0; } ACE_ENDTRY; return 0; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::POA::WrongPolicy *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::POA::_tc_WrongPolicy, ACE_TRY_ENV)) // not equal { _tao_elem = 0; return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (PortableServer::POA::WrongPolicy *)_tao_any.value (); return 1; } else { ACE_NEW_RETURN (_tao_elem, PortableServer::POA::WrongPolicy, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); if (stream >> *(PortableServer::POA::WrongPolicy *)_tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::POA::_tc_WrongPolicy, 1, ACE_reinterpret_cast (void *, ACE_const_cast (PortableServer::POA::WrongPolicy *&, _tao_elem)), ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else { delete ACE_const_cast (PortableServer::POA::WrongPolicy *&, _tao_elem); _tao_elem = 0; } } } ACE_CATCHANY { delete ACE_const_cast (PortableServer::POA::WrongPolicy *&, _tao_elem); _tao_elem = 0; return 0; } ACE_ENDTRY; return 0; } void operator<<= (CORBA::Any &_tao_any, const PortableServer::Current::NoContext &_tao_elem) // copying { PortableServer::Current::NoContext *_tao_any_val = 0; ACE_NEW (_tao_any_val, PortableServer::Current::NoContext (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_any_val; _tao_any._tao_replace ( PortableServer::Current::_tc_NoContext, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_any_val, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { delete _tao_any_val; } ACE_ENDTRY; } void operator<<= (CORBA::Any &_tao_any, PortableServer::Current::NoContext *_tao_elem) // non copying { ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( PortableServer::Current::_tc_NoContext, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_elem, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { delete _tao_elem; _tao_elem = 0; } ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::Current::NoContext *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::Current::_tc_NoContext, ACE_TRY_ENV)) // not equal { _tao_elem = 0; return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (PortableServer::Current::NoContext *)_tao_any.value (); return 1; } else { ACE_NEW_RETURN (_tao_elem, PortableServer::Current::NoContext, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); if (stream >> *_tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::Current::_tc_NoContext, 1, ACE_reinterpret_cast (void *, _tao_elem), ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else { delete _tao_elem; _tao_elem = 0; } } } ACE_CATCHANY { delete _tao_elem; _tao_elem = 0; return 0; } ACE_ENDTRY; return 0; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::Current::NoContext *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::Current::_tc_NoContext, ACE_TRY_ENV)) // not equal { _tao_elem = 0; return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (PortableServer::Current::NoContext *)_tao_any.value (); return 1; } else { ACE_NEW_RETURN (_tao_elem, PortableServer::Current::NoContext, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); if (stream >> *(PortableServer::Current::NoContext *)_tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::Current::_tc_NoContext, 1, ACE_reinterpret_cast (void *, ACE_const_cast (PortableServer::Current::NoContext *&, _tao_elem)), ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else { delete ACE_const_cast (PortableServer::Current::NoContext *&, _tao_elem); _tao_elem = 0; } } } ACE_CATCHANY { delete ACE_const_cast (PortableServer::Current::NoContext *&, _tao_elem); _tao_elem = 0; return 0; } ACE_ENDTRY; return 0; } void operator<<= (CORBA::Any &_tao_any, PortableServer::Current_ptr _tao_elem) { CORBA::Object_ptr *_tao_obj_ptr = 0; ACE_TRY_NEW_ENV { ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); *_tao_obj_ptr = PortableServer::Current::_duplicate (_tao_elem); TAO_OutputCDR stream; if (stream << *_tao_obj_ptr) { _tao_any._tao_replace ( PortableServer::_tc_Current, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_obj_ptr, ACE_TRY_ENV ); ACE_TRY_CHECK; } else { delete _tao_obj_ptr; } } ACE_CATCHANY { delete _tao_obj_ptr; } ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::Current_ptr &_tao_elem) { CORBA::Object_ptr *tmp = 0; ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = PortableServer::Current::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::_tc_Current, ACE_TRY_ENV)) // not equal { delete tmp; return 0; } ACE_TRY_CHECK; TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); CORBA::Object_var _tao_obj_var; if (stream >> _tao_obj_var.out ()) { _tao_elem = PortableServer::Current::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); ACE_TRY_CHECK; *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::_tc_Current, 1, tmp, ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else // failure { delete tmp; } } ACE_CATCHANY { delete tmp; _tao_elem = PortableServer::Current::_nil (); return 0; } ACE_ENDTRY; _tao_elem = PortableServer::Current::_nil (); return 0; } void operator<<= (CORBA::Any &_tao_any, PortableServer::POAManager_ptr _tao_elem) { CORBA::Object_ptr *_tao_obj_ptr = 0; ACE_TRY_NEW_ENV { ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); *_tao_obj_ptr = PortableServer::POAManager::_duplicate (_tao_elem); TAO_OutputCDR stream; if (stream << *_tao_obj_ptr) { _tao_any._tao_replace ( PortableServer::_tc_POAManager, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_obj_ptr, ACE_TRY_ENV ); ACE_TRY_CHECK; } else { delete _tao_obj_ptr; } } ACE_CATCHANY { delete _tao_obj_ptr; } ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POAManager_ptr &_tao_elem) { CORBA::Object_ptr *tmp = 0; ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = PortableServer::POAManager::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::_tc_POAManager, ACE_TRY_ENV)) // not equal { delete tmp; return 0; } ACE_TRY_CHECK; TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); CORBA::Object_var _tao_obj_var; if (stream >> _tao_obj_var.out ()) { _tao_elem = PortableServer::POAManager::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); ACE_TRY_CHECK; *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::_tc_POAManager, 1, tmp, ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else // failure { delete tmp; } } ACE_CATCHANY { delete tmp; _tao_elem = PortableServer::POAManager::_nil (); return 0; } ACE_ENDTRY; _tao_elem = PortableServer::POAManager::_nil (); return 0; } void operator<<= (CORBA::Any &_tao_any, PortableServer::POAManager::State _tao_elem) { PortableServer::POAManager::State *_tao_any_val; ACE_NEW (_tao_any_val, PortableServer::POAManager::State (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_any_val; _tao_any._tao_replace ( PortableServer::POAManager::_tc_State, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_any_val, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { // free allocated storage delete _tao_any_val; } ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POAManager::State &_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::POAManager::_tc_State, 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; } void operator<<= (CORBA::Any &_tao_any, const PortableServer::POAManager::AdapterInactive &_tao_elem) // copying { PortableServer::POAManager::AdapterInactive *_tao_any_val = 0; ACE_NEW (_tao_any_val, PortableServer::POAManager::AdapterInactive (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_any_val; _tao_any._tao_replace ( PortableServer::POAManager::_tc_AdapterInactive, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_any_val, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { delete _tao_any_val; } ACE_ENDTRY; } void operator<<= (CORBA::Any &_tao_any, PortableServer::POAManager::AdapterInactive *_tao_elem) // non copying { ACE_TRY_NEW_ENV { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( PortableServer::POAManager::_tc_AdapterInactive, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_elem, ACE_TRY_ENV ); ACE_TRY_CHECK; } ACE_CATCHANY { delete _tao_elem; _tao_elem = 0; } ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POAManager::AdapterInactive *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::POAManager::_tc_AdapterInactive, ACE_TRY_ENV)) // not equal { _tao_elem = 0; return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (PortableServer::POAManager::AdapterInactive *)_tao_any.value (); return 1; } else { ACE_NEW_RETURN (_tao_elem, PortableServer::POAManager::AdapterInactive, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); if (stream >> *_tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::POAManager::_tc_AdapterInactive, 1, ACE_reinterpret_cast (void *, _tao_elem), ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else { delete _tao_elem; _tao_elem = 0; } } } ACE_CATCHANY { delete _tao_elem; _tao_elem = 0; return 0; } ACE_ENDTRY; return 0; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::POAManager::AdapterInactive *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::POAManager::_tc_AdapterInactive, ACE_TRY_ENV)) // not equal { _tao_elem = 0; return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (PortableServer::POAManager::AdapterInactive *)_tao_any.value (); return 1; } else { ACE_NEW_RETURN (_tao_elem, PortableServer::POAManager::AdapterInactive, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); if (stream >> *(PortableServer::POAManager::AdapterInactive *)_tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::POAManager::_tc_AdapterInactive, 1, ACE_reinterpret_cast (void *, ACE_const_cast (PortableServer::POAManager::AdapterInactive *&, _tao_elem)), ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else { delete ACE_const_cast (PortableServer::POAManager::AdapterInactive *&, _tao_elem); _tao_elem = 0; } } } ACE_CATCHANY { delete ACE_const_cast (PortableServer::POAManager::AdapterInactive *&, _tao_elem); _tao_elem = 0; return 0; } ACE_ENDTRY; return 0; } #if (TAO_HAS_MINIMUM_POA == 0) void operator<<= (CORBA::Any &_tao_any, PortableServer::AdapterActivator_ptr _tao_elem) { CORBA::Object_ptr *_tao_obj_ptr = 0; ACE_TRY_NEW_ENV { ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); *_tao_obj_ptr = PortableServer::AdapterActivator::_duplicate (_tao_elem); TAO_OutputCDR stream; if (stream << *_tao_obj_ptr) { _tao_any._tao_replace ( PortableServer::_tc_AdapterActivator, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_obj_ptr, ACE_TRY_ENV ); ACE_TRY_CHECK; } else { delete _tao_obj_ptr; } } ACE_CATCHANY { delete _tao_obj_ptr; } ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::AdapterActivator_ptr &_tao_elem) { CORBA::Object_ptr *tmp = 0; ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = PortableServer::AdapterActivator::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::_tc_AdapterActivator, ACE_TRY_ENV)) // not equal { delete tmp; return 0; } ACE_TRY_CHECK; TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); CORBA::Object_var _tao_obj_var; if (stream >> _tao_obj_var.out ()) { _tao_elem = PortableServer::AdapterActivator::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); ACE_TRY_CHECK; *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::_tc_AdapterActivator, 1, tmp, ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else // failure { delete tmp; } } ACE_CATCHANY { delete tmp; _tao_elem = PortableServer::AdapterActivator::_nil (); return 0; } ACE_ENDTRY; _tao_elem = PortableServer::AdapterActivator::_nil (); return 0; } void operator<<= (CORBA::Any &_tao_any, PortableServer::ServantLocator_ptr _tao_elem) { CORBA::Object_ptr *_tao_obj_ptr = 0; ACE_TRY_NEW_ENV { ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); *_tao_obj_ptr = PortableServer::ServantLocator::_duplicate (_tao_elem); TAO_OutputCDR stream; if (stream << *_tao_obj_ptr) { _tao_any._tao_replace ( PortableServer::_tc_ServantLocator, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_obj_ptr, ACE_TRY_ENV ); ACE_TRY_CHECK; } else { delete _tao_obj_ptr; } } ACE_CATCHANY { delete _tao_obj_ptr; } ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ServantLocator_ptr &_tao_elem) { CORBA::Object_ptr *tmp = 0; ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = PortableServer::ServantLocator::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::_tc_ServantLocator, ACE_TRY_ENV)) // not equal { delete tmp; return 0; } ACE_TRY_CHECK; TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); CORBA::Object_var _tao_obj_var; if (stream >> _tao_obj_var.out ()) { _tao_elem = PortableServer::ServantLocator::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); ACE_TRY_CHECK; *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::_tc_ServantLocator, 1, tmp, ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else // failure { delete tmp; } } ACE_CATCHANY { delete tmp; _tao_elem = PortableServer::ServantLocator::_nil (); return 0; } ACE_ENDTRY; _tao_elem = PortableServer::ServantLocator::_nil (); return 0; } void operator<<= (CORBA::Any &_tao_any, PortableServer::ServantManager_ptr _tao_elem) { CORBA::Object_ptr *_tao_obj_ptr = 0; ACE_TRY_NEW_ENV { ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); *_tao_obj_ptr = PortableServer::ServantManager::_duplicate (_tao_elem); TAO_OutputCDR stream; if (stream << *_tao_obj_ptr) { _tao_any._tao_replace ( PortableServer::_tc_ServantManager, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_obj_ptr, ACE_TRY_ENV ); ACE_TRY_CHECK; } else { delete _tao_obj_ptr; } } ACE_CATCHANY { delete _tao_obj_ptr; } ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ServantManager_ptr &_tao_elem) { CORBA::Object_ptr *tmp = 0; ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = PortableServer::ServantManager::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::_tc_ServantManager, ACE_TRY_ENV)) // not equal { delete tmp; return 0; } ACE_TRY_CHECK; TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); CORBA::Object_var _tao_obj_var; if (stream >> _tao_obj_var.out ()) { _tao_elem = PortableServer::ServantManager::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); ACE_TRY_CHECK; *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::_tc_ServantManager, 1, tmp, ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else // failure { delete tmp; } } ACE_CATCHANY { delete tmp; _tao_elem = PortableServer::ServantManager::_nil (); return 0; } ACE_ENDTRY; _tao_elem = PortableServer::ServantManager::_nil (); return 0; } void operator<<= (CORBA::Any &_tao_any, PortableServer::ServantActivator_ptr _tao_elem) { CORBA::Object_ptr *_tao_obj_ptr = 0; ACE_TRY_NEW_ENV { ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); *_tao_obj_ptr = PortableServer::ServantActivator::_duplicate (_tao_elem); TAO_OutputCDR stream; if (stream << *_tao_obj_ptr) { _tao_any._tao_replace ( PortableServer::_tc_ServantActivator, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_obj_ptr, ACE_TRY_ENV ); ACE_TRY_CHECK; } else { delete _tao_obj_ptr; } } ACE_CATCHANY { delete _tao_obj_ptr; } ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ServantActivator_ptr &_tao_elem) { CORBA::Object_ptr *tmp = 0; ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = PortableServer::ServantActivator::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::_tc_ServantActivator, ACE_TRY_ENV)) // not equal { delete tmp; return 0; } ACE_TRY_CHECK; TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); CORBA::Object_var _tao_obj_var; if (stream >> _tao_obj_var.out ()) { _tao_elem = PortableServer::ServantActivator::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); ACE_TRY_CHECK; *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::_tc_ServantActivator, 1, tmp, ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else // failure { delete tmp; } } ACE_CATCHANY { delete tmp; _tao_elem = PortableServer::ServantActivator::_nil (); return 0; } ACE_ENDTRY; _tao_elem = PortableServer::ServantActivator::_nil (); return 0; } #endif /* TAO_HAS_MINIMUM_POA == 0 */ void operator<<= (CORBA::Any &_tao_any, PortableServer::POA_ptr _tao_elem) { CORBA::Object_ptr *_tao_obj_ptr = 0; ACE_TRY_NEW_ENV { ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); *_tao_obj_ptr = PortableServer::POA::_duplicate (_tao_elem); TAO_OutputCDR stream; if (stream << *_tao_obj_ptr) { _tao_any._tao_replace ( PortableServer::_tc_POA, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_obj_ptr, ACE_TRY_ENV ); ACE_TRY_CHECK; } else { delete _tao_obj_ptr; } } ACE_CATCHANY { delete _tao_obj_ptr; } ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA_ptr &_tao_elem) { CORBA::Object_ptr *tmp = 0; ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = PortableServer::POA::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (PortableServer::_tc_POA, ACE_TRY_ENV)) // not equal { delete tmp; return 0; } ACE_TRY_CHECK; TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); CORBA::Object_var _tao_obj_var; if (stream >> _tao_obj_var.out ()) { _tao_elem = PortableServer::POA::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); ACE_TRY_CHECK; *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object ((CORBA::Any *)&_tao_any)->_tao_replace ( PortableServer::_tc_POA, 1, tmp, ACE_TRY_ENV ); ACE_TRY_CHECK; return 1; } else // failure { delete tmp; } } ACE_CATCHANY { delete tmp; _tao_elem = PortableServer::POA::_nil (); return 0; } ACE_ENDTRY; _tao_elem = PortableServer::POA::_nil (); return 0; }