diff options
Diffstat (limited to 'TAO')
-rw-r--r-- | TAO/tao/MessagingC.cpp | 1675 | ||||
-rw-r--r-- | TAO/tao/MessagingC.h | 78 | ||||
-rw-r--r-- | TAO/tao/MessagingC.i | 555 | ||||
-rw-r--r-- | TAO/tao/POAC.cpp | 4732 | ||||
-rw-r--r-- | TAO/tao/POAC.h | 275 | ||||
-rw-r--r-- | TAO/tao/POAC.i | 286 | ||||
-rw-r--r-- | TAO/tao/PolicyC.cpp | 162 | ||||
-rw-r--r-- | TAO/tao/PolicyC.h | 56 | ||||
-rw-r--r-- | TAO/tao/PolicyC.i | 77 |
9 files changed, 6799 insertions, 1097 deletions
diff --git a/TAO/tao/MessagingC.cpp b/TAO/tao/MessagingC.cpp index 4f2d02b7ae4..5eb5db6e013 100644 --- a/TAO/tao/MessagingC.cpp +++ b/TAO/tao/MessagingC.cpp @@ -2073,14 +2073,185 @@ TAO_NAMESPACE_END // **************************************************************** +void operator<<= (CORBA::Any &_tao_any, Messaging::RebindPolicy_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 = Messaging::RebindPolicy::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + Messaging::_tc_RebindPolicy, + 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, Messaging::RebindPolicy_ptr &_tao_elem) +{ + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); + ACE_TRY_NEW_ENV + { + _tao_elem = Messaging::RebindPolicy::_nil (); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (Messaging::_tc_RebindPolicy, 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 = Messaging::RebindPolicy::_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 ( + Messaging::_tc_RebindPolicy, + 1, + tmp, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else // failure + { + delete tmp; + } + } + ACE_CATCHANY + { + delete tmp; + _tao_elem = Messaging::RebindPolicy::_nil (); + return 0; + } + ACE_ENDTRY; + _tao_elem = Messaging::RebindPolicy::_nil (); + return 0; +} + +void operator<<= (CORBA::Any &_tao_any, Messaging::SyncScopePolicy_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 = Messaging::SyncScopePolicy::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + Messaging::_tc_SyncScopePolicy, + 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, Messaging::SyncScopePolicy_ptr &_tao_elem) +{ + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); + ACE_TRY_NEW_ENV + { + _tao_elem = Messaging::SyncScopePolicy::_nil (); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (Messaging::_tc_SyncScopePolicy, 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 = Messaging::SyncScopePolicy::_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 ( + Messaging::_tc_SyncScopePolicy, + 1, + tmp, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else // failure + { + delete tmp; + } + } + ACE_CATCHANY + { + delete tmp; + _tao_elem = Messaging::SyncScopePolicy::_nil (); + return 0; + } + ACE_ENDTRY; + _tao_elem = Messaging::SyncScopePolicy::_nil (); + return 0; +} + void operator<<= (CORBA::Any &_tao_any, const Messaging::PriorityRange &_tao_elem) // copying { - Messaging::PriorityRange *_any_val; + Messaging::PriorityRange *_any_val = 0; ACE_NEW (_any_val, Messaging::PriorityRange (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (Messaging::_tc_PriorityRange, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + Messaging::_tc_PriorityRange, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -2094,10 +2265,23 @@ void operator<<= (CORBA::Any &_tao_any, Messaging::PriorityRange *_tao_elem) // { ACE_TRY_NEW_ENV { - _tao_any.replace (Messaging::_tc_PriorityRange, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + Messaging::_tc_PriorityRange, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } - ACE_CATCHANY {} + ACE_CATCHANY + { + delete _tao_elem; + _tao_elem = 0; + } ACE_ENDTRY; } @@ -2106,37 +2290,748 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::PriorityRange ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (Messaging::_tc_PriorityRange, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (Messaging::_tc_PriorityRange, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (Messaging::PriorityRange *)_tao_any.value (); return 1; - } + } else { ACE_NEW_RETURN (_tao_elem, Messaging::PriorityRange, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (Messaging::_tc_PriorityRange, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA::Any *)&_tao_any)->replace (Messaging::_tc_PriorityRange, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + Messaging::_tc_PriorityRange, + 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 Messaging::PriorityRange *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (Messaging::_tc_PriorityRange, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (Messaging::PriorityRange *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, Messaging::PriorityRange, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(Messaging::PriorityRange *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + Messaging::_tc_PriorityRange, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (Messaging::PriorityRange *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (Messaging::PriorityRange *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (Messaging::PriorityRange *&, _tao_elem); + _tao_elem = 0; + return 0; + } + ACE_ENDTRY; + return 0; +} + +void operator<<= (CORBA::Any &_tao_any, Messaging::RequestPriorityPolicy_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 = Messaging::RequestPriorityPolicy::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + Messaging::_tc_RequestPriorityPolicy, + 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, Messaging::RequestPriorityPolicy_ptr &_tao_elem) +{ + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); + ACE_TRY_NEW_ENV + { + _tao_elem = Messaging::RequestPriorityPolicy::_nil (); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (Messaging::_tc_RequestPriorityPolicy, 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 = Messaging::RequestPriorityPolicy::_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 ( + Messaging::_tc_RequestPriorityPolicy, + 1, + tmp, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else // failure + { + delete tmp; + } + } + ACE_CATCHANY + { + delete tmp; + _tao_elem = Messaging::RequestPriorityPolicy::_nil (); + return 0; + } + ACE_ENDTRY; + _tao_elem = Messaging::RequestPriorityPolicy::_nil (); + return 0; +} + +void operator<<= (CORBA::Any &_tao_any, Messaging::ReplyPriorityPolicy_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 = Messaging::ReplyPriorityPolicy::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + Messaging::_tc_ReplyPriorityPolicy, + 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, Messaging::ReplyPriorityPolicy_ptr &_tao_elem) +{ + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); + ACE_TRY_NEW_ENV + { + _tao_elem = Messaging::ReplyPriorityPolicy::_nil (); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (Messaging::_tc_ReplyPriorityPolicy, 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 = Messaging::ReplyPriorityPolicy::_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 ( + Messaging::_tc_ReplyPriorityPolicy, + 1, + tmp, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else // failure + { + delete tmp; + } + } + ACE_CATCHANY + { + delete tmp; + _tao_elem = Messaging::ReplyPriorityPolicy::_nil (); + return 0; + } + ACE_ENDTRY; + _tao_elem = Messaging::ReplyPriorityPolicy::_nil (); + return 0; +} + +void operator<<= (CORBA::Any &_tao_any, Messaging::RequestStartTimePolicy_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 = Messaging::RequestStartTimePolicy::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + Messaging::_tc_RequestStartTimePolicy, + 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, Messaging::RequestStartTimePolicy_ptr &_tao_elem) +{ + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); + ACE_TRY_NEW_ENV + { + _tao_elem = Messaging::RequestStartTimePolicy::_nil (); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (Messaging::_tc_RequestStartTimePolicy, 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 = Messaging::RequestStartTimePolicy::_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 ( + Messaging::_tc_RequestStartTimePolicy, + 1, + tmp, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else // failure + { + delete tmp; + } + } + ACE_CATCHANY + { + delete tmp; + _tao_elem = Messaging::RequestStartTimePolicy::_nil (); + return 0; + } + ACE_ENDTRY; + _tao_elem = Messaging::RequestStartTimePolicy::_nil (); + return 0; +} + +void operator<<= (CORBA::Any &_tao_any, Messaging::RequestEndTimePolicy_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 = Messaging::RequestEndTimePolicy::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + Messaging::_tc_RequestEndTimePolicy, + 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, Messaging::RequestEndTimePolicy_ptr &_tao_elem) +{ + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); + ACE_TRY_NEW_ENV + { + _tao_elem = Messaging::RequestEndTimePolicy::_nil (); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (Messaging::_tc_RequestEndTimePolicy, 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 = Messaging::RequestEndTimePolicy::_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 ( + Messaging::_tc_RequestEndTimePolicy, + 1, + tmp, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else // failure + { + delete tmp; + } + } + ACE_CATCHANY + { + delete tmp; + _tao_elem = Messaging::RequestEndTimePolicy::_nil (); + return 0; + } + ACE_ENDTRY; + _tao_elem = Messaging::RequestEndTimePolicy::_nil (); + return 0; +} + +void operator<<= (CORBA::Any &_tao_any, Messaging::ReplyStartTimePolicy_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 = Messaging::ReplyStartTimePolicy::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + Messaging::_tc_ReplyStartTimePolicy, + 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, Messaging::ReplyStartTimePolicy_ptr &_tao_elem) +{ + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); + ACE_TRY_NEW_ENV + { + _tao_elem = Messaging::ReplyStartTimePolicy::_nil (); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (Messaging::_tc_ReplyStartTimePolicy, 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 = Messaging::ReplyStartTimePolicy::_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 ( + Messaging::_tc_ReplyStartTimePolicy, + 1, + tmp, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else // failure + { + delete tmp; + } + } + ACE_CATCHANY + { + delete tmp; + _tao_elem = Messaging::ReplyStartTimePolicy::_nil (); + return 0; + } + ACE_ENDTRY; + _tao_elem = Messaging::ReplyStartTimePolicy::_nil (); + return 0; +} + +void operator<<= (CORBA::Any &_tao_any, Messaging::ReplyEndTimePolicy_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 = Messaging::ReplyEndTimePolicy::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + Messaging::_tc_ReplyEndTimePolicy, + 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, Messaging::ReplyEndTimePolicy_ptr &_tao_elem) +{ + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); + ACE_TRY_NEW_ENV + { + _tao_elem = Messaging::ReplyEndTimePolicy::_nil (); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (Messaging::_tc_ReplyEndTimePolicy, 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 = Messaging::ReplyEndTimePolicy::_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 ( + Messaging::_tc_ReplyEndTimePolicy, + 1, + tmp, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else // failure + { + delete tmp; + } + } + ACE_CATCHANY + { + delete tmp; + _tao_elem = Messaging::ReplyEndTimePolicy::_nil (); + return 0; + } + ACE_ENDTRY; + _tao_elem = Messaging::ReplyEndTimePolicy::_nil (); + return 0; +} + +void operator<<= (CORBA::Any &_tao_any, Messaging::RelativeRequestTimeoutPolicy_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 = Messaging::RelativeRequestTimeoutPolicy::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + Messaging::_tc_RelativeRequestTimeoutPolicy, + 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, Messaging::RelativeRequestTimeoutPolicy_ptr &_tao_elem) +{ + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); + ACE_TRY_NEW_ENV + { + _tao_elem = Messaging::RelativeRequestTimeoutPolicy::_nil (); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (Messaging::_tc_RelativeRequestTimeoutPolicy, 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 = Messaging::RelativeRequestTimeoutPolicy::_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 ( + Messaging::_tc_RelativeRequestTimeoutPolicy, + 1, + tmp, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else // failure + { + delete tmp; + } + } + ACE_CATCHANY + { + delete tmp; + _tao_elem = Messaging::RelativeRequestTimeoutPolicy::_nil (); + return 0; + } + ACE_ENDTRY; + _tao_elem = Messaging::RelativeRequestTimeoutPolicy::_nil (); + return 0; +} + +void operator<<= (CORBA::Any &_tao_any, Messaging::RelativeRoundtripTimeoutPolicy_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 = Messaging::RelativeRoundtripTimeoutPolicy::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + Messaging::_tc_RelativeRoundtripTimeoutPolicy, + 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, Messaging::RelativeRoundtripTimeoutPolicy_ptr &_tao_elem) +{ + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); + ACE_TRY_NEW_ENV + { + _tao_elem = Messaging::RelativeRoundtripTimeoutPolicy::_nil (); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (Messaging::_tc_RelativeRoundtripTimeoutPolicy, 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 = Messaging::RelativeRoundtripTimeoutPolicy::_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 ( + Messaging::_tc_RelativeRoundtripTimeoutPolicy, + 1, + tmp, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else // failure + { + delete tmp; + } + } + ACE_CATCHANY + { + delete tmp; + _tao_elem = Messaging::RelativeRoundtripTimeoutPolicy::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = Messaging::RelativeRoundtripTimeoutPolicy::_nil (); return 0; } @@ -2144,12 +3039,21 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::PriorityRange void operator<<= (CORBA::Any &_tao_any, const Messaging::RoutingTypeRange &_tao_elem) // copying { - Messaging::RoutingTypeRange *_any_val; + Messaging::RoutingTypeRange *_any_val = 0; ACE_NEW (_any_val, Messaging::RoutingTypeRange (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (Messaging::_tc_RoutingTypeRange, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + Messaging::_tc_RoutingTypeRange, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -2163,10 +3067,23 @@ void operator<<= (CORBA::Any &_tao_any, Messaging::RoutingTypeRange *_tao_elem) { ACE_TRY_NEW_ENV { - _tao_any.replace (Messaging::_tc_RoutingTypeRange, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + Messaging::_tc_RoutingTypeRange, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } - ACE_CATCHANY {} + ACE_CATCHANY + { + delete _tao_elem; + _tao_elem = 0; + } ACE_ENDTRY; } @@ -2175,35 +3092,98 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::RoutingTypeRa ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (Messaging::_tc_RoutingTypeRange, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (Messaging::_tc_RoutingTypeRange, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (Messaging::RoutingTypeRange *)_tao_any.value (); return 1; - } + } else { ACE_NEW_RETURN (_tao_elem, Messaging::RoutingTypeRange, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (Messaging::_tc_RoutingTypeRange, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA::Any *)&_tao_any)->replace (Messaging::_tc_RoutingTypeRange, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + Messaging::_tc_RoutingTypeRange, + 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; - return 0; + _tao_elem = 0; + return 0; + } + ACE_ENDTRY; + return 0; +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const Messaging::RoutingTypeRange *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (Messaging::_tc_RoutingTypeRange, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (Messaging::RoutingTypeRange *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, Messaging::RoutingTypeRange, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(Messaging::RoutingTypeRange *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + Messaging::_tc_RoutingTypeRange, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (Messaging::RoutingTypeRange *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (Messaging::RoutingTypeRange *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (Messaging::RoutingTypeRange *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; @@ -2211,14 +3191,266 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::RoutingTypeRa // **************************************************************** +void operator<<= (CORBA::Any &_tao_any, Messaging::RoutingPolicy_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 = Messaging::RoutingPolicy::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + Messaging::_tc_RoutingPolicy, + 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, Messaging::RoutingPolicy_ptr &_tao_elem) +{ + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); + ACE_TRY_NEW_ENV + { + _tao_elem = Messaging::RoutingPolicy::_nil (); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (Messaging::_tc_RoutingPolicy, 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 = Messaging::RoutingPolicy::_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 ( + Messaging::_tc_RoutingPolicy, + 1, + tmp, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else // failure + { + delete tmp; + } + } + ACE_CATCHANY + { + delete tmp; + _tao_elem = Messaging::RoutingPolicy::_nil (); + return 0; + } + ACE_ENDTRY; + _tao_elem = Messaging::RoutingPolicy::_nil (); + return 0; +} + +void operator<<= (CORBA::Any &_tao_any, Messaging::MaxHopsPolicy_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 = Messaging::MaxHopsPolicy::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + Messaging::_tc_MaxHopsPolicy, + 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, Messaging::MaxHopsPolicy_ptr &_tao_elem) +{ + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); + ACE_TRY_NEW_ENV + { + _tao_elem = Messaging::MaxHopsPolicy::_nil (); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (Messaging::_tc_MaxHopsPolicy, 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 = Messaging::MaxHopsPolicy::_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 ( + Messaging::_tc_MaxHopsPolicy, + 1, + tmp, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else // failure + { + delete tmp; + } + } + ACE_CATCHANY + { + delete tmp; + _tao_elem = Messaging::MaxHopsPolicy::_nil (); + return 0; + } + ACE_ENDTRY; + _tao_elem = Messaging::MaxHopsPolicy::_nil (); + return 0; +} + +void operator<<= (CORBA::Any &_tao_any, Messaging::QueueOrderPolicy_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 = Messaging::QueueOrderPolicy::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + Messaging::_tc_QueueOrderPolicy, + 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, Messaging::QueueOrderPolicy_ptr &_tao_elem) +{ + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); + ACE_TRY_NEW_ENV + { + _tao_elem = Messaging::QueueOrderPolicy::_nil (); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (Messaging::_tc_QueueOrderPolicy, 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 = Messaging::QueueOrderPolicy::_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 ( + Messaging::_tc_QueueOrderPolicy, + 1, + tmp, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else // failure + { + delete tmp; + } + } + ACE_CATCHANY + { + delete tmp; + _tao_elem = Messaging::QueueOrderPolicy::_nil (); + return 0; + } + ACE_ENDTRY; + _tao_elem = Messaging::QueueOrderPolicy::_nil (); + return 0; +} + void operator<<= (CORBA::Any &_tao_any, const Messaging::PolicyValue &_tao_elem) // copying { - Messaging::PolicyValue *_any_val; + Messaging::PolicyValue *_any_val = 0; ACE_NEW (_any_val, Messaging::PolicyValue (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (Messaging::_tc_PolicyValue, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + Messaging::_tc_PolicyValue, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -2232,10 +3464,23 @@ void operator<<= (CORBA::Any &_tao_any, Messaging::PolicyValue *_tao_elem) // no { ACE_TRY_NEW_ENV { - _tao_any.replace (Messaging::_tc_PolicyValue, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + Messaging::_tc_PolicyValue, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } - ACE_CATCHANY {} + ACE_CATCHANY + { + delete _tao_elem; + _tao_elem = 0; + } ACE_ENDTRY; } @@ -2244,35 +3489,98 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::PolicyValue * ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (Messaging::_tc_PolicyValue, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (Messaging::_tc_PolicyValue, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (Messaging::PolicyValue *)_tao_any.value (); return 1; - } + } else { ACE_NEW_RETURN (_tao_elem, Messaging::PolicyValue, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (Messaging::_tc_PolicyValue, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA::Any *)&_tao_any)->replace (Messaging::_tc_PolicyValue, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + Messaging::_tc_PolicyValue, + 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; - return 0; + _tao_elem = 0; + return 0; + } + ACE_ENDTRY; + return 0; +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const Messaging::PolicyValue *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (Messaging::_tc_PolicyValue, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (Messaging::PolicyValue *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, Messaging::PolicyValue, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(Messaging::PolicyValue *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + Messaging::_tc_PolicyValue, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (Messaging::PolicyValue *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (Messaging::PolicyValue *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (Messaging::PolicyValue *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; @@ -2290,8 +3598,23 @@ void operator<<= ( if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (Messaging::_tc_PolicyValueSeq, _tao_any_val, 1, ACE_TRY_ENV); // copy the value - ACE_TRY_CHECK; + TAO_OutputCDR stream; + if (stream << *_tao_any_val) + { + _tao_any._tao_replace ( + Messaging::_tc_PolicyValueSeq, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_any_val; + } } ACE_CATCHANY { @@ -2304,10 +3627,23 @@ void operator<<= (CORBA::Any &_tao_any, Messaging::PolicyValueSeq *_tao_elem) // { ACE_TRY_NEW_ENV { - _tao_any.replace (Messaging::_tc_PolicyValueSeq, _tao_elem, 0, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + Messaging::_tc_PolicyValueSeq, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } - ACE_CATCHANY {} + ACE_CATCHANY + { + delete _tao_elem; + _tao_elem = 0; + } ACE_ENDTRY; } @@ -2316,7 +3652,11 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::PolicyValueSe ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (Messaging::_tc_PolicyValueSeq, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (Messaging::_tc_PolicyValueSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { @@ -2326,25 +3666,84 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::PolicyValueSe else { ACE_NEW_RETURN (_tao_elem, Messaging::PolicyValueSeq, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (Messaging::_tc_PolicyValueSeq, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA::Any *)&_tao_any)->replace (Messaging::_tc_PolicyValueSeq, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + Messaging::_tc_PolicyValueSeq, + 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; - return 0; + _tao_elem = 0; + return 0; + } + ACE_ENDTRY; + return 0; +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const Messaging::PolicyValueSeq *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (Messaging::_tc_PolicyValueSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (Messaging::PolicyValueSeq *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, Messaging::PolicyValueSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(Messaging::PolicyValueSeq *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + Messaging::_tc_PolicyValueSeq, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (Messaging::PolicyValueSeq *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (Messaging::PolicyValueSeq *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (Messaging::PolicyValueSeq *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; @@ -2365,8 +3764,23 @@ void operator<<= (CORBA::Any &_tao_any, Messaging::ReplyHandler_ptr _tao_elem) { ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); *_tao_obj_ptr = Messaging::ReplyHandler::_duplicate (_tao_elem); - _tao_any.replace (Messaging::_tc_ReplyHandler, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + Messaging::_tc_ReplyHandler, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -2378,38 +3792,134 @@ void operator<<= (CORBA::Any &_tao_any, Messaging::ReplyHandler_ptr _tao_elem) CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::ReplyHandler_ptr &_tao_elem) { CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = Messaging::ReplyHandler::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (Messaging::_tc_ReplyHandler, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (Messaging::_tc_ReplyHandler, 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 ()); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); CORBA::Object_var _tao_obj_var; - ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); - if (stream.decode (Messaging::_tc_ReplyHandler, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + if (stream >> _tao_obj_var.out ()) { _tao_elem = Messaging::ReplyHandler::_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)->replace (Messaging::_tc_ReplyHandler, tmp, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + Messaging::_tc_ReplyHandler, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = Messaging::ReplyHandler::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = Messaging::ReplyHandler::_nil (); return 0; } -#endif /* TAO_HAS_AMI_CALLBACK == 1 || TAO_HAS_AMI_POLLER == 1 */ +void operator<<= (CORBA::Any &_tao_any, Messaging::ExceptionHolder_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 = Messaging::ExceptionHolder::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + Messaging::_tc_ExceptionHolder, + 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, Messaging::ExceptionHolder_ptr &_tao_elem) +{ + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); + ACE_TRY_NEW_ENV + { + _tao_elem = Messaging::ExceptionHolder::_nil (); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (Messaging::_tc_ExceptionHolder, 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 = Messaging::ExceptionHolder::_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 ( + Messaging::_tc_ExceptionHolder, + 1, + tmp, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else // failure + { + delete tmp; + } + } + ACE_CATCHANY + { + delete tmp; + _tao_elem = Messaging::ExceptionHolder::_nil (); + return 0; + } + ACE_ENDTRY; + _tao_elem = Messaging::ExceptionHolder::_nil (); + return 0; +} + +#endif /* TAO_HAS_AMI_CALLBACK == 1 || TAO_HAS_AMI_POLLER */ // **************************************************************** @@ -2422,8 +3932,23 @@ void operator<<= (CORBA::Any &_tao_any, Messaging::Poller_ptr _tao_elem) { ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); *_tao_obj_ptr = Messaging::Poller::_duplicate (_tao_elem); - _tao_any.replace (Messaging::_tc_Poller, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + Messaging::_tc_Poller, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -2435,36 +3960,52 @@ void operator<<= (CORBA::Any &_tao_any, Messaging::Poller_ptr _tao_elem) CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::Poller_ptr &_tao_elem) { CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = Messaging::Poller::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (Messaging::_tc_Poller, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (Messaging::_tc_Poller, 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 ()); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); CORBA::Object_var _tao_obj_var; - ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); - if (stream.decode (Messaging::_tc_Poller, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + if (stream >> _tao_obj_var.out ()) { _tao_elem = Messaging::Poller::_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)->replace (Messaging::_tc_Poller, tmp, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + Messaging::_tc_Poller, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = Messaging::Poller::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = Messaging::Poller::_nil (); return 0; } + #endif /* TAO_HAS_AMI_POLLER == 1 */ #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) diff --git a/TAO/tao/MessagingC.h b/TAO/tao/MessagingC.h index cd12cbb51de..db320714f78 100644 --- a/TAO/tao/MessagingC.h +++ b/TAO/tao/MessagingC.h @@ -2099,19 +2099,64 @@ typedef void (*TAO_Reply_Handler_Skeleton)( ); #endif /* TAO_HAS_AMI_CALLBACK == 1 */ +TAO_Export void operator<<= (CORBA::Any &, Messaging::RebindPolicy_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, Messaging::RebindPolicy *&); + +TAO_Export void operator<<= (CORBA::Any &, Messaging::SyncScopePolicy_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, Messaging::SyncScopePolicy *&); + +TAO_Export void operator<<= (CORBA::Any &, const Messaging::PriorityRange &); // copying version TAO_Export void operator<<= (CORBA::Any &, Messaging::PriorityRange*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, Messaging::PriorityRange *&); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, Messaging::PriorityRange *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const Messaging::PriorityRange *&); + +TAO_Export void operator<<= (CORBA::Any &, Messaging::RequestPriorityPolicy_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, Messaging::RequestPriorityPolicy *&); + +TAO_Export void operator<<= (CORBA::Any &, Messaging::ReplyPriorityPolicy_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, Messaging::ReplyPriorityPolicy *&); + +TAO_Export void operator<<= (CORBA::Any &, Messaging::RequestStartTimePolicy_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, Messaging::RequestStartTimePolicy *&); + +TAO_Export void operator<<= (CORBA::Any &, Messaging::RequestEndTimePolicy_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, Messaging::RequestEndTimePolicy *&); + +TAO_Export void operator<<= (CORBA::Any &, Messaging::ReplyStartTimePolicy_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, Messaging::ReplyStartTimePolicy *&); + +TAO_Export void operator<<= (CORBA::Any &, Messaging::ReplyEndTimePolicy_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, Messaging::ReplyEndTimePolicy *&); + +TAO_Export void operator<<= (CORBA::Any &, Messaging::RelativeRequestTimeoutPolicy_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, Messaging::RelativeRequestTimeoutPolicy *&); + +TAO_Export void operator<<= (CORBA::Any &, Messaging::RelativeRoundtripTimeoutPolicy_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, Messaging::RelativeRoundtripTimeoutPolicy *&); TAO_Export void operator<<= (CORBA::Any &, const Messaging::RoutingTypeRange &); // copying version TAO_Export void operator<<= (CORBA::Any &, Messaging::RoutingTypeRange*); // noncopying version TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, Messaging::RoutingTypeRange *&); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const Messaging::RoutingTypeRange *&); + +TAO_Export void operator<<= (CORBA::Any &, Messaging::RoutingPolicy_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, Messaging::RoutingPolicy *&); + +TAO_Export void operator<<= (CORBA::Any &, Messaging::MaxHopsPolicy_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, Messaging::MaxHopsPolicy *&); + +TAO_Export void operator<<= (CORBA::Any &, Messaging::QueueOrderPolicy_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, Messaging::QueueOrderPolicy *&); TAO_Export void operator<<= (CORBA::Any &, const Messaging::PolicyValue &); // copying version TAO_Export void operator<<= (CORBA::Any &, Messaging::PolicyValue*); // noncopying version TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, Messaging::PolicyValue *&); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const Messaging::PolicyValue *&); + TAO_Export void operator<<= (CORBA::Any &, const Messaging::PolicyValueSeq &); // copying version TAO_Export void operator<<= (CORBA::Any &, Messaging::PolicyValueSeq*); // noncopying version TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, Messaging::PolicyValueSeq *&); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const Messaging::PolicyValueSeq *&); #if (TAO_HAS_AMI_CALLBACK == 1) extern TAO_Export Messaging::ReplyHandler_ptr (*_TAO_collocation_Messaging_ReplyHandler_Stub_Factory_function_pointer) ( @@ -2120,8 +2165,9 @@ extern TAO_Export Messaging::ReplyHandler_ptr (*_TAO_collocation_Messaging_Repl // Any operators for interface Messaging::ReplyHandler TAO_Export void operator<<= (CORBA::Any &, Messaging::ReplyHandler_ptr); TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, Messaging::ReplyHandler *&); -TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::ExceptionHolder *); // -TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::ExceptionHolder *&); + +TAO_Export void operator<<= (CORBA::Any &, const Messaging::ExceptionHolder_ptr); // +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, Messaging::ExceptionHolder *&); #endif /* TAO_HAS_AMI_CALLBACK == 1 */ #if (TAO_HAS_AMI_POLLER == 1) @@ -2132,10 +2178,36 @@ TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, Messaging::Poller *&) #ifndef __ACE_INLINE__ +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::RebindPolicy_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::RebindPolicy_ptr &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::SyncScopePolicy_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::SyncScopePolicy_ptr &); TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::PriorityRange &); // TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::PriorityRange &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::RequestPriorityPolicy_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::RequestPriorityPolicy_ptr &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::ReplyPriorityPolicy_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::ReplyPriorityPolicy_ptr &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::RequestStartTimePolicy_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::RequestStartTimePolicy_ptr &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::RequestEndTimePolicy_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::RequestEndTimePolicy_ptr &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::ReplyStartTimePolicy_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::ReplyStartTimePolicy_ptr &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::ReplyEndTimePolicy_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::ReplyEndTimePolicy_ptr &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::RelativeRequestTimeoutPolicy_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::RelativeRequestTimeoutPolicy_ptr &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::RelativeRoundtripTimeoutPolicy_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::RelativeRoundtripTimeoutPolicy_ptr &); TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::RoutingTypeRange &); // TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::RoutingTypeRange &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::RoutingPolicy_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::RoutingPolicy_ptr &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::MaxHopsPolicy_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::MaxHopsPolicy_ptr &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::QueueOrderPolicy_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::QueueOrderPolicy_ptr &); TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::PolicyValue &); // TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::PolicyValue &); TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::PolicyValue::_tao_seq_Octet &); // diff --git a/TAO/tao/MessagingC.i b/TAO/tao/MessagingC.i index 8678acf74b9..7a10f63abde 100644 --- a/TAO/tao/MessagingC.i +++ b/TAO/tao/MessagingC.i @@ -3774,9 +3774,102 @@ Messaging::Poller_out::operator-> (void) return this->ptr_; } +#endif /* TAO_HAS_AMI_POLLER == 1 */ + // **************************************************************** -ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const Messaging::PriorityRange &_tao_aggregate) +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const Messaging::RebindPolicy_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + Messaging::RebindPolicy_ptr &_tao_objref + ) +{ + ACE_TRY_NEW_ENV + { + CORBA::Object_var obj; + if ((strm >> obj.inout ()) == 0) + return 0; + // narrow to the right type + _tao_objref = + Messaging::RebindPolicy::_narrow ( + obj.in (), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + ACE_CATCHANY + { + // do nothing + } + ACE_ENDTRY; + return 0; +} + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &, + const Messaging::SyncScopePolicy_ptr + ); +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &, + Messaging::SyncScopePolicy_ptr & + ); + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const Messaging::SyncScopePolicy_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + Messaging::SyncScopePolicy_ptr &_tao_objref + ) +{ + ACE_TRY_NEW_ENV + { + CORBA::Object_var obj; + if ((strm >> obj.inout ()) == 0) + return 0; + // narrow to the right type + _tao_objref = + Messaging::SyncScopePolicy::_narrow ( + obj.in (), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + ACE_CATCHANY + { + // do nothing + } + ACE_ENDTRY; + return 0; +} + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const Messaging::PriorityRange &_tao_aggregate + ) { if ( (strm << _tao_aggregate.min) && @@ -3788,7 +3881,11 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const Messaging::Prio } -ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, Messaging::PriorityRange &_tao_aggregate) +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + Messaging::PriorityRange &_tao_aggregate + ) { if ( (strm >> _tao_aggregate.min) && @@ -3800,9 +3897,317 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, Messaging::PriorityRan } +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const Messaging::RequestPriorityPolicy_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + Messaging::RequestPriorityPolicy_ptr &_tao_objref + ) +{ + ACE_TRY_NEW_ENV + { + CORBA::Object_var obj; + if ((strm >> obj.inout ()) == 0) + return 0; + // narrow to the right type + _tao_objref = + Messaging::RequestPriorityPolicy::_narrow ( + obj.in (), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + ACE_CATCHANY + { + // do nothing + } + ACE_ENDTRY; + return 0; +} + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const Messaging::ReplyPriorityPolicy_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + Messaging::ReplyPriorityPolicy_ptr &_tao_objref + ) +{ + ACE_TRY_NEW_ENV + { + CORBA::Object_var obj; + if ((strm >> obj.inout ()) == 0) + return 0; + // narrow to the right type + _tao_objref = + Messaging::ReplyPriorityPolicy::_narrow ( + obj.in (), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + ACE_CATCHANY + { + // do nothing + } + ACE_ENDTRY; + return 0; +} + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const Messaging::RequestStartTimePolicy_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + Messaging::RequestStartTimePolicy_ptr &_tao_objref + ) +{ + ACE_TRY_NEW_ENV + { + CORBA::Object_var obj; + if ((strm >> obj.inout ()) == 0) + return 0; + // narrow to the right type + _tao_objref = + Messaging::RequestStartTimePolicy::_narrow ( + obj.in (), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + ACE_CATCHANY + { + // do nothing + } + ACE_ENDTRY; + return 0; +} + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const Messaging::RequestEndTimePolicy_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + Messaging::RequestEndTimePolicy_ptr &_tao_objref + ) +{ + ACE_TRY_NEW_ENV + { + CORBA::Object_var obj; + if ((strm >> obj.inout ()) == 0) + return 0; + // narrow to the right type + _tao_objref = + Messaging::RequestEndTimePolicy::_narrow ( + obj.in (), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + ACE_CATCHANY + { + // do nothing + } + ACE_ENDTRY; + return 0; +} + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const Messaging::ReplyStartTimePolicy_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + Messaging::ReplyStartTimePolicy_ptr &_tao_objref + ) +{ + ACE_TRY_NEW_ENV + { + CORBA::Object_var obj; + if ((strm >> obj.inout ()) == 0) + return 0; + // narrow to the right type + _tao_objref = + Messaging::ReplyStartTimePolicy::_narrow ( + obj.in (), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + ACE_CATCHANY + { + // do nothing + } + ACE_ENDTRY; + return 0; +} + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const Messaging::ReplyEndTimePolicy_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + Messaging::ReplyEndTimePolicy_ptr &_tao_objref + ) +{ + ACE_TRY_NEW_ENV + { + CORBA::Object_var obj; + if ((strm >> obj.inout ()) == 0) + return 0; + // narrow to the right type + _tao_objref = + Messaging::ReplyEndTimePolicy::_narrow ( + obj.in (), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + ACE_CATCHANY + { + // do nothing + } + ACE_ENDTRY; + return 0; +} + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const Messaging::RelativeRequestTimeoutPolicy_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + Messaging::RelativeRequestTimeoutPolicy_ptr &_tao_objref + ) +{ + ACE_TRY_NEW_ENV + { + CORBA::Object_var obj; + if ((strm >> obj.inout ()) == 0) + return 0; + // narrow to the right type + _tao_objref = + Messaging::RelativeRequestTimeoutPolicy::_narrow ( + obj.in (), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + ACE_CATCHANY + { + // do nothing + } + ACE_ENDTRY; + return 0; +} + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const Messaging::RelativeRoundtripTimeoutPolicy_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + Messaging::RelativeRoundtripTimeoutPolicy_ptr &_tao_objref + ) +{ + ACE_TRY_NEW_ENV + { + CORBA::Object_var obj; + if ((strm >> obj.inout ()) == 0) + return 0; + // narrow to the right type + _tao_objref = + Messaging::RelativeRoundtripTimeoutPolicy::_narrow ( + obj.in (), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + ACE_CATCHANY + { + // do nothing + } + ACE_ENDTRY; + return 0; +} + // **************************************************************** -ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const Messaging::RoutingTypeRange &_tao_aggregate) +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const Messaging::RoutingTypeRange &_tao_aggregate + ) { if ( (strm << _tao_aggregate.min) && @@ -3814,7 +4219,11 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const Messaging::Rout } -ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, Messaging::RoutingTypeRange &_tao_aggregate) +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + Messaging::RoutingTypeRange &_tao_aggregate + ) { if ( (strm >> _tao_aggregate.min) && @@ -3826,6 +4235,120 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, Messaging::RoutingType } +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const Messaging::RoutingPolicy_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + Messaging::RoutingPolicy_ptr &_tao_objref + ) +{ + ACE_TRY_NEW_ENV + { + CORBA::Object_var obj; + if ((strm >> obj.inout ()) == 0) + return 0; + // narrow to the right type + _tao_objref = + Messaging::RoutingPolicy::_narrow ( + obj.in (), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + ACE_CATCHANY + { + // do nothing + } + ACE_ENDTRY; + return 0; +} + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const Messaging::MaxHopsPolicy_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + Messaging::MaxHopsPolicy_ptr &_tao_objref + ) +{ + ACE_TRY_NEW_ENV + { + CORBA::Object_var obj; + if ((strm >> obj.inout ()) == 0) + return 0; + // narrow to the right type + _tao_objref = + Messaging::MaxHopsPolicy::_narrow ( + obj.in (), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + ACE_CATCHANY + { + // do nothing + } + ACE_ENDTRY; + return 0; +} + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const Messaging::QueueOrderPolicy_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + Messaging::QueueOrderPolicy_ptr &_tao_objref + ) +{ + ACE_TRY_NEW_ENV + { + CORBA::Object_var obj; + if ((strm >> obj.inout ()) == 0) + return 0; + // narrow to the right type + _tao_objref = + Messaging::QueueOrderPolicy::_narrow ( + obj.in (), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + ACE_CATCHANY + { + // do nothing + } + ACE_ENDTRY; + return 0; +} + // **************************************************************** ACE_INLINE CORBA::Boolean operator<< ( @@ -3887,7 +4410,11 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, Messaging::PolicyValue // **************************************************************** -ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const Messaging::PolicyValue &_tao_aggregate) +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const Messaging::PolicyValue &_tao_aggregate + ) { if ( (strm << _tao_aggregate.ptype) && @@ -3899,7 +4426,11 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const Messaging::Poli } -ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, Messaging::PolicyValue &_tao_aggregate) +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + Messaging::PolicyValue &_tao_aggregate + ) { if ( (strm >> _tao_aggregate.ptype) && @@ -3913,7 +4444,8 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, Messaging::PolicyValue // **************************************************************** -ACE_INLINE CORBA::Boolean operator<< ( +ACE_INLINE CORBA::Boolean +operator<< ( TAO_OutputCDR &strm, const Messaging::PolicyValueSeq &_tao_sequence ) @@ -3929,7 +4461,11 @@ ACE_INLINE CORBA::Boolean operator<< ( return 0; // error } -ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, Messaging::PolicyValueSeq &_tao_sequence) +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + Messaging::PolicyValueSeq &_tao_sequence + ) { CORBA::ULong _tao_seq_len; if (strm >> _tao_seq_len) @@ -3945,9 +4481,6 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, Messaging::PolicyValue return 0; // error } -#endif /* TAO_HAS_AMI_POLLER == 1 */ - - // **************************************************************** #if (TAO_HAS_AMI_CALLBACK == 1) || (TAO_HAS_AMI_POLLER == 1) diff --git a/TAO/tao/POAC.cpp b/TAO/tao/POAC.cpp index 4fd629893f2..8f7c0a234fc 100644 --- a/TAO/tao/POAC.cpp +++ b/TAO/tao/POAC.cpp @@ -148,15 +148,23 @@ CORBA::Exception *PortableServer::ForwardRequest::_alloc (void) 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)); + ACE_NEW (_tao_any_val, PortableServer::ForwardRequest (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (PortableServer::_tc_ForwardRequest, _tao_any_val, 1, ACE_TRY_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 + ACE_CATCHANY { delete _tao_any_val; } @@ -167,10 +175,23 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::ForwardRequest *_tao_ele { ACE_TRY_NEW_ENV { - _tao_any.replace (PortableServer::_tc_ForwardRequest, _tao_elem, 1, ACE_TRY_ENV); // consume it + 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 {} + ACE_CATCHANY + { + delete _tao_elem; + _tao_elem = 0; + } ACE_ENDTRY; } @@ -179,7 +200,11 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ForwardR ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (PortableServer::_tc_ForwardRequest, ACE_TRY_ENV)) return 0; // not equal + 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 ()) { @@ -189,25 +214,84 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ForwardR else { ACE_NEW_RETURN (_tao_elem, PortableServer::ForwardRequest, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (PortableServer::_tc_ForwardRequest, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA::Any *)&_tao_any)->replace (PortableServer::_tc_ForwardRequest, _tao_elem, 1, ACE_TRY_ENV); + ((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; - return 0; + _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; @@ -1427,6 +1511,20 @@ PortableServer::POAManager_ptr PortableServer::POAManager::_duplicate (PortableS 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 @@ -1530,74 +1628,6 @@ CORBA::Exception *PortableServer::POAManager::AdapterInactive::_alloc (void) return retval; } -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_any.replace (PortableServer::POAManager::_tc_AdapterInactive, _tao_any_val, 1, 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_any.replace (PortableServer::POAManager::_tc_AdapterInactive, _tao_elem, 1, ACE_TRY_ENV); // consume it - ACE_TRY_CHECK; - } - ACE_CATCHANY {} - 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->equal (PortableServer::POAManager::_tc_AdapterInactive, ACE_TRY_ENV)) return 0; // not equal - 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.decode (PortableServer::POAManager::_tc_AdapterInactive, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - ((CORBA::Any *)&_tao_any)->replace (PortableServer::POAManager::_tc_AdapterInactive, _tao_elem, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; - return 1; - } - else - { - delete _tao_elem; - } - } - } - ACE_CATCHANY - { - delete _tao_elem; - return 0; - } - ACE_ENDTRY; - return 0; -} - static const CORBA::Long _oc_PortableServer_POAManager_AdapterInactive[] = { TAO_ENCAP_BYTE_ORDER, // byte order @@ -2050,74 +2080,6 @@ CORBA::Exception *PortableServer::POA::AdapterAlreadyExists::_alloc (void) return retval; } -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_any.replace (PortableServer::POA::_tc_AdapterAlreadyExists, _tao_any_val, 1, 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_any.replace (PortableServer::POA::_tc_AdapterAlreadyExists, _tao_elem, 1, ACE_TRY_ENV); // consume it - ACE_TRY_CHECK; - } - ACE_CATCHANY {} - 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->equal (PortableServer::POA::_tc_AdapterAlreadyExists, ACE_TRY_ENV)) return 0; // not equal - 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.decode (PortableServer::POA::_tc_AdapterAlreadyExists, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - ((CORBA::Any *)&_tao_any)->replace (PortableServer::POA::_tc_AdapterAlreadyExists, _tao_elem, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; - return 1; - } - else - { - delete _tao_elem; - } - } - } - ACE_CATCHANY - { - delete _tao_elem; - return 0; - } - ACE_ENDTRY; - return 0; -} - static const CORBA::Long _oc_PortableServer_POA_AdapterAlreadyExists[] = { TAO_ENCAP_BYTE_ORDER, // byte order @@ -2201,74 +2163,6 @@ CORBA::Exception *PortableServer::POA::AdapterInactive::_alloc (void) return retval; } -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_any.replace (PortableServer::POA::_tc_AdapterInactive, _tao_any_val, 1, 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_any.replace (PortableServer::POA::_tc_AdapterInactive, _tao_elem, 1, ACE_TRY_ENV); // consume it - ACE_TRY_CHECK; - } - ACE_CATCHANY {} - 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->equal (PortableServer::POA::_tc_AdapterInactive, ACE_TRY_ENV)) return 0; // not equal - 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.decode (PortableServer::POA::_tc_AdapterInactive, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - ((CORBA::Any *)&_tao_any)->replace (PortableServer::POA::_tc_AdapterInactive, _tao_elem, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; - return 1; - } - else - { - delete _tao_elem; - } - } - } - ACE_CATCHANY - { - delete _tao_elem; - return 0; - } - ACE_ENDTRY; - return 0; -} - static const CORBA::Long _oc_PortableServer_POA_AdapterInactive[] = { TAO_ENCAP_BYTE_ORDER, // byte order @@ -2352,74 +2246,6 @@ CORBA::Exception *PortableServer::POA::AdapterNonExistent::_alloc (void) return retval; } -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_any.replace (PortableServer::POA::_tc_AdapterNonExistent, _tao_any_val, 1, 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_any.replace (PortableServer::POA::_tc_AdapterNonExistent, _tao_elem, 1, ACE_TRY_ENV); // consume it - ACE_TRY_CHECK; - } - ACE_CATCHANY {} - 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->equal (PortableServer::POA::_tc_AdapterNonExistent, ACE_TRY_ENV)) return 0; // not equal - 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.decode (PortableServer::POA::_tc_AdapterNonExistent, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - ((CORBA::Any *)&_tao_any)->replace (PortableServer::POA::_tc_AdapterNonExistent, _tao_elem, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; - return 1; - } - else - { - delete _tao_elem; - } - } - } - ACE_CATCHANY - { - delete _tao_elem; - return 0; - } - ACE_ENDTRY; - return 0; -} - static const CORBA::Long _oc_PortableServer_POA_AdapterNonExistent[] = { TAO_ENCAP_BYTE_ORDER, // byte order @@ -2510,74 +2336,6 @@ CORBA::Exception *PortableServer::POA::InvalidPolicy::_alloc (void) return retval; } -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_any.replace (PortableServer::POA::_tc_InvalidPolicy, _tao_any_val, 1, 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_any.replace (PortableServer::POA::_tc_InvalidPolicy, _tao_elem, 1, ACE_TRY_ENV); // consume it - ACE_TRY_CHECK; - } - ACE_CATCHANY {} - 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->equal (PortableServer::POA::_tc_InvalidPolicy, ACE_TRY_ENV)) return 0; // not equal - 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.decode (PortableServer::POA::_tc_InvalidPolicy, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - ((CORBA::Any *)&_tao_any)->replace (PortableServer::POA::_tc_InvalidPolicy, _tao_elem, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; - return 1; - } - else - { - delete _tao_elem; - } - } - } - ACE_CATCHANY - { - delete _tao_elem; - return 0; - } - ACE_ENDTRY; - return 0; -} - static const CORBA::Long _oc_PortableServer_POA_InvalidPolicy[] = { TAO_ENCAP_BYTE_ORDER, // byte order @@ -2664,74 +2422,6 @@ CORBA::Exception *PortableServer::POA::NoServant::_alloc (void) return retval; } -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_any.replace (PortableServer::POA::_tc_NoServant, _tao_any_val, 1, 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_any.replace (PortableServer::POA::_tc_NoServant, _tao_elem, 1, ACE_TRY_ENV); // consume it - ACE_TRY_CHECK; - } - ACE_CATCHANY {} - 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->equal (PortableServer::POA::_tc_NoServant, ACE_TRY_ENV)) return 0; // not equal - 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.decode (PortableServer::POA::_tc_NoServant, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - ((CORBA::Any *)&_tao_any)->replace (PortableServer::POA::_tc_NoServant, _tao_elem, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; - return 1; - } - else - { - delete _tao_elem; - } - } - } - ACE_CATCHANY - { - delete _tao_elem; - return 0; - } - ACE_ENDTRY; - return 0; -} - static const CORBA::Long _oc_PortableServer_POA_NoServant[] = { TAO_ENCAP_BYTE_ORDER, // byte order @@ -2817,74 +2507,6 @@ CORBA::Exception *PortableServer::POA::ObjectAlreadyActive::_alloc (void) return retval; } -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_any.replace (PortableServer::POA::_tc_ObjectAlreadyActive, _tao_any_val, 1, 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_any.replace (PortableServer::POA::_tc_ObjectAlreadyActive, _tao_elem, 1, ACE_TRY_ENV); // consume it - ACE_TRY_CHECK; - } - ACE_CATCHANY {} - 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->equal (PortableServer::POA::_tc_ObjectAlreadyActive, ACE_TRY_ENV)) return 0; // not equal - 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.decode (PortableServer::POA::_tc_ObjectAlreadyActive, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - ((CORBA::Any *)&_tao_any)->replace (PortableServer::POA::_tc_ObjectAlreadyActive, _tao_elem, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; - return 1; - } - else - { - delete _tao_elem; - } - } - } - ACE_CATCHANY - { - delete _tao_elem; - return 0; - } - ACE_ENDTRY; - return 0; -} - static const CORBA::Long _oc_PortableServer_POA_ObjectAlreadyActive[] = { TAO_ENCAP_BYTE_ORDER, // byte order @@ -2966,74 +2588,6 @@ CORBA::Exception *PortableServer::POA::ObjectNotActive::_alloc (void) return retval; } -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_any.replace (PortableServer::POA::_tc_ObjectNotActive, _tao_any_val, 1, 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_any.replace (PortableServer::POA::_tc_ObjectNotActive, _tao_elem, 1, ACE_TRY_ENV); // consume it - ACE_TRY_CHECK; - } - ACE_CATCHANY {} - 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->equal (PortableServer::POA::_tc_ObjectNotActive, ACE_TRY_ENV)) return 0; // not equal - 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.decode (PortableServer::POA::_tc_ObjectNotActive, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - ((CORBA::Any *)&_tao_any)->replace (PortableServer::POA::_tc_ObjectNotActive, _tao_elem, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; - return 1; - } - else - { - delete _tao_elem; - } - } - } - ACE_CATCHANY - { - delete _tao_elem; - return 0; - } - ACE_ENDTRY; - return 0; -} - static const CORBA::Long _oc_PortableServer_POA_ObjectNotActive[] = { TAO_ENCAP_BYTE_ORDER, // byte order @@ -3115,74 +2669,6 @@ CORBA::Exception *PortableServer::POA::ServantAlreadyActive::_alloc (void) return retval; } -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_any.replace (PortableServer::POA::_tc_ServantAlreadyActive, _tao_any_val, 1, 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_any.replace (PortableServer::POA::_tc_ServantAlreadyActive, _tao_elem, 1, ACE_TRY_ENV); // consume it - ACE_TRY_CHECK; - } - ACE_CATCHANY {} - 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->equal (PortableServer::POA::_tc_ServantAlreadyActive, ACE_TRY_ENV)) return 0; // not equal - 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.decode (PortableServer::POA::_tc_ServantAlreadyActive, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - ((CORBA::Any *)&_tao_any)->replace (PortableServer::POA::_tc_ServantAlreadyActive, _tao_elem, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; - return 1; - } - else - { - delete _tao_elem; - } - } - } - ACE_CATCHANY - { - delete _tao_elem; - return 0; - } - ACE_ENDTRY; - return 0; -} - static const CORBA::Long _oc_PortableServer_POA_ServantAlreadyActive[] = { TAO_ENCAP_BYTE_ORDER, // byte order @@ -3264,74 +2750,6 @@ CORBA::Exception *PortableServer::POA::ServantNotActive::_alloc (void) return retval; } -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_any.replace (PortableServer::POA::_tc_ServantNotActive, _tao_any_val, 1, 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_any.replace (PortableServer::POA::_tc_ServantNotActive, _tao_elem, 1, ACE_TRY_ENV); // consume it - ACE_TRY_CHECK; - } - ACE_CATCHANY {} - 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->equal (PortableServer::POA::_tc_ServantNotActive, ACE_TRY_ENV)) return 0; // not equal - 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.decode (PortableServer::POA::_tc_ServantNotActive, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - ((CORBA::Any *)&_tao_any)->replace (PortableServer::POA::_tc_ServantNotActive, _tao_elem, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; - return 1; - } - else - { - delete _tao_elem; - } - } - } - ACE_CATCHANY - { - delete _tao_elem; - return 0; - } - ACE_ENDTRY; - return 0; -} - static const CORBA::Long _oc_PortableServer_POA_ServantNotActive[] = { TAO_ENCAP_BYTE_ORDER, // byte order @@ -3413,74 +2831,6 @@ CORBA::Exception *PortableServer::POA::WrongAdapter::_alloc (void) return retval; } -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_any.replace (PortableServer::POA::_tc_WrongAdapter, _tao_any_val, 1, 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_any.replace (PortableServer::POA::_tc_WrongAdapter, _tao_elem, 1, ACE_TRY_ENV); // consume it - ACE_TRY_CHECK; - } - ACE_CATCHANY {} - 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->equal (PortableServer::POA::_tc_WrongAdapter, ACE_TRY_ENV)) return 0; // not equal - 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.decode (PortableServer::POA::_tc_WrongAdapter, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - ((CORBA::Any *)&_tao_any)->replace (PortableServer::POA::_tc_WrongAdapter, _tao_elem, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; - return 1; - } - else - { - delete _tao_elem; - } - } - } - ACE_CATCHANY - { - delete _tao_elem; - return 0; - } - ACE_ENDTRY; - return 0; -} - static const CORBA::Long _oc_PortableServer_POA_WrongAdapter[] = { TAO_ENCAP_BYTE_ORDER, // byte order @@ -3562,74 +2912,6 @@ CORBA::Exception *PortableServer::POA::WrongPolicy::_alloc (void) return retval; } -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_any.replace (PortableServer::POA::_tc_WrongPolicy, _tao_any_val, 1, 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_any.replace (PortableServer::POA::_tc_WrongPolicy, _tao_elem, 1, ACE_TRY_ENV); // consume it - ACE_TRY_CHECK; - } - ACE_CATCHANY {} - 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->equal (PortableServer::POA::_tc_WrongPolicy, ACE_TRY_ENV)) return 0; // not equal - 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.decode (PortableServer::POA::_tc_WrongPolicy, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - ((CORBA::Any *)&_tao_any)->replace (PortableServer::POA::_tc_WrongPolicy, _tao_elem, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; - return 1; - } - else - { - delete _tao_elem; - } - } - } - ACE_CATCHANY - { - delete _tao_elem; - return 0; - } - ACE_ENDTRY; - return 0; -} - static const CORBA::Long _oc_PortableServer_POA_WrongPolicy[] = { TAO_ENCAP_BYTE_ORDER, // byte order @@ -3784,74 +3066,6 @@ CORBA::Exception *PortableServer::Current::NoContext::_alloc (void) return retval; } -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_any.replace (PortableServer::Current::_tc_NoContext, _tao_any_val, 1, 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_any.replace (PortableServer::Current::_tc_NoContext, _tao_elem, 1, ACE_TRY_ENV); // consume it - ACE_TRY_CHECK; - } - ACE_CATCHANY {} - 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->equal (PortableServer::Current::_tc_NoContext, ACE_TRY_ENV)) return 0; // not equal - 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.decode (PortableServer::Current::_tc_NoContext, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - ((CORBA::Any *)&_tao_any)->replace (PortableServer::Current::_tc_NoContext, _tao_elem, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; - return 1; - } - else - { - delete _tao_elem; - } - } - } - ACE_CATCHANY - { - delete _tao_elem; - return 0; - } - ACE_ENDTRY; - return 0; -} - static const CORBA::Long _oc_PortableServer_Current_NoContext[] = { TAO_ENCAP_BYTE_ORDER, // byte order @@ -3981,3 +3195,3727 @@ 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; +} + diff --git a/TAO/tao/POAC.h b/TAO/tao/POAC.h index 3db6230b6f5..cb50cc2a0b0 100644 --- a/TAO/tao/POAC.h +++ b/TAO/tao/POAC.h @@ -1129,6 +1129,7 @@ TAO_NAMESPACE PortableServer{ DISCARDING, INACTIVE }; + static CORBA::TypeCode_ptr _tc_State; // the static operations static POAManager_ptr _duplicate (POAManager_ptr obj); @@ -2376,6 +2377,141 @@ TAO_NAMESPACE PortableServer{ } TAO_NAMESPACE_CLOSE +TAO_Export void operator<<= (CORBA::Any &, const PortableServer::ObjectId &); // copying version +TAO_Export void operator<<= (CORBA::Any &, PortableServer::ObjectId*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::ObjectId *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const PortableServer::ObjectId *&); +TAO_Export void operator<<= (CORBA::Any &, const PortableServer::ForwardRequest &); // copying version +TAO_Export void operator<<= (CORBA::Any &, PortableServer::ForwardRequest*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::ForwardRequest *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const PortableServer::ForwardRequest *&); + +#if (TAO_HAS_MINIMUM_POA == 0) + +TAO_Export void operator<<= (CORBA::Any &, PortableServer::ThreadPolicyValue); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::ThreadPolicyValue &); +TAO_Export void operator<<= (CORBA::Any &, PortableServer::ThreadPolicy_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::ThreadPolicy *&); + +#endif /* TAO_HAS_MINIMUM_POA == 0 */ + +TAO_Export void operator<<= (CORBA::Any &, PortableServer::LifespanPolicyValue); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::LifespanPolicyValue &); +TAO_Export void operator<<= (CORBA::Any &, PortableServer::LifespanPolicy_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::LifespanPolicy *&); +TAO_Export void operator<<= (CORBA::Any &, PortableServer::IdUniquenessPolicyValue); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::IdUniquenessPolicyValue &); +TAO_Export void operator<<= (CORBA::Any &, PortableServer::IdUniquenessPolicy_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::IdUniquenessPolicy *&); +TAO_Export void operator<<= (CORBA::Any &, PortableServer::IdAssignmentPolicyValue); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::IdAssignmentPolicyValue &); +TAO_Export void operator<<= (CORBA::Any &, PortableServer::IdAssignmentPolicy_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::IdAssignmentPolicy *&); + +#if (TAO_HAS_MINIMUM_POA == 0) + +TAO_Export void operator<<= (CORBA::Any &, PortableServer::ImplicitActivationPolicyValue); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::ImplicitActivationPolicyValue &); +TAO_Export void operator<<= (CORBA::Any &, PortableServer::ImplicitActivationPolicy_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::ImplicitActivationPolicy *&); +TAO_Export void operator<<= (CORBA::Any &, PortableServer::ServantRetentionPolicyValue); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::ServantRetentionPolicyValue &); +TAO_Export void operator<<= (CORBA::Any &, PortableServer::ServantRetentionPolicy_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::ServantRetentionPolicy *&); +TAO_Export void operator<<= (CORBA::Any &, PortableServer::RequestProcessingPolicyValue); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::RequestProcessingPolicyValue &); +TAO_Export void operator<<= (CORBA::Any &, PortableServer::RequestProcessingPolicy_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::RequestProcessingPolicy *&); + +#endif /* TAO_HAS_MINIMUM_POA == 0 */ + +TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::AdapterAlreadyExists &); // copying version +TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::AdapterAlreadyExists*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::AdapterAlreadyExists *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const PortableServer::POA::AdapterAlreadyExists *&); + +#if (TAO_HAS_MINIMUM_POA == 0) + +TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::AdapterInactive &); // copying version +TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::AdapterInactive*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::AdapterInactive *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const PortableServer::POA::AdapterInactive *&); + +#endif /* TAO_HAS_MINIMUM_POA == 0 */ + +TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::AdapterNonExistent &); // copying version +TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::AdapterNonExistent*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::AdapterNonExistent *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const PortableServer::POA::AdapterNonExistent *&); +TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::InvalidPolicy &); // copying version +TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::InvalidPolicy*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::InvalidPolicy *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const PortableServer::POA::InvalidPolicy *&); + +#if (TAO_HAS_MINIMUM_POA == 0) + +TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::NoServant &); // copying version +TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::NoServant*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::NoServant *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const PortableServer::POA::NoServant *&); + +#endif /* TAO_HAS_MINIMUM_POA == 0 */ + +TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::ObjectAlreadyActive &); // copying version +TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::ObjectAlreadyActive*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::ObjectAlreadyActive *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const PortableServer::POA::ObjectAlreadyActive *&); +TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::ObjectNotActive &); // copying version +TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::ObjectNotActive*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::ObjectNotActive *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const PortableServer::POA::ObjectNotActive *&); +TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::ServantAlreadyActive &); // copying version +TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::ServantAlreadyActive*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::ServantAlreadyActive *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const PortableServer::POA::ServantAlreadyActive *&); +TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::ServantNotActive &); // copying version +TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::ServantNotActive*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::ServantNotActive *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const PortableServer::POA::ServantNotActive *&); +TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::WrongAdapter &); // copying version +TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::WrongAdapter*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::WrongAdapter *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const PortableServer::POA::WrongAdapter *&); +TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::WrongPolicy &); // copying version +TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::WrongPolicy*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::WrongPolicy *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const PortableServer::POA::WrongPolicy *&); +TAO_Export void operator<<= (CORBA::Any &, PortableServer::Current_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::Current *&); +TAO_Export void operator<<= (CORBA::Any &, const PortableServer::Current::NoContext &); // copying version +TAO_Export void operator<<= (CORBA::Any &, PortableServer::Current::NoContext*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::Current::NoContext *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const PortableServer::Current::NoContext *&); +TAO_Export void operator<<= (CORBA::Any &, PortableServer::POAManager_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POAManager *&); +TAO_Export void operator<<= (CORBA::Any &, PortableServer::POAManager::State); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POAManager::State &); +TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POAManager::AdapterInactive &); // copying version +TAO_Export void operator<<= (CORBA::Any &, PortableServer::POAManager::AdapterInactive*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POAManager::AdapterInactive *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const PortableServer::POAManager::AdapterInactive *&); + +#if (TAO_HAS_MINIMUM_POA == 0) + +TAO_Export void operator<<= (CORBA::Any &, PortableServer::AdapterActivator_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::AdapterActivator *&); +TAO_Export void operator<<= (CORBA::Any &, PortableServer::ServantManager_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::ServantManager *&); +TAO_Export void operator<<= (CORBA::Any &, PortableServer::ServantActivator_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::ServantActivator *&); +TAO_Export void operator<<= (CORBA::Any &, PortableServer::ServantLocator_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::ServantLocator *&); + +#endif /* TAO_HAS_MINIMUM_POA == 0 */ + +TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA *&); + #if defined (__ACE_INLINE__) #include "tao/POAC.i" #else @@ -2386,129 +2522,68 @@ TAO_NAMESPACE_CLOSE TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ThreadPolicyValue &); // TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::ThreadPolicyValue &); -TAO_Export CORBA::Boolean -operator<< (TAO_OutputCDR &, const PortableServer::ThreadPolicy_ptr ); -TAO_Export CORBA::Boolean -operator>> (TAO_InputCDR &, PortableServer::ThreadPolicy_ptr &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ThreadPolicy_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::ThreadPolicy_ptr &); #endif /* TAO_HAS_MINIMUM_POA == 0 */ TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::LifespanPolicyValue &); // TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::LifespanPolicyValue &); -TAO_Export CORBA::Boolean -operator<< (TAO_OutputCDR &, const PortableServer::LifespanPolicy_ptr ); -TAO_Export CORBA::Boolean -operator>> (TAO_InputCDR &, PortableServer::LifespanPolicy_ptr &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::LifespanPolicy_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::LifespanPolicy_ptr &); TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::IdUniquenessPolicyValue &); // TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::IdUniquenessPolicyValue &); -TAO_Export CORBA::Boolean -operator<< (TAO_OutputCDR &, const PortableServer::IdUniquenessPolicy_ptr ); -TAO_Export CORBA::Boolean -operator>> (TAO_InputCDR &, PortableServer::IdUniquenessPolicy_ptr &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::IdUniquenessPolicy_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::IdUniquenessPolicy_ptr &); TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::IdAssignmentPolicyValue &); // TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::IdAssignmentPolicyValue &); -TAO_Export CORBA::Boolean -operator<< (TAO_OutputCDR &, const PortableServer::IdAssignmentPolicy_ptr ); -TAO_Export CORBA::Boolean -operator>> (TAO_InputCDR &, PortableServer::IdAssignmentPolicy_ptr &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::IdAssignmentPolicy_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::IdAssignmentPolicy_ptr &); #if (TAO_HAS_MINIMUM_POA == 0) TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ImplicitActivationPolicyValue &); // TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::ImplicitActivationPolicyValue &); -TAO_Export CORBA::Boolean -operator<< (TAO_OutputCDR &, const PortableServer::ImplicitActivationPolicy_ptr ); -TAO_Export CORBA::Boolean -operator>> (TAO_InputCDR &, PortableServer::ImplicitActivationPolicy_ptr &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ImplicitActivationPolicy_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::ImplicitActivationPolicy_ptr &); TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ServantRetentionPolicyValue &); // TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::ServantRetentionPolicyValue &); -TAO_Export CORBA::Boolean -operator<< (TAO_OutputCDR &, const PortableServer::ServantRetentionPolicy_ptr ); -TAO_Export CORBA::Boolean -operator>> (TAO_InputCDR &, PortableServer::ServantRetentionPolicy_ptr &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ServantRetentionPolicy_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::ServantRetentionPolicy_ptr &); TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::RequestProcessingPolicyValue &); // TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::RequestProcessingPolicyValue &); -TAO_Export CORBA::Boolean -operator<< (TAO_OutputCDR &, const PortableServer::RequestProcessingPolicy_ptr ); -TAO_Export CORBA::Boolean -operator>> (TAO_InputCDR &, PortableServer::RequestProcessingPolicy_ptr &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::RequestProcessingPolicy_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::RequestProcessingPolicy_ptr &); #endif /* TAO_HAS_MINIMUM_POA == 0 */ // POA's exceptions. -TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::AdapterAlreadyExists &); // copying version -TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::AdapterAlreadyExists*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::AdapterAlreadyExists *&); - TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::POA::AdapterAlreadyExists &_tao_aggregate); TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::POA::AdapterAlreadyExists &); -#if (TAO_HAS_MINIMUM_POA == 0) - -TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::AdapterInactive &); // copying version -TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::AdapterInactive*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::AdapterInactive *&); - -TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::POAManager::AdapterInactive &_tao_aggregate); -TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &,PortableServer::POAManager::AdapterInactive &); - -#endif /* TAO_HAS_MINIMUM_POA == 0 */ - -TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::AdapterNonExistent &); // copying version -TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::AdapterNonExistent*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::AdapterNonExistent *&); -TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::InvalidPolicy &); // copying version -TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::InvalidPolicy*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::InvalidPolicy *&); - -TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::POA::InvalidPolicy &_tao_aggregate); -TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::POA::InvalidPolicy &_tao_aggregate); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::POA::AdapterNonExistent &); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::POA::AdapterNonExistent &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::POA::InvalidPolicy &); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::POA::InvalidPolicy &); #if (TAO_HAS_MINIMUM_POA == 0) -TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::NoServant &); // copying version -TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::NoServant*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::NoServant *&); - -TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::POA::NoServant &_tao_aggregate); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::POA::NoServant &); TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::POA::NoServant &); #endif /* TAO_HAS_MINIMUM_POA == 0 */ -TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::ObjectAlreadyActive &); // copying version -TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::ObjectAlreadyActive*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::ObjectAlreadyActive *&); -TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::POA::ObjectAlreadyActive &_tao_aggregate); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::POA::ObjectAlreadyActive &); TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::POA::ObjectAlreadyActive &); - -TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::ObjectNotActive &); // copying version -TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::ObjectNotActive*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::ObjectNotActive *&); -TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::POA::ObjectNotActive &_tao_aggregate); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::POA::ObjectNotActive &); TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::POA::ObjectNotActive &); - -TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::ServantAlreadyActive &); // copying version -TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::ServantAlreadyActive*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::ServantAlreadyActive *&); -TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::POA::ServantAlreadyActive &_tao_aggregate); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::POA::ServantAlreadyActive &); TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::POA::ServantAlreadyActive &); - -TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::ServantNotActive &); // copying version -TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::ServantNotActive*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::ServantNotActive *&); -TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::POA::ServantNotActive &_tao_aggregate); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::POA::ServantNotActive &); TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::POA::ServantNotActive &); - -TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::WrongAdapter &); // copying version -TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::WrongAdapter*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::WrongAdapter *&); -TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::POA::WrongAdapter &_tao_aggregate); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::POA::WrongAdapter &); TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::POA::WrongAdapter &); - -TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::WrongPolicy &); // copying version -TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::WrongPolicy*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::WrongPolicy *&); -TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::POA::WrongPolicy &_tao_aggregate); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::POA::WrongPolicy &); TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::POA::WrongPolicy &); // POA::Current && its exception. @@ -2517,11 +2592,31 @@ TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::Current_pt TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::Current::NoContext &); // TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::Current::NoContext &); - TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ForwardRequest &); - TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::ForwardRequest &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ForwardRequest &); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::ForwardRequest &); + +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::POAManager_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::POAManager_ptr &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::POAManager::State &); // +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::POAManager::State &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::POAManager::AdapterInactive &); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::POAManager::AdapterInactive &); + +#if (TAO_HAS_MINIMUM_POA == 0) + +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::AdapterActivator_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::AdapterActivator_ptr &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ServantManager_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::ServantManager_ptr &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ServantActivator_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::ServantActivator_ptr &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ServantLocator_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::ServantLocator_ptr &); + +#endif /* TAO_HAS_MINIMUM_POA == 0 */ - TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::POAManager::AdapterInactive &); - TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::POAManager::AdapterInactive &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::POA_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::POA_ptr &); #endif /* defined INLINE */ diff --git a/TAO/tao/POAC.i b/TAO/tao/POAC.i index a65b62eaf54..3c154586aab 100644 --- a/TAO/tao/POAC.i +++ b/TAO/tao/POAC.i @@ -3089,6 +3089,8 @@ PortableServer::Current_out::operator-> (void) return this->ptr_; } +#endif // end #if !defined + // **************************************************************** #if (TAO_HAS_MINIMUM_POA == 0) @@ -3844,4 +3846,286 @@ operator>> ( ACE_ENDTRY; return 0; } -#endif // end #if !defined + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const PortableServer::POAManager_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + PortableServer::POAManager_ptr &_tao_objref + ) +{ + ACE_TRY_NEW_ENV + { + CORBA::Object_var obj; + if ((strm >> obj.inout ()) == 0) + return 0; + // narrow to the right type + _tao_objref = + PortableServer::POAManager::_narrow ( + obj.in (), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + ACE_CATCHANY + { + // do nothing + } + ACE_ENDTRY; + return 0; +} + +ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::POAManager::State &_tao_enumval) +{ + return strm.write_ulong ((CORBA::ULong) _tao_enumval); +} + +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::POAManager::State &_tao_enumval) +{ + CORBA::ULong _tao_temp; + if (strm.read_ulong (_tao_temp)) + { + ACE_OS::memcpy (&_tao_enumval, &_tao_temp, sizeof (CORBA::ULong)); + return 1; + } + else + return 0; +} + +#if (TAO_HAS_MINIMUM_POA == 0) + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const PortableServer::AdapterActivator_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + PortableServer::AdapterActivator_ptr &_tao_objref + ) +{ + ACE_TRY_NEW_ENV + { + CORBA::Object_var obj; + if ((strm >> obj.inout ()) == 0) + return 0; + // narrow to the right type + _tao_objref = + PortableServer::AdapterActivator::_narrow ( + obj.in (), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + ACE_CATCHANY + { + // do nothing + } + ACE_ENDTRY; + return 0; +} + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &, + const PortableServer::ServantManager_ptr + ); +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &, + PortableServer::ServantManager_ptr & + ); + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const PortableServer::ServantManager_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + PortableServer::ServantManager_ptr &_tao_objref + ) +{ + ACE_TRY_NEW_ENV + { + CORBA::Object_var obj; + if ((strm >> obj.inout ()) == 0) + return 0; + // narrow to the right type + _tao_objref = + PortableServer::ServantManager::_narrow ( + obj.in (), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + ACE_CATCHANY + { + // do nothing + } + ACE_ENDTRY; + return 0; +} + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &, + const PortableServer::ServantActivator_ptr + ); +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &, + PortableServer::ServantActivator_ptr & + ); + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const PortableServer::ServantActivator_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + PortableServer::ServantActivator_ptr &_tao_objref + ) +{ + ACE_TRY_NEW_ENV + { + CORBA::Object_var obj; + if ((strm >> obj.inout ()) == 0) + return 0; + // narrow to the right type + _tao_objref = + PortableServer::ServantActivator::_narrow ( + obj.in (), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + ACE_CATCHANY + { + // do nothing + } + ACE_ENDTRY; + return 0; +} + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &, + const PortableServer::ServantLocator_ptr + ); +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &, + PortableServer::ServantLocator_ptr & + ); + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const PortableServer::ServantLocator_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + PortableServer::ServantLocator_ptr &_tao_objref + ) +{ + ACE_TRY_NEW_ENV + { + CORBA::Object_var obj; + if ((strm >> obj.inout ()) == 0) + return 0; + // narrow to the right type + _tao_objref = + PortableServer::ServantLocator::_narrow ( + obj.in (), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + ACE_CATCHANY + { + // do nothing + } + ACE_ENDTRY; + return 0; +} + +#endif /* TAO_HAS_MINIMUM_POA == 0 */ + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const PortableServer::POA_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + PortableServer::POA_ptr &_tao_objref + ) +{ + ACE_TRY_NEW_ENV + { + CORBA::Object_var obj; + if ((strm >> obj.inout ()) == 0) + return 0; + // narrow to the right type + _tao_objref = + PortableServer::POA::_narrow ( + obj.in (), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + ACE_CATCHANY + { + // do nothing + } + ACE_ENDTRY; + return 0; +} + diff --git a/TAO/tao/PolicyC.cpp b/TAO/tao/PolicyC.cpp index 6b5e328854e..8454e32b9ef 100644 --- a/TAO/tao/PolicyC.cpp +++ b/TAO/tao/PolicyC.cpp @@ -1414,6 +1414,168 @@ operator>> ( return 0; } +void operator<<= (CORBA::Any &_tao_any, CORBA::PolicyManager_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 = CORBA::PolicyManager::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_PolicyManager, + 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, CORBA::PolicyManager_ptr &_tao_elem) +{ + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); + ACE_TRY_NEW_ENV + { + _tao_elem = CORBA::PolicyManager::_nil (); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_PolicyManager, 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 = CORBA::PolicyManager::_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 ( + CORBA::_tc_PolicyManager, + 1, + tmp, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else // failure + { + delete tmp; + } + } + ACE_CATCHANY + { + delete tmp; + _tao_elem = CORBA::PolicyManager::_nil (); + return 0; + } + ACE_ENDTRY; + _tao_elem = CORBA::PolicyManager::_nil (); + return 0; +} + +void operator<<= (CORBA::Any &_tao_any, CORBA::PolicyCurrent_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 = CORBA::PolicyCurrent::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_PolicyCurrent, + 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, CORBA::PolicyCurrent_ptr &_tao_elem) +{ + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); + ACE_TRY_NEW_ENV + { + _tao_elem = CORBA::PolicyCurrent::_nil (); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_PolicyCurrent, 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 = CORBA::PolicyCurrent::_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 ( + CORBA::_tc_PolicyCurrent, + 1, + tmp, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else // failure + { + delete tmp; + } + } + ACE_CATCHANY + { + delete tmp; + _tao_elem = CORBA::PolicyCurrent::_nil (); + return 0; + } + ACE_ENDTRY; + _tao_elem = CORBA::PolicyCurrent::_nil (); + return 0; +} + // **************************************************************** #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) diff --git a/TAO/tao/PolicyC.h b/TAO/tao/PolicyC.h index b48bb21e95a..0e2ed7697be 100644 --- a/TAO/tao/PolicyC.h +++ b/TAO/tao/PolicyC.h @@ -18,6 +18,7 @@ #endif /* ACE_LACKS_PRAGMA_ONCE */ #include "tao/CDR.h" +#include "tao/Environment.h" #include "tao/Sequence.h" class TAO_Export CORBA_PolicyError : public CORBA::UserException @@ -563,40 +564,39 @@ TAO_Export void operator<<= (CORBA::Any &, TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::SetOverrideType &); +TAO_Export void operator<<= (CORBA::Any &, + CORBA::PolicyManager_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::PolicyManager *&); +TAO_Export void operator<<= (CORBA::Any &, + CORBA::PolicyCurrent_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::PolicyCurrent *&); + // **************************************************************** #if defined (__ACE_INLINE__) #include "tao/PolicyC.i" #else -TAO_Export CORBA::Boolean -operator<< (TAO_OutputCDR &, const CORBA::PolicyError &); -TAO_Export CORBA::Boolean -operator>> (TAO_InputCDR &, CORBA::PolicyError &); -TAO_Export CORBA::Boolean -operator<< (TAO_OutputCDR &, const CORBA::InvalidPolicies &); -TAO_Export CORBA::Boolean -operator>> (TAO_InputCDR &, CORBA::InvalidPolicies &); -TAO_Export CORBA::Boolean -operator<< (TAO_OutputCDR &, const CORBA::InvalidPolicies::_tao_seq_UShort &); -TAO_Export CORBA::Boolean -operator>> (TAO_InputCDR &, CORBA::InvalidPolicies::_tao_seq_UShort &); -TAO_Export CORBA::Boolean -operator<< (TAO_OutputCDR &, const CORBA::Policy_ptr ); -TAO_Export CORBA::Boolean -operator>> (TAO_InputCDR &, CORBA::Policy_ptr &); -TAO_Export CORBA::Boolean -operator<< (TAO_OutputCDR &, const CORBA::PolicyList &); -TAO_Export CORBA::Boolean -operator>> (TAO_InputCDR &, CORBA::PolicyList &); -TAO_Export CORBA::Boolean -operator<< (TAO_OutputCDR &, const CORBA::PolicyTypeSeq &); -TAO_Export CORBA::Boolean -operator>> (TAO_InputCDR &, CORBA::PolicyTypeSeq &); -TAO_Export CORBA::Boolean -operator<< (TAO_OutputCDR &, const CORBA::SetOverrideType &); -TAO_Export CORBA::Boolean -operator>> (TAO_InputCDR &, CORBA::SetOverrideType &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::PolicyError &); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::PolicyError &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::InvalidPolicies &); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::InvalidPolicies &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::InvalidPolicies::_tao_seq_UShort &); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::InvalidPolicies::_tao_seq_UShort &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::Policy_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::Policy_ptr &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::PolicyList &); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::PolicyList &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::PolicyTypeSeq &); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::PolicyTypeSeq &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::SetOverrideType &); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::SetOverrideType &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::PolicyManager_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::PolicyManager_ptr &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::PolicyCurrent_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::PolicyCurrent_ptr &); #endif /* defined INLINE */ diff --git a/TAO/tao/PolicyC.i b/TAO/tao/PolicyC.i index 42b4735537c..63793eb792a 100644 --- a/TAO/tao/PolicyC.i +++ b/TAO/tao/PolicyC.i @@ -1137,3 +1137,80 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::SetOverrideType else return 0; } + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const CORBA::PolicyManager_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + CORBA::PolicyManager_ptr &_tao_objref + ) +{ + ACE_TRY_NEW_ENV + { + CORBA::Object_var obj; + if ((strm >> obj.inout ()) == 0) + return 0; + // narrow to the right type + _tao_objref = + CORBA::PolicyManager::_narrow ( + obj.in (), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + ACE_CATCHANY + { + // do nothing + } + ACE_ENDTRY; + return 0; +} + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const CORBA::PolicyCurrent_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + CORBA::PolicyCurrent_ptr &_tao_objref + ) +{ + ACE_TRY_NEW_ENV + { + CORBA::Object_var obj; + if ((strm >> obj.inout ()) == 0) + return 0; + // narrow to the right type + _tao_objref = + CORBA::PolicyCurrent::_narrow ( + obj.in (), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + ACE_CATCHANY + { + // do nothing + } + ACE_ENDTRY; + return 0; +} + |