diff options
| author | bala <balanatarajan@users.noreply.github.com> | 2000-03-12 20:25:30 +0000 |
|---|---|---|
| committer | bala <balanatarajan@users.noreply.github.com> | 2000-03-12 20:25:30 +0000 |
| commit | f4ddae089eecd7b8439874b28f920e8938cd28ef (patch) | |
| tree | cb4736eb5c58624bc66a9f0a2ea0e89b1e6584f7 | |
| parent | 12cc822e0f51b8af1ef79a2944b30555daaaf6fb (diff) | |
| download | ATCD-f4ddae089eecd7b8439874b28f920e8938cd28ef.tar.gz | |
*** empty log message ***
207 files changed, 20322 insertions, 4747 deletions
diff --git a/TAO/tao/Acceptor_Registry.cpp b/TAO/tao/Acceptor_Registry.cpp index f93c09e9957..b2822aa070d 100644 --- a/TAO/tao/Acceptor_Registry.cpp +++ b/TAO/tao/Acceptor_Registry.cpp @@ -18,6 +18,7 @@ ACE_RCSID(tao, Acceptor_Registry, "$Id$") + TAO_Acceptor_Registry::TAO_Acceptor_Registry (void) : acceptors_ (0), size_ (0) diff --git a/TAO/tao/Acceptor_Registry.i b/TAO/tao/Acceptor_Registry.i index 1f314a4f905..4a98e902fc1 100644 --- a/TAO/tao/Acceptor_Registry.i +++ b/TAO/tao/Acceptor_Registry.i @@ -1,7 +1,6 @@ // -*- C++ -*- // $Id$ - ACE_INLINE TAO_AcceptorSetIterator TAO_Acceptor_Registry::begin (void) { diff --git a/TAO/tao/Active_Object_Map.cpp b/TAO/tao/Active_Object_Map.cpp index f36fd39819f..e3bf5c52c56 100644 --- a/TAO/tao/Active_Object_Map.cpp +++ b/TAO/tao/Active_Object_Map.cpp @@ -1,5 +1,4 @@ // $Id$ - #include "tao/Active_Object_Map.h" #if !defined (__ACE_INLINE__) diff --git a/TAO/tao/Active_Object_Map.h b/TAO/tao/Active_Object_Map.h index df5781482f0..2da5d2240ab 100644 --- a/TAO/tao/Active_Object_Map.h +++ b/TAO/tao/Active_Object_Map.h @@ -1,7 +1,6 @@ /* -*- C++ -*- */ // $Id$ - // ============================================================================ // // = LIBRARY diff --git a/TAO/tao/Any.cpp b/TAO/tao/Any.cpp index ae3374215c1..5fece149023 100644 --- a/TAO/tao/Any.cpp +++ b/TAO/tao/Any.cpp @@ -1,7 +1,7 @@ // $Id$ - // Portions of this file are: + // Copyright 1994-1995 by Sun Microsystems Inc. // All Rights Reserved // @@ -12,6 +12,8 @@ #include "tao/ORB_Core.h" #include "tao/Object.h" #include "tao/singletons.h" +#include "tao/debug.h" + #if !defined (__ACE_INLINE__) # include "tao/Any.i" @@ -19,7 +21,6 @@ ACE_RCSID(tao, Any, "$Id$") - CORBA::TypeCode_ptr CORBA_Any::type (void) const { @@ -654,6 +655,30 @@ CORBA_Any::operator<<= (CORBA::Double d) ACE_CHECK; } +void +CORBA_Any::operator<<= (CORBA::LongDouble ld) +{ + ACE_DECLARE_NEW_CORBA_ENV; + ACE_TRY + { + CORBA::LongDouble *nld; + ACE_NEW (nld, + CORBA::LongDouble (ld)); + this->replace (CORBA::_tc_longdouble, + nld, + 1, + ACE_TRY_ENV); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + ACE_DEBUG ((LM_DEBUG, + ASYS_TEXT ("Exception in CORBA::LongDouble insertion\n"))); + } + ACE_ENDTRY; + ACE_CHECK; +} + // insertion of Any - copying void CORBA_Any::operator<<= (const CORBA_Any& a) @@ -835,9 +860,7 @@ CORBA_Any::operator<<= (const CORBA_Exception &exception) ACE_TRY { TAO_OutputCDR stream; - stream.encode (exception._type (), - &exception, 0, - ACE_TRY_ENV); + exception._tao_encode (stream, ACE_TRY_ENV); ACE_TRY_CHECK; this->_tao_replace (exception._type (), @@ -848,8 +871,9 @@ CORBA_Any::operator<<= (const CORBA_Exception &exception) } ACE_CATCHANY { - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("Exception in CORBA::Exception insertion\n"))); + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, + ASYS_TEXT ("Exception in CORBA::Exception insertion\n"))); } ACE_ENDTRY; ACE_CHECK; @@ -1355,6 +1379,47 @@ CORBA_Any::operator>>= (CORBA::Double &d) const } CORBA::Boolean +CORBA_Any::operator>>= (CORBA::LongDouble &ld) const +{ + ACE_DECLARE_NEW_CORBA_ENV; + + ACE_TRY + { + CORBA::Boolean result = + this->type_->equivalent (CORBA::_tc_longdouble, + ACE_TRY_ENV); + ACE_TRY_CHECK; + + if (result) + { + if (this->any_owns_data_ && this->value_) + { + ld = *(CORBA::LongDouble *) this->value_; + return 1; + } + else + { + TAO_InputCDR stream (this->cdr_, + this->byte_order_); + return stream.read_longdouble (ld); + } + } + else + { + return 0; + } + } + ACE_CATCHANY + { + ACE_DEBUG ((LM_DEBUG, + ASYS_TEXT ("Exception in CORBA::LongDouble extraction\n"))); + } + ACE_ENDTRY; + + return 0; +} + +CORBA::Boolean CORBA_Any::operator>>= (CORBA::Any &a) const { ACE_DECLARE_NEW_CORBA_ENV; diff --git a/TAO/tao/Any.h b/TAO/tao/Any.h index 20f09d06655..88a1d32f043 100644 --- a/TAO/tao/Any.h +++ b/TAO/tao/Any.h @@ -126,6 +126,9 @@ public: void operator<<= (CORBA::Double); // insert a double + void operator<<= (CORBA::LongDouble); + // insert a long double + void operator<<= (const CORBA_Any&); // insert an Any, copying @@ -174,6 +177,9 @@ public: CORBA::Boolean operator>>= (CORBA::Double&) const; // extract a double + CORBA::Boolean operator>>= (CORBA::LongDouble&) const; + // extract a long double + CORBA::Boolean operator>>= (CORBA_Any&) const; // non-spec CORBA::Boolean operator>>= (const CORBA_Any*&) const; // extract an Any diff --git a/TAO/tao/Any.i b/TAO/tao/Any.i index 456e8387f05..370cd09cafa 100644 --- a/TAO/tao/Any.i +++ b/TAO/tao/Any.i @@ -1,6 +1,6 @@ // This may look like C, but it's really -*- C++ -*- - // $Id$ + // Insertion from special types. ACE_INLINE diff --git a/TAO/tao/Asynch_Invocation.cpp b/TAO/tao/Asynch_Invocation.cpp index 386b7999349..852fa004fd9 100644 --- a/TAO/tao/Asynch_Invocation.cpp +++ b/TAO/tao/Asynch_Invocation.cpp @@ -16,8 +16,6 @@ ACE_RCSID(tao, Asynch_Invocation, "$Id$") - - #if defined (ACE_ENABLE_TIMEPROBES) static const char *TAO_Asynch_Invocation_Timeprobe_Description[] = @@ -86,7 +84,7 @@ TAO_GIOP_Twoway_Asynch_Invocation::invoke_i (CORBA::Environment &ACE_TRY_ENV) // heap allocated reply dispatcher. int retval = - this->transport_->tms ()->bind_dispatcher (this->request_id_, + this->transport_->tms ()->bind_dispatcher (this->op_details_.request_id (), this->rd_); if (retval == -1) { diff --git a/TAO/tao/Asynch_Invocation.h b/TAO/tao/Asynch_Invocation.h index 9a431b9c03e..457c9f263c0 100644 --- a/TAO/tao/Asynch_Invocation.h +++ b/TAO/tao/Asynch_Invocation.h @@ -2,7 +2,6 @@ // $Id$ - // ============================================================================ // // = LIBRARY diff --git a/TAO/tao/BoundsC.cpp b/TAO/tao/BoundsC.cpp index 511f6ad2ea0..fa7be70cea4 100644 --- a/TAO/tao/BoundsC.cpp +++ b/TAO/tao/BoundsC.cpp @@ -1,5 +1,6 @@ /* -*- C++ -*- */ //$Id$ + // ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* // TAO and the TAO IDL Compiler have been developed by the Center for // Distributed Object Computing at Washington University, St. Louis. @@ -55,6 +56,22 @@ void CORBA_Bounds::_raise () TAO_RAISE(*this); } +void CORBA_Bounds::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void CORBA_Bounds::_tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + // TAO extension - the _alloc method CORBA::Exception *CORBA_Bounds::_alloc (void) { diff --git a/TAO/tao/BoundsC.h b/TAO/tao/BoundsC.h index 549063782c3..88c4c544276 100644 --- a/TAO/tao/BoundsC.h +++ b/TAO/tao/BoundsC.h @@ -49,6 +49,11 @@ virtual void _raise (void); + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static CORBA_Bounds *_narrow (CORBA::Exception *); diff --git a/TAO/tao/BoundsC.i b/TAO/tao/BoundsC.i index 40e552e3e13..2635b0c4b7f 100644 --- a/TAO/tao/BoundsC.i +++ b/TAO/tao/BoundsC.i @@ -20,16 +20,7 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::Bounds & return 0; } -ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::Bounds &_tao_aggregate) +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::Bounds &) { - // retrieve RepoID and verify if we are of that type - char *_tao_repoID; - if ((strm >> _tao_repoID) && - (_tao_aggregate._is_a (_tao_repoID))) - { - return 1; - } - else - return 0; + return 1; } - diff --git a/TAO/tao/Buffering_Constraint_Policy.cpp b/TAO/tao/Buffering_Constraint_Policy.cpp index dc48b5a48c6..b63a124d3ce 100644 --- a/TAO/tao/Buffering_Constraint_Policy.cpp +++ b/TAO/tao/Buffering_Constraint_Policy.cpp @@ -1,5 +1,6 @@ // $Id$ + #include "tao/Buffering_Constraint_Policy.h" #if (TAO_HAS_CORBA_MESSAGING == 1) diff --git a/TAO/tao/CDR.h b/TAO/tao/CDR.h index b163dfb82b8..56839afbc07 100644 --- a/TAO/tao/CDR.h +++ b/TAO/tao/CDR.h @@ -1,4 +1,5 @@ // This may look like C, but it's really -*- C++ -*- +// $Id$ // $Id$ diff --git a/TAO/tao/CONV_FRAMEC.cpp b/TAO/tao/CONV_FRAMEC.cpp index 7a5b9339088..8b4978ab66a 100644 --- a/TAO/tao/CONV_FRAMEC.cpp +++ b/TAO/tao/CONV_FRAMEC.cpp @@ -1,6 +1,5 @@ // // $Id$ - // // ================================================================ // @@ -267,14 +266,24 @@ TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) TAO_NAMESPACE_BEGIN (CONV_FRAME) TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_CodeSetContext, &_tc_TAO_tc_CONV_FRAME_CodeSetContext) TAO_NAMESPACE_END + void operator<<= (CORBA::Any &_tao_any, const CONV_FRAME::CodeSetComponent &_tao_elem) // copying { - CONV_FRAME::CodeSetComponent *_any_val; + CONV_FRAME::CodeSetComponent *_any_val = 0; ACE_NEW (_any_val, CONV_FRAME::CodeSetComponent (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CONV_FRAME::_tc_CodeSetComponent, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + CONV_FRAME::_tc_CodeSetComponent, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -288,10 +297,23 @@ void operator<<= (CORBA::Any &_tao_any, CONV_FRAME::CodeSetComponent *_tao_elem) { ACE_TRY_NEW_ENV { - _tao_any.replace (CONV_FRAME::_tc_CodeSetComponent, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CONV_FRAME::_tc_CodeSetComponent, + 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; } @@ -300,35 +322,98 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CONV_FRAME::CodeSetCompo ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CONV_FRAME::_tc_CodeSetComponent, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CONV_FRAME::_tc_CodeSetComponent, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (CONV_FRAME::CodeSetComponent *)_tao_any.value (); return 1; - } + } else { ACE_NEW_RETURN (_tao_elem, CONV_FRAME::CodeSetComponent, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CONV_FRAME::_tc_CodeSetComponent, _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 (CONV_FRAME::_tc_CodeSetComponent, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CONV_FRAME::_tc_CodeSetComponent, + 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 CONV_FRAME::CodeSetComponent *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CONV_FRAME::_tc_CodeSetComponent, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CONV_FRAME::CodeSetComponent *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CONV_FRAME::CodeSetComponent, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CONV_FRAME::CodeSetComponent *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CONV_FRAME::_tc_CodeSetComponent, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CONV_FRAME::CodeSetComponent *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CONV_FRAME::CodeSetComponent *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CONV_FRAME::CodeSetComponent *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; @@ -336,12 +421,21 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CONV_FRAME::CodeSetCompo void operator<<= (CORBA::Any &_tao_any, const CONV_FRAME::CodeSetComponentInfo &_tao_elem) // copying { - CONV_FRAME::CodeSetComponentInfo *_any_val; + CONV_FRAME::CodeSetComponentInfo *_any_val = 0; ACE_NEW (_any_val, CONV_FRAME::CodeSetComponentInfo (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CONV_FRAME::_tc_CodeSetComponentInfo, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + CONV_FRAME::_tc_CodeSetComponentInfo, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -355,10 +449,23 @@ void operator<<= (CORBA::Any &_tao_any, CONV_FRAME::CodeSetComponentInfo *_tao_e { ACE_TRY_NEW_ENV { - _tao_any.replace (CONV_FRAME::_tc_CodeSetComponentInfo, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CONV_FRAME::_tc_CodeSetComponentInfo, + 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; } @@ -367,35 +474,98 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CONV_FRAME::CodeSetCompo ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CONV_FRAME::_tc_CodeSetComponentInfo, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CONV_FRAME::_tc_CodeSetComponentInfo, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (CONV_FRAME::CodeSetComponentInfo *)_tao_any.value (); return 1; - } + } else { ACE_NEW_RETURN (_tao_elem, CONV_FRAME::CodeSetComponentInfo, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CONV_FRAME::_tc_CodeSetComponentInfo, _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 (CONV_FRAME::_tc_CodeSetComponentInfo, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CONV_FRAME::_tc_CodeSetComponentInfo, + 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 CONV_FRAME::CodeSetComponentInfo *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CONV_FRAME::_tc_CodeSetComponentInfo, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CONV_FRAME::CodeSetComponentInfo *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CONV_FRAME::CodeSetComponentInfo, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CONV_FRAME::CodeSetComponentInfo *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CONV_FRAME::_tc_CodeSetComponentInfo, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CONV_FRAME::CodeSetComponentInfo *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CONV_FRAME::CodeSetComponentInfo *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CONV_FRAME::CodeSetComponentInfo *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; @@ -403,12 +573,21 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CONV_FRAME::CodeSetCompo void operator<<= (CORBA::Any &_tao_any, const CONV_FRAME::CodeSetContext &_tao_elem) // copying { - CONV_FRAME::CodeSetContext *_any_val; + CONV_FRAME::CodeSetContext *_any_val = 0; ACE_NEW (_any_val, CONV_FRAME::CodeSetContext (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CONV_FRAME::_tc_CodeSetContext, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + CONV_FRAME::_tc_CodeSetContext, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -422,10 +601,23 @@ void operator<<= (CORBA::Any &_tao_any, CONV_FRAME::CodeSetContext *_tao_elem) / { ACE_TRY_NEW_ENV { - _tao_any.replace (CONV_FRAME::_tc_CodeSetContext, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CONV_FRAME::_tc_CodeSetContext, + 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; } @@ -434,35 +626,98 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CONV_FRAME::CodeSetConte ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CONV_FRAME::_tc_CodeSetContext, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CONV_FRAME::_tc_CodeSetContext, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (CONV_FRAME::CodeSetContext *)_tao_any.value (); return 1; - } + } else { ACE_NEW_RETURN (_tao_elem, CONV_FRAME::CodeSetContext, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CONV_FRAME::_tc_CodeSetContext, _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 (CONV_FRAME::_tc_CodeSetContext, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CONV_FRAME::_tc_CodeSetContext, + 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 CONV_FRAME::CodeSetContext *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CONV_FRAME::_tc_CodeSetContext, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CONV_FRAME::CodeSetContext *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CONV_FRAME::CodeSetContext, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CONV_FRAME::CodeSetContext *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CONV_FRAME::_tc_CodeSetContext, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CONV_FRAME::CodeSetContext *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CONV_FRAME::CodeSetContext *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CONV_FRAME::CodeSetContext *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; diff --git a/TAO/tao/CONV_FRAMEC.h b/TAO/tao/CONV_FRAMEC.h index a3e92f1f56b..4a1cc01f3c0 100644 --- a/TAO/tao/CONV_FRAMEC.h +++ b/TAO/tao/CONV_FRAMEC.h @@ -330,16 +330,30 @@ TAO_NAMESPACE CONV_FRAME } TAO_NAMESPACE_CLOSE // module CONV_FRAME -TAO_Export void operator<<= (CORBA::Any &, const CONV_FRAME::CodeSetComponent &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CONV_FRAME::CodeSetComponent*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CONV_FRAME::CodeSetComponent *&); -TAO_Export void operator<<= (CORBA::Any &, const CONV_FRAME::CodeSetComponentInfo &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CONV_FRAME::CodeSetComponentInfo*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CONV_FRAME::CodeSetComponentInfo *&); -TAO_Export void operator<<= (CORBA::Any &, const CONV_FRAME::CodeSetContext &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CONV_FRAME::CodeSetContext*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CONV_FRAME::CodeSetContext *&); - +TAO_Export void operator<<= (CORBA::Any &, + const CONV_FRAME::CodeSetComponent &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CONV_FRAME::CodeSetComponent*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CONV_FRAME::CodeSetComponent *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CONV_FRAME::CodeSetComponent *&); +TAO_Export void operator<<= (CORBA::Any &, + const CONV_FRAME::CodeSetComponentInfo &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CONV_FRAME::CodeSetComponentInfo*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CONV_FRAME::CodeSetComponentInfo *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CONV_FRAME::CodeSetComponentInfo *&); +TAO_Export void operator<<= (CORBA::Any &, + const CONV_FRAME::CodeSetContext &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CONV_FRAME::CodeSetContext*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CONV_FRAME::CodeSetContext *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CONV_FRAME::CodeSetContext *&); #ifndef __ACE_INLINE__ TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CONV_FRAME::CodeSetComponent &); diff --git a/TAO/tao/Client_Priority_Policy.cpp b/TAO/tao/Client_Priority_Policy.cpp index 0335fb57e5f..6fafae0bc9d 100644 --- a/TAO/tao/Client_Priority_Policy.cpp +++ b/TAO/tao/Client_Priority_Policy.cpp @@ -9,10 +9,8 @@ #if (TAO_HAS_CORBA_MESSAGING == 1) - ACE_RCSID(TAO, Client_Priority_Policy, "$Id$") - TAO_Client_Priority_Policy::TAO_Client_Priority_Policy ( PortableServer::POA_ptr poa, const TAO::PrioritySpecification &priority_spec) diff --git a/TAO/tao/Client_Priority_Policy.h b/TAO/tao/Client_Priority_Policy.h index 0606e83543f..972120df484 100644 --- a/TAO/tao/Client_Priority_Policy.h +++ b/TAO/tao/Client_Priority_Policy.h @@ -1,6 +1,5 @@ /* -*- C++ -*- */ // $Id$ - // // ============================================================================ // diff --git a/TAO/tao/Client_Priority_Policy.i b/TAO/tao/Client_Priority_Policy.i index 492ef306190..0811902a8b0 100644 --- a/TAO/tao/Client_Priority_Policy.i +++ b/TAO/tao/Client_Priority_Policy.i @@ -1,6 +1,6 @@ +/* -*- C++ -*- */ // $Id$ - - #if (TAO_HAS_CORBA_MESSAGING == 1) #endif /* TAO_HAS_CORBA_MESSAGING == 1 */ + diff --git a/TAO/tao/Connector_Registry.cpp b/TAO/tao/Connector_Registry.cpp index 44a01383ad1..2ffaf966e35 100644 --- a/TAO/tao/Connector_Registry.cpp +++ b/TAO/tao/Connector_Registry.cpp @@ -7,14 +7,12 @@ #include "tao/Environment.h" #include "tao/debug.h" - #if !defined(__ACE_INLINE__) #include "tao/Connector_Registry.i" #endif /* __ACE_INLINE__ */ ACE_RCSID(tao, Connector_Registry, "$Id$") - TAO_Connector_Registry::TAO_Connector_Registry (void) : connectors_ (0), size_ (0) diff --git a/TAO/tao/CurrentC.cpp b/TAO/tao/CurrentC.cpp index 987ab94ed7a..d514f92cc20 100644 --- a/TAO/tao/CurrentC.cpp +++ b/TAO/tao/CurrentC.cpp @@ -20,8 +20,8 @@ #include "tao/CurrentC.i" #endif /* !defined INLINE */ -ACE_RCSID(tao, CurrentC, "$Id$") +ACE_RCSID(tao, CurrentC, "$Id$") CORBA_Current_ptr CORBA_Current::_duplicate (CORBA_Current_ptr obj) { @@ -82,49 +82,84 @@ const char* CORBA_Current::_interface_repository_id (void) const return "IDL:omg.org/CORBA/Current:1.0"; } -void operator<<= (CORBA::Any &_tao_any, CORBA_Current_ptr _tao_elem) +void operator<<= (CORBA::Any &_tao_any, CORBA::Current_ptr _tao_elem) { - CORBA::Environment _tao_env; - CORBA::Object_ptr *_tao_obj_ptr; - ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); - *_tao_obj_ptr = CORBA_Current::_duplicate (_tao_elem); - _tao_any.replace (CORBA::_tc_Current, _tao_obj_ptr, 1, _tao_env); + CORBA::Object_ptr *_tao_obj_ptr = 0; + ACE_TRY_NEW_ENV + { + ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); + *_tao_obj_ptr = CORBA::Current::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_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, CORBA_Current_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Current_ptr &_tao_elem) { - ACE_DECLARE_NEW_CORBA_ENV; - ACE_TRY + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); + ACE_TRY_NEW_ENV + { + _tao_elem = CORBA::Current::_nil (); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_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 = CORBA_Current::_nil (); - CORBA::TypeCode_var type = _tao_any.type (); - CORBA::Boolean eq = type->equal (CORBA::_tc_Current, - ACE_TRY_ENV); + _tao_elem = CORBA::Current::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); ACE_TRY_CHECK; - if (eq == 0) - return 0; - - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - CORBA::Object_ptr *_tao_obj_ptr; - ACE_NEW_RETURN (_tao_obj_ptr, CORBA::Object_ptr, 0); - if (stream.decode (CORBA::_tc_Current, _tao_obj_ptr, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - _tao_elem = CORBA_Current::_narrow (*_tao_obj_ptr, ACE_TRY_ENV); - ACE_TRY_CHECK; - CORBA::release (*_tao_obj_ptr); - *_tao_obj_ptr = _tao_elem; - ((CORBA::Any *)&_tao_any)->replace (CORBA::_tc_Current, - _tao_obj_ptr, 1, - ACE_TRY_ENV); - ACE_TRY_CHECK; - } + *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_Current, + 1, + tmp, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; } - ACE_CATCHANY + else // failure { - return 0; + delete tmp; } + } + ACE_CATCHANY + { + delete tmp; + _tao_elem = CORBA::Current::_nil (); + return 0; + } ACE_ENDTRY; - return 1; + _tao_elem = CORBA::Current::_nil (); + return 0; } + diff --git a/TAO/tao/CurrentC.h b/TAO/tao/CurrentC.h index 3e14ab636bd..5cb043d1077 100644 --- a/TAO/tao/CurrentC.h +++ b/TAO/tao/CurrentC.h @@ -147,8 +147,10 @@ class CORBA_Current : public virtual ACE_CORBA_1 (Object) #endif /* end #if !defined */ // Any operators for interface CORBA_Current -void operator<<= (CORBA::Any &, CORBA_Current_ptr); -CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_Current *&); +TAO_Export void operator<<= (CORBA::Any &, + CORBA_Current_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA_Current *&); #if defined (__ACE_INLINE__) #include "tao/CurrentC.i" diff --git a/TAO/tao/Direct_Priority_Mapping.cpp b/TAO/tao/Direct_Priority_Mapping.cpp index 648c86bdae0..15f654ead3d 100644 --- a/TAO/tao/Direct_Priority_Mapping.cpp +++ b/TAO/tao/Direct_Priority_Mapping.cpp @@ -1,6 +1,5 @@ // $Id$ - #include "tao/orbconf.h" #if (TAO_HAS_RT_CORBA == 1) @@ -13,10 +12,8 @@ # include "tao/Direct_Priority_Mapping.i" #endif /* ! __ACE_INLINE__ */ - ACE_RCSID(tao, Direct_Priority_Mapping, "$Id$") - TAO_Direct_Priority_Mapping::TAO_Direct_Priority_Mapping (int policy) : policy_ (policy) { diff --git a/TAO/tao/Direct_Priority_Mapping.h b/TAO/tao/Direct_Priority_Mapping.h index 21eb938965f..118edce2224 100644 --- a/TAO/tao/Direct_Priority_Mapping.h +++ b/TAO/tao/Direct_Priority_Mapping.h @@ -1,6 +1,5 @@ // $Id$ - // ============================================================================ // // = LIBRARY diff --git a/TAO/tao/DomainC.cpp b/TAO/tao/DomainC.cpp index a44fef530c2..643350c3bcf 100644 --- a/TAO/tao/DomainC.cpp +++ b/TAO/tao/DomainC.cpp @@ -339,15 +339,30 @@ CORBA_DomainManagerList::CORBA_DomainManagerList (const CORBA_DomainManagerList CORBA_DomainManagerList::~CORBA_DomainManagerList (void) // dtor {} -void operator<<= (CORBA::Any &_tao_any, CORBA_DomainManager_ptr _tao_elem) +void operator<<= (CORBA::Any &_tao_any, CORBA::DomainManager_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_DomainManager::_duplicate (_tao_elem); - _tao_any.replace (CORBA::_tc_DomainManager, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + *_tao_obj_ptr = CORBA::DomainManager::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_DomainManager, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -356,37 +371,52 @@ void operator<<= (CORBA::Any &_tao_any, CORBA_DomainManager_ptr _tao_elem) ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_DomainManager_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::DomainManager_ptr &_tao_elem) { CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { - _tao_elem = CORBA_DomainManager::_nil (); + _tao_elem = CORBA::DomainManager::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_DomainManager, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_DomainManager, 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 (CORBA::_tc_DomainManager, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + if (stream >> _tao_obj_var.out ()) { - _tao_elem = CORBA_DomainManager::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); + _tao_elem = CORBA::DomainManager::_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 (CORBA::_tc_DomainManager, tmp, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_DomainManager, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = CORBA::DomainManager::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = CORBA::DomainManager::_nil (); return 0; } @@ -402,15 +432,30 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_DomainManager_ptr #if ! defined (TAO_HAS_MINIMUM_CORBA) -void operator<<= (CORBA::Any &_tao_any, CORBA_ConstructionPolicy_ptr _tao_elem) +void operator<<= (CORBA::Any &_tao_any, CORBA::ConstructionPolicy_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_ConstructionPolicy::_duplicate (_tao_elem); - _tao_any.replace (CORBA::_tc_ConstructionPolicy, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + *_tao_obj_ptr = CORBA::ConstructionPolicy::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_ConstructionPolicy, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -419,37 +464,52 @@ void operator<<= (CORBA::Any &_tao_any, CORBA_ConstructionPolicy_ptr _tao_elem) ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_ConstructionPolicy_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ConstructionPolicy_ptr &_tao_elem) { CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { - _tao_elem = CORBA_ConstructionPolicy::_nil (); + _tao_elem = CORBA::ConstructionPolicy::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_ConstructionPolicy, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_ConstructionPolicy, 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 (CORBA::_tc_ConstructionPolicy, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + if (stream >> _tao_obj_var.out ()) { - _tao_elem = CORBA_ConstructionPolicy::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); + _tao_elem = CORBA::ConstructionPolicy::_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 (CORBA::_tc_ConstructionPolicy, tmp, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ConstructionPolicy, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = CORBA::ConstructionPolicy::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = CORBA::ConstructionPolicy::_nil (); return 0; } @@ -464,16 +524,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_ConstructionPolicy void operator<<= ( CORBA::Any &_tao_any, - const CORBA_DomainManagerList &_tao_elem + const CORBA::DomainManagerList &_tao_elem ) // copying { - CORBA_DomainManagerList *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA_DomainManagerList (_tao_elem)); + CORBA::DomainManagerList *_tao_any_val; + ACE_NEW (_tao_any_val, CORBA::DomainManagerList (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_DomainManagerList, _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 ( + CORBA::_tc_DomainManagerList, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_any_val; + } } ACE_CATCHANY { @@ -482,52 +557,129 @@ void operator<<= ( ACE_ENDTRY; } -void operator<<= (CORBA::Any &_tao_any, CORBA_DomainManagerList *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::DomainManagerList *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_DomainManagerList, _tao_elem, 0, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_DomainManagerList, + 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; } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_DomainManagerList *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::DomainManagerList *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_DomainManagerList, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_DomainManagerList, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_DomainManagerList *)_tao_any.value (); + _tao_elem = (CORBA::DomainManagerList *)_tao_any.value (); return 1; } else { - ACE_NEW_RETURN (_tao_elem, CORBA_DomainManagerList, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_DomainManagerList, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::DomainManagerList, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA::Any *)&_tao_any)->replace (CORBA::_tc_DomainManagerList, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_DomainManagerList, + 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 CORBA::DomainManagerList *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_DomainManagerList, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::DomainManagerList *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::DomainManagerList, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::DomainManagerList *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_DomainManagerList, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::DomainManagerList *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::DomainManagerList *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::DomainManagerList *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; } + diff --git a/TAO/tao/DomainC.h b/TAO/tao/DomainC.h index 41f5d45b087..bf112f37da3 100644 --- a/TAO/tao/DomainC.h +++ b/TAO/tao/DomainC.h @@ -315,8 +315,10 @@ TAO_Export void operator<<= (CORBA::Any &, const CORBA_DomainManagerList &); // copying version TAO_Export void operator<<= (CORBA::Any &, CORBA_DomainManagerList*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, - CORBA_DomainManagerList *&); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::DomainManagerList *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::DomainManagerList *&); #ifndef __ACE_INLINE__ diff --git a/TAO/tao/DynAnyC.cpp b/TAO/tao/DynAnyC.cpp index 247f6e9e51e..113a5c0f719 100644 --- a/TAO/tao/DynAnyC.cpp +++ b/TAO/tao/DynAnyC.cpp @@ -123,6 +123,19 @@ void CORBA_DynAny::Invalid::_raise () TAO_RAISE(*this); } +void CORBA_DynAny::Invalid::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << this->_id ()) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void CORBA_DynAny::Invalid::_tao_decode (TAO_InputCDR &, + CORBA::Environment &) +{ +} + // TAO extension - the _alloc method CORBA::Exception *CORBA_DynAny::Invalid::_alloc (void) { @@ -209,6 +222,19 @@ void CORBA_DynAny::InvalidValue::_raise () TAO_RAISE(*this); } +void CORBA_DynAny::InvalidValue::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << this->_id ()) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void CORBA_DynAny::InvalidValue::_tao_decode (TAO_InputCDR &, + CORBA::Environment &) +{ +} + // TAO extension - the _alloc method CORBA::Exception *CORBA_DynAny::InvalidValue::_alloc (void) { @@ -299,6 +325,19 @@ void CORBA_DynAny::TypeMismatch::_raise () TAO_RAISE(*this); } +void CORBA_DynAny::TypeMismatch::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << this->_id ()) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void CORBA_DynAny::TypeMismatch::_tao_decode (TAO_InputCDR &, + CORBA::Environment &) +{ +} + // TAO extension - the _alloc method CORBA::Exception *CORBA_DynAny::TypeMismatch::_alloc (void) { @@ -388,6 +427,19 @@ void CORBA_DynAny::InvalidSeq::_raise () TAO_RAISE(*this); } +void CORBA_DynAny::InvalidSeq::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << this->_id ()) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void CORBA_DynAny::InvalidSeq::_tao_decode (TAO_InputCDR &, + CORBA::Environment &) +{ +} + // TAO extension - the _alloc method CORBA::Exception *CORBA_DynAny::InvalidSeq::_alloc (void) { diff --git a/TAO/tao/DynAnyC.h b/TAO/tao/DynAnyC.h index fdda529aaf1..47346e899ce 100644 --- a/TAO/tao/DynAnyC.h +++ b/TAO/tao/DynAnyC.h @@ -127,6 +127,11 @@ public: virtual void _raise (void); + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static Invalid *_narrow (CORBA::Exception *); @@ -156,6 +161,11 @@ public: virtual void _raise (void); + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static InvalidValue *_narrow (CORBA::Exception *); @@ -185,6 +195,11 @@ public: virtual void _raise (void); + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static TypeMismatch *_narrow (CORBA::Exception *); @@ -214,6 +229,11 @@ public: virtual void _raise (void); + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static InvalidSeq *_narrow (CORBA::Exception *); diff --git a/TAO/tao/DynArray_i.cpp b/TAO/tao/DynArray_i.cpp index c66fed58742..a2c7db9d9e5 100644 --- a/TAO/tao/DynArray_i.cpp +++ b/TAO/tao/DynArray_i.cpp @@ -1,7 +1,6 @@ /* -*- C++ -*- */ // $Id$ - // ==================================================================== // // = LIBRARY diff --git a/TAO/tao/DynStruct_i.cpp b/TAO/tao/DynStruct_i.cpp index 73ef52be568..369797c6345 100644 --- a/TAO/tao/DynStruct_i.cpp +++ b/TAO/tao/DynStruct_i.cpp @@ -2,6 +2,7 @@ // $Id$ + // ==================================================================== // // = LIBRARY diff --git a/TAO/tao/Exception.cpp b/TAO/tao/Exception.cpp index 8240d84b170..5525bad34a6 100644 --- a/TAO/tao/Exception.cpp +++ b/TAO/tao/Exception.cpp @@ -1,6 +1,5 @@ // $Id$ - // THREADING NOTE: calling thread handles mutual exclusion policy // on all of these data structures. @@ -198,12 +197,6 @@ CORBA_UserException::operator= (const CORBA_UserException &src) return *this; } -void -CORBA_UserException::_raise (void) -{ - TAO_RAISE (*this); -} - int CORBA_UserException::_is_a (const char* interface_id) const { @@ -279,6 +272,35 @@ CORBA_SystemException::_raise (void) TAO_RAISE (*this); } +void +CORBA_SystemException::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr.write_string (this->_id ()) + && cdr.write_ulong (this->minor ()) + && cdr.write_ulong (this->completed ())) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void +CORBA_SystemException::_tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + // The string is read by the caller, to determine the exact type of + // the exception. We just decode the fields... + // cdr.read_string (this->id ()); + CORBA::ULong tmp; + + if (cdr.read_ulong (this->minor_) + && cdr.read_ulong (tmp)) + { + this->completed_ = CORBA::CompletionStatus (tmp); + return; + } + ACE_THROW (CORBA::MARSHAL ()); +} + CORBA::ULong CORBA_SystemException::_tao_errno (int errno_value) { @@ -587,6 +609,20 @@ CORBA_UnknownUserException::_raise (void) TAO_RAISE (*this); } +void +CORBA_UnknownUserException::_tao_encode (TAO_OutputCDR &, + CORBA::Environment &ACE_TRY_ENV) const +{ + ACE_THROW (CORBA::MARSHAL ()); +} + +void +CORBA_UnknownUserException::_tao_decode (TAO_InputCDR &, + CORBA::Environment &ACE_TRY_ENV) +{ + ACE_THROW (CORBA::MARSHAL ()); +} + // Note that "buffer" holds the (unscoped) name originally, and is // then overwritten. diff --git a/TAO/tao/Exception.h b/TAO/tao/Exception.h index 1363580887c..ae579ed705f 100644 --- a/TAO/tao/Exception.h +++ b/TAO/tao/Exception.h @@ -86,6 +86,11 @@ public: // Returns a string containing information about the exception. This // function is not CORBA compliant. + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const = 0; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &) = 0; + // = Methods required for memory management support. CORBA::ULong _incr_refcnt (void); CORBA::ULong _decr_refcnt (void); @@ -133,9 +138,6 @@ public: CORBA_UserException &operator= (const CORBA_UserException &src); // Assignment operator. - virtual void _raise (void); - // To throw an exception of this type. - static CORBA_UserException *_narrow (CORBA_Exception *exception); // The narrow operation. @@ -206,6 +208,11 @@ public: // Returns a string containing information about the exception. This // function is not CORBA compliant. + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static CORBA::ULong _tao_minor_code (u_int location, int errno_value); // Helper to create a minor status value. @@ -315,6 +322,11 @@ public: virtual void _raise (void); // To throw an UnknownUserException of this type. + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static CORBA_UnknownUserException *_narrow (CORBA_Exception *ex); // Narrow to an UnknowUserException diff --git a/TAO/tao/GIOPC.cpp b/TAO/tao/GIOPC.cpp index ec1fd30d353..2d173c1e2e3 100644 --- a/TAO/tao/GIOPC.cpp +++ b/TAO/tao/GIOPC.cpp @@ -1,6 +1,5 @@ /* -*- C++ -*- $Id$ */ - // ================================================================ // // = LIBRARY @@ -349,12 +348,21 @@ TAO_NAMESPACE_END void operator<<= (CORBA::Any &_tao_any, const GIOP::IORAddressingInfo &_tao_elem) // copying { - GIOP::IORAddressingInfo *_any_val; + GIOP::IORAddressingInfo *_any_val = 0; ACE_NEW (_any_val, GIOP::IORAddressingInfo (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (GIOP::_tc_IORAddressingInfo, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + GIOP::_tc_IORAddressingInfo, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -368,10 +376,23 @@ void operator<<= (CORBA::Any &_tao_any, GIOP::IORAddressingInfo *_tao_elem) // n { ACE_TRY_NEW_ENV { - _tao_any.replace (GIOP::_tc_IORAddressingInfo, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + GIOP::_tc_IORAddressingInfo, + 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; } @@ -380,35 +401,98 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, GIOP::IORAddressingInfo ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equivalent (GIOP::_tc_IORAddressingInfo, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (GIOP::_tc_IORAddressingInfo, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (GIOP::IORAddressingInfo *)_tao_any.value (); return 1; - } + } else { ACE_NEW_RETURN (_tao_elem, GIOP::IORAddressingInfo, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (GIOP::_tc_IORAddressingInfo, _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 (GIOP::_tc_IORAddressingInfo, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + GIOP::_tc_IORAddressingInfo, + 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 GIOP::IORAddressingInfo *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (GIOP::_tc_IORAddressingInfo, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (GIOP::IORAddressingInfo *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, GIOP::IORAddressingInfo, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(GIOP::IORAddressingInfo *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + GIOP::_tc_IORAddressingInfo, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (GIOP::IORAddressingInfo *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (GIOP::IORAddressingInfo *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (GIOP::IORAddressingInfo *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; @@ -419,21 +503,27 @@ void operator<<= ( const GIOP::TargetAddress &_tao_elem ) { - GIOP::TargetAddress *_any_val; + GIOP::TargetAddress *_any_val = 0; ACE_NEW (_any_val, GIOP::TargetAddress (_tao_elem)); ACE_TRY_NEW_ENV { TAO_OutputCDR stream; - stream << *_any_val; - _tao_any._tao_replace ( - GIOP::_tc_TargetAddress, - TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _any_val, - ACE_TRY_ENV - ); - ACE_TRY_CHECK; + if (stream << *_any_val) + { + _tao_any._tao_replace ( + GIOP::_tc_TargetAddress, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _any_val; + } } ACE_CATCHANY { @@ -450,18 +540,28 @@ void operator<<= ( ACE_TRY_NEW_ENV { TAO_OutputCDR stream; - stream << *_tao_elem; - _tao_any._tao_replace ( - GIOP::_tc_TargetAddress, - TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_elem, - ACE_TRY_ENV - ); - ACE_TRY_CHECK; + if (stream << *_tao_elem) + { + _tao_any._tao_replace ( + GIOP::_tc_TargetAddress, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_elem; + } + } + ACE_CATCHANY + { + delete _tao_elem; + _tao_elem = 0; } - ACE_CATCHANY {} ACE_ENDTRY; } @@ -473,8 +573,11 @@ CORBA::Boolean operator>>= ( ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equivalent (GIOP::_tc_TargetAddress, ACE_TRY_ENV)) - return 0; + if (!type->equivalent (GIOP::_tc_TargetAddress, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { @@ -484,25 +587,90 @@ CORBA::Boolean operator>>= ( else { ACE_NEW_RETURN (_tao_elem, GIOP::TargetAddress, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - stream >> *_tao_elem; - ((CORBA::Any *)&_tao_any)->_tao_replace ( - GIOP::_tc_TargetAddress, - 1, - ACE_reinterpret_cast(void*,_tao_elem), - ACE_TRY_ENV + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () ); - ACE_TRY_CHECK; + + if (stream >> *_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + GIOP::_tc_TargetAddress, + 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; + } + ACE_ENDTRY; + return 0; +} +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + const GIOP::TargetAddress *&_tao_elem + ) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (GIOP::_tc_TargetAddress, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (GIOP::TargetAddress *)_tao_any.value (); return 1; } + else + { + ACE_NEW_RETURN (_tao_elem, GIOP::TargetAddress, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + + if (stream >> *(GIOP::TargetAddress *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + GIOP::_tc_TargetAddress, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (GIOP::TargetAddress *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (GIOP::TargetAddress *&, _tao_elem); + _tao_elem = 0; + } + } } ACE_CATCHANY { - delete _tao_elem; + delete ACE_const_cast (GIOP::TargetAddress *&, _tao_elem); + _tao_elem = 0; } ACE_ENDTRY; return 0; } + diff --git a/TAO/tao/GIOPC.h b/TAO/tao/GIOPC.h index f6560b10ae7..d753c94b1c0 100644 --- a/TAO/tao/GIOPC.h +++ b/TAO/tao/GIOPC.h @@ -1,5 +1,6 @@ /* -*- C++ -*- $Id$ */ + // ================================================================ // // = LIBRARY @@ -267,12 +268,22 @@ private: } TAO_NAMESPACE_CLOSE // module GIOP -TAO_Export void operator<<= (CORBA::Any &, const GIOP::IORAddressingInfo &); // copying version -TAO_Export void operator<<= (CORBA::Any &, GIOP::IORAddressingInfo*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, GIOP::IORAddressingInfo *&); -TAO_Export void operator<<= (CORBA::Any &, const GIOP::TargetAddress &); // copying version -TAO_Export void operator<<= (CORBA::Any &, GIOP::TargetAddress*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, GIOP::TargetAddress *&); +TAO_Export void operator<<= (CORBA::Any &, + const GIOP::IORAddressingInfo &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + GIOP::IORAddressingInfo*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + GIOP::IORAddressingInfo *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const GIOP::IORAddressingInfo *&); +TAO_Export void operator<<= (CORBA::Any &, + const GIOP::TargetAddress &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + GIOP::TargetAddress*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + GIOP::TargetAddress *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const GIOP::TargetAddress *&); #ifndef __ACE_INLINE__ diff --git a/TAO/tao/GIOP_Assorted_Headers.h b/TAO/tao/GIOP_Assorted_Headers.h index 66b46969818..b5923da9bfb 100644 --- a/TAO/tao/GIOP_Assorted_Headers.h +++ b/TAO/tao/GIOP_Assorted_Headers.h @@ -16,8 +16,8 @@ // Balachandran Natarajan <bala@cs.wustl.edu> // // ============================================================================ -#ifndef _TAO_GIOP_ASSORTED_HEADERS_H_ -#define _TAO_GIOP_ASSORTED_HEADERS_H_ +#ifndef TAO_GIOP_ASSORTED_HEADERS_H +#define TAO_GIOP_ASSORTED_HEADERS_H #include "tao/GIOPC.h" @@ -74,4 +74,4 @@ private: # include "tao/GIOP_Assorted_Headers.i" #endif /* __ACE_INLINE__ */ -#endif /*_TAO_GIOP_ASSORTED_HEADERS_H_*/ +#endif /*TAO_GIOP_ASSORTED_HEADERS_H*/ diff --git a/TAO/tao/GIOP_Assorted_Headers.i b/TAO/tao/GIOP_Assorted_Headers.i index 5d804b5db57..b23be7551fe 100644 --- a/TAO/tao/GIOP_Assorted_Headers.i +++ b/TAO/tao/GIOP_Assorted_Headers.i @@ -4,6 +4,7 @@ ACE_INLINE TAO_GIOP_Locate_Request_Header::TAO_GIOP_Locate_Request_Header (TAO_InputCDR &msg) : request_id_ (0), addressing_disposition_ (0), + target_address_ (), incoming_ (&msg) { } diff --git a/TAO/tao/GIOP_Message_Accept_State.h b/TAO/tao/GIOP_Message_Accept_State.h index b6576e18684..1d03230037c 100644 --- a/TAO/tao/GIOP_Message_Accept_State.h +++ b/TAO/tao/GIOP_Message_Accept_State.h @@ -14,8 +14,8 @@ // = AUTHOR // Balachandran Natarajan <bala@cs.wustl.edu> // ============================================================================ -#ifndef _TAO_GIOP_MESSAGE_ACCEPT_STATE_H_ -#define _TAO_GIOP_MESSAGE_ACCEPT_STATE_H_ +#ifndef TAO_GIOP_MESSAGE_ACCEPT_STATE_H +#define TAO_GIOP_MESSAGE_ACCEPT_STATE_H #include "tao/GIOP_Server_Request.h" #include "tao/GIOP_Assorted_Headers.h" diff --git a/TAO/tao/GIOP_Message_Acceptors.cpp b/TAO/tao/GIOP_Message_Acceptors.cpp index 6f3499640ad..10cb7837d31 100644 --- a/TAO/tao/GIOP_Message_Acceptors.cpp +++ b/TAO/tao/GIOP_Message_Acceptors.cpp @@ -111,28 +111,29 @@ TAO_GIOP_Message_Acceptors:: // "Doing the Table Lookup ...\n", // object_id.c_str ())); - CORBA::Object_ptr object_reference = + //CORBA::Object_ptr object_reference = + CORBA::Object_var object_reference = CORBA::Object::_nil (); // Do the Table Lookup. int status = orb_core->orb ()->_tao_find_in_IOR_table (object_id, - object_reference); + object_reference.out ()); // If ObjectID not in table or reference is nil raise // OBJECT_NOT_EXIST. - if (status == -1 || CORBA::is_nil (object_reference)) + if (status == -1 || CORBA::is_nil (object_reference.in ())) ACE_TRY_THROW (CORBA::OBJECT_NOT_EXIST ()); // ObjectID present in the table with an associated NON-NULL // reference. Throw a forward request exception. - CORBA::Object_ptr dup = - CORBA::Object::_duplicate (object_reference); + /*CORBA::Object_ptr dup = + CORBA::Object::_duplicate (object_reference);*/ // @@ We could simply write the response at this point... - ACE_TRY_THROW (PortableServer::ForwardRequest (dup)); + ACE_TRY_THROW (PortableServer::ForwardRequest (object_reference.in ())); } #endif /* TAO_NO_IOR_TABLE */ @@ -354,7 +355,6 @@ TAO_GIOP_Message_Acceptors:: ACE_TRY_THROW (PortableServer::ForwardRequest (dup)); } #endif /* TAO_NO_IOR_TABLE */ - // Execute a fake request to find out if the object is there or // if the POA can activate it on demand... char repbuf[ACE_CDR::DEFAULT_BUFSIZE]; @@ -392,7 +392,6 @@ TAO_GIOP_Message_Acceptors:: transport, 0, ACE_TRY_ENV); - ACE_TRY_CHECK; if (server_request.exception_type () == TAO_GIOP_NO_EXCEPTION) @@ -420,7 +419,6 @@ TAO_GIOP_Message_Acceptors:: ASYS_TEXT ("handle_locate has been called: not here\n"))); } } - } #if !defined (TAO_HAS_MINIMUM_CORBA) @@ -455,7 +453,6 @@ TAO_GIOP_Message_Acceptors:: #endif /* TAO_HAS_EXCEPTIONS */ ACE_ENDTRY; - return this->make_send_locate_reply (transport, locate_request, status_info); @@ -510,11 +507,14 @@ TAO_GIOP_Message_Acceptors:: // @@ Any way to implement this without interpretive // marshaling??? - output.encode (except_tc, + x->_tao_encode (output, ACE_TRY_ENV); + ACE_TRY_CHECK; + + /*output.encode (except_tc, x, 0, ACE_TRY_ENV); - ACE_TRY_CHECK; + ACE_TRY_CHECK;*/ } ACE_CATCH (CORBA_Exception, ex) { @@ -604,8 +604,7 @@ TAO_GIOP_Message_Acceptors:: int TAO_GIOP_Message_Acceptors:: parse_reply (TAO_Message_State_Factory & /*mesg_state*/, - TAO_Pluggable_Connector_Params & /*params*/, - CORBA::ULong & /*reply_status*/) + TAO_Pluggable_Connector_Params & /*params*/) { ACE_NOTSUP_RETURN (-1); } diff --git a/TAO/tao/GIOP_Message_Acceptors.h b/TAO/tao/GIOP_Message_Acceptors.h index e3459a0b106..8d3caa9e084 100644 --- a/TAO/tao/GIOP_Message_Acceptors.h +++ b/TAO/tao/GIOP_Message_Acceptors.h @@ -16,8 +16,8 @@ // Balachandran Natarajan <bala@cs.wustl.edu> // // ============================================================================ -#ifndef _TAO_GIOP_MESSAGE_ACCEPTORS_ -#define _TAO_GIOP_MESSAGE_ACCEPTORS_ +#ifndef TAO_GIOP_MESSAGE_ACCEPTORS +#define TAO_GIOP_MESSAGE_ACCEPTORS #include "tao/GIOP_Message_Base.h" #include "tao/GIOP_Utils.h" @@ -47,8 +47,7 @@ public: // passed on to the appropriate states. int parse_reply (TAO_Message_State_Factory &mesg_state, - TAO_Pluggable_Connector_Params ¶ms, - CORBA::ULong &reply_status); + TAO_Pluggable_Connector_Params ¶ms); private: int process_connector_request (TAO_Transport *transport, @@ -130,4 +129,4 @@ private: # include "tao/GIOP_Message_Acceptors.i" #endif /* __ACE_INLINE__ */ -#endif /*_TAO_GIOP_MESSAGE_ACCEPTORS_*/ +#endif /*TAO_GIOP_MESSAGE_ACCEPTORS*/ diff --git a/TAO/tao/GIOP_Message_Acceptors.i b/TAO/tao/GIOP_Message_Acceptors.i index a083a1e43f2..0daa6fda9ea 100644 --- a/TAO/tao/GIOP_Message_Acceptors.i +++ b/TAO/tao/GIOP_Message_Acceptors.i @@ -51,7 +51,6 @@ TAO_GIOP_Message_Acceptors:: this->write_protocol_header (TAO_PLUGGABLE_MESSAGE_LOCATEREPLY, this->output_); - // This writes the header & body this->accept_state_->write_locate_reply_mesg (this->output_, request.request_id (), @@ -60,7 +59,7 @@ TAO_GIOP_Message_Acceptors:: // Send the message int result = this->send_message (transport, this->output_); - + // Print out message if there is an error if (result == -1) { diff --git a/TAO/tao/GIOP_Message_Base.cpp b/TAO/tao/GIOP_Message_Base.cpp index ecb03d4354d..b1f11399e6d 100644 --- a/TAO/tao/GIOP_Message_Base.cpp +++ b/TAO/tao/GIOP_Message_Base.cpp @@ -254,17 +254,15 @@ TAO_GIOP_Message_Base:: if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, "TAO (%P|%t) - %p\n", - "TAO_GIOP_Message_Acceptor::handle_input, read_buffer[1]")); + "TAO_GIOP_Message_Base::handle_input, read_buffer[1]")); return -1; } else if (n == 0) { - if (errno == EWOULDBLOCK) - return 0; if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, "TAO (%P|%t) - %p\n", - "TAO_GIOP_Message_Acceptor::handle_input, read_buffer[2]")); + "TAO_GIOP_Message_Base::handle_input, read_buffer[2]")); return -1; } diff --git a/TAO/tao/GIOP_Message_Base.h b/TAO/tao/GIOP_Message_Base.h index 155f0605ca4..168d54c2c8e 100644 --- a/TAO/tao/GIOP_Message_Base.h +++ b/TAO/tao/GIOP_Message_Base.h @@ -17,8 +17,8 @@ // Balachandran Natarajan <bala@cs.wustl.edu> // // ============================================================================ -#ifndef _TAO_GIOP_MESSAGE_H_ -#define _TAO_GIOP_MESSAGE_H_ +#ifndef TAO_GIOP_MESSAGE_H +#define TAO_GIOP_MESSAGE_H #include "tao/Pluggable_Messaging.h" #include "tao/GIOP_Utils.h" @@ -67,8 +67,7 @@ public: // Sends the encapsulated stream in <stream> on to the transport virtual int parse_reply (TAO_Message_State_Factory &mesg_state, - TAO_Pluggable_Connector_Params ¶ms, - CORBA::ULong &reply_status) = 0; + TAO_Pluggable_Connector_Params ¶ms) = 0; // Parse the reply message from the server int process_connector_messages (TAO_Transport *transport, @@ -164,4 +163,4 @@ const size_t TAO_GIOP_MESSAGE_TYPE_OFFSET = 7; # include "tao/GIOP_Message_Base.i" #endif /* __ACE_INLINE__ */ -#endif /*_TAO_GIOP_MESSAGE_H_*/ +#endif /*TAO_GIOP_MESSAGE_H*/ diff --git a/TAO/tao/GIOP_Message_Connectors.cpp b/TAO/tao/GIOP_Message_Connectors.cpp index e667146fac2..b32f4124252 100644 --- a/TAO/tao/GIOP_Message_Connectors.cpp +++ b/TAO/tao/GIOP_Message_Connectors.cpp @@ -59,8 +59,7 @@ TAO_GIOP_Message_Connectors:: int TAO_GIOP_Message_Connectors:: parse_reply (TAO_Message_State_Factory &mesg_state, - TAO_Pluggable_Connector_Params ¶ms, - CORBA::ULong &reply_status) + TAO_Pluggable_Connector_Params ¶ms) { // Cast to the GIOP Message state @@ -68,7 +67,7 @@ TAO_GIOP_Message_Connectors:: &mesg_state); // Read the request id - if (!state->cdr.read_ulong (params.request_id)) + if (!state->cdr.read_ulong (params.request_id_)) { if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, @@ -79,8 +78,10 @@ TAO_GIOP_Message_Connectors:: // and the reply status type. status can be NO_EXCEPTION, // SYSTEM_EXCEPTION, USER_EXCEPTION, LOCATION_FORWARD - // CAnnot handle LOCATION_FORWARD_PERM here - if (!state->cdr.read_ulong (reply_status)) + + // Cannot handle LOCATION_FORWARD_PERM here + CORBA::ULong rep_stat = 0; + if (!state->cdr.read_ulong (rep_stat)) { if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, @@ -88,7 +89,33 @@ TAO_GIOP_Message_Connectors:: "extracting reply status\n")); return -1; } - + + // Pass the right Pluggable interface code to the transport layer + switch (rep_stat) + { + // Request completed successfully + case TAO_GIOP_NO_EXCEPTION: + params.reply_status_ = TAO_PLUGGABLE_MESSAGE_NO_EXCEPTION; + break; + + // Request terminated with user exception + case TAO_GIOP_USER_EXCEPTION: + params.reply_status_ = TAO_PLUGGABLE_MESSAGE_USER_EXCEPTION; + break; + // Request terminated with system exception + case TAO_GIOP_SYSTEM_EXCEPTION: + params.reply_status_ = TAO_PLUGGABLE_MESSAGE_SYSTEM_EXCEPTION; + break; + // Reply is a location forward type + case TAO_GIOP_LOCATION_FORWARD: + params.reply_status_ = TAO_PLUGGABLE_MESSAGE_LOCATION_FORWARD; + break; + default: + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, + ASYS_TEXT ("(%N|%l) Unknown reply status \n"))); + } + return 0; } @@ -209,8 +236,8 @@ TAO_GIOP_Message_Connector_11:: int TAO_GIOP_Message_Connector_11:: parse_reply (TAO_Message_State_Factory &mesg_state, - TAO_Pluggable_Connector_Params ¶ms, - CORBA::ULong &reply_status) + TAO_Pluggable_Connector_Params ¶ms) + { // Cast to the GIOP Message state TAO_GIOP_Message_State *state = ACE_dynamic_cast (TAO_GIOP_Message_State *, @@ -239,7 +266,7 @@ TAO_GIOP_Message_Connector_11:: // Handle after the switch break; case TAO_GIOP_REPLY: - if ((state->cdr >> params.svc_ctx) == 0) + if ((state->cdr >> params.svc_ctx_) == 0) { if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, @@ -255,8 +282,8 @@ TAO_GIOP_Message_Connector_11:: } if (TAO_GIOP_Message_Connectors::parse_reply (*state, - params, - reply_status) == -1) + params) + == -1) return -1; return 0; diff --git a/TAO/tao/GIOP_Message_Connectors.h b/TAO/tao/GIOP_Message_Connectors.h index b1bf7a06846..6fb7c757459 100644 --- a/TAO/tao/GIOP_Message_Connectors.h +++ b/TAO/tao/GIOP_Message_Connectors.h @@ -16,8 +16,8 @@ // Balachandran Natarajan <bala@cs.wustl.edu> // // ============================================================================ -#ifndef _TAO_GIOP_MESSAGE_CONNECTORS_ -#define _TAO_GIOP_MESSAGE_CONNECTORS_ +#ifndef TAO_GIOP_MESSAGE_CONNECTORS_ +#define TAO_GIOP_MESSAGE_CONNECTORS_ #include "tao/GIOP_Message_Base.h" class TAO_Export TAO_GIOP_Message_Connectors: @@ -39,8 +39,7 @@ protected: // Write the GIOP request header. int parse_reply (TAO_Message_State_Factory &mesg_state, - TAO_Pluggable_Connector_Params ¶ms, - CORBA::ULong &reply_status); + TAO_Pluggable_Connector_Params ¶ms); // Parse the reply message from the server private: @@ -95,8 +94,7 @@ private: // Write the locate request header in to the <msg> int parse_reply (TAO_Message_State_Factory &mesg_state, - TAO_Pluggable_Connector_Params ¶ms, - CORBA::ULong &reply_status); + TAO_Pluggable_Connector_Params ¶ms); // Parse the reply messages from the server CORBA::Octet major_version (void); @@ -122,4 +120,4 @@ private: # include "tao/GIOP_Message_Connectors.i" #endif /* __ACE_INLINE__ */ -#endif /*_TAO_GIOP_MESSAGE_CONNECTORS_*/ +#endif /*TAO_GIOP_MESSAGE_CONNECTORS*/ diff --git a/TAO/tao/GIOP_Message_Lite.cpp b/TAO/tao/GIOP_Message_Lite.cpp index 9b78f1755c1..397df8009cd 100644 --- a/TAO/tao/GIOP_Message_Lite.cpp +++ b/TAO/tao/GIOP_Message_Lite.cpp @@ -265,8 +265,7 @@ TAO_GIOP_Message_Lite:: int TAO_GIOP_Message_Lite:: parse_reply (TAO_Message_State_Factory &mesg_state, - TAO_Pluggable_Connector_Params ¶ms, - CORBA::ULong &reply_status) + TAO_Pluggable_Connector_Params ¶ms) { // Cast to the GIOP Message state TAO_GIOP_Message_State *state = @@ -296,7 +295,7 @@ TAO_GIOP_Message_Lite:: // Handle after the switch break; case TAO_GIOP_REPLY: - if ((state->cdr >> params.svc_ctx) == 0) + if ((state->cdr >> params.svc_ctx_) == 0) { if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, @@ -312,7 +311,7 @@ TAO_GIOP_Message_Lite:: } // Read the request id - if (!state->cdr.read_ulong (params.request_id)) + if (!state->cdr.read_ulong (params.request_id_)) { if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, @@ -321,10 +320,11 @@ TAO_GIOP_Message_Lite:: return -1; } + CORBA::ULong rep_stat = 0; // and the reply status type. status can be NO_EXCEPTION, // SYSTEM_EXCEPTION, USER_EXCEPTION, LOCATION_FORWARD // CAnnot handle LOCATION_FORWARD_PERM here - if (!state->cdr.read_ulong (reply_status)) + if (!state->cdr.read_ulong (rep_stat)) { if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, @@ -333,6 +333,31 @@ TAO_GIOP_Message_Lite:: return -1; } + // Pass the right Pluggable interface code to the transport layer + switch (rep_stat) + { + // Request completed successfully + case TAO_GIOP_NO_EXCEPTION: + params.reply_status_ = TAO_PLUGGABLE_MESSAGE_NO_EXCEPTION; + break; + + // Request terminated with user exception + case TAO_GIOP_USER_EXCEPTION: + params.reply_status_ = TAO_PLUGGABLE_MESSAGE_USER_EXCEPTION; + break; + // Request terminated with system exception + case TAO_GIOP_SYSTEM_EXCEPTION: + params.reply_status_ = TAO_PLUGGABLE_MESSAGE_SYSTEM_EXCEPTION; + break; + // Reply is a location forward type + case TAO_GIOP_LOCATION_FORWARD: + params.reply_status_ = TAO_PLUGGABLE_MESSAGE_LOCATION_FORWARD; + break; + default: + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, + ASYS_TEXT ("(%N|%l) Unknown reply status \n"))); + } return 0; } diff --git a/TAO/tao/GIOP_Message_Lite.h b/TAO/tao/GIOP_Message_Lite.h index e9e88c5343a..f0a1af08b07 100644 --- a/TAO/tao/GIOP_Message_Lite.h +++ b/TAO/tao/GIOP_Message_Lite.h @@ -16,8 +16,8 @@ // Balachandran Natarajan <bala@cs.wustl.edu> // // ============================================================================ -#ifndef _TAO_GIOP_MESSAGE_LITE_H_ -#define _TAO_GIOP_MESSAGE_LITE_H_ +#ifndef TAO_GIOP_MESSAGE_LITE_H +#define TAO_GIOP_MESSAGE_LITE_H #include "tao/GIOP_Server_Request.h" #include "tao/GIOP_Assorted_Headers.h" @@ -64,8 +64,7 @@ public: // Sends the encapsulated stream in <stream> on to the transport int parse_reply (TAO_Message_State_Factory &mesg_state, - TAO_Pluggable_Connector_Params ¶ms, - CORBA::ULong &reply_status); + TAO_Pluggable_Connector_Params ¶ms); // Parse the reply message from the server int process_connector_messages (TAO_Transport *transport, @@ -161,4 +160,4 @@ const size_t TAO_GIOP_LITE_MESSAGE_TYPE_OFFSET = 4; # include "tao/GIOP_Message_Lite.i" #endif /* __ACE_INLINE__ */ -#endif /*_TAO_GIOP_MESSAGE_LITE_H_*/ +#endif /*TAO_GIOP_MESSAGE_LITE_H*/ diff --git a/TAO/tao/GIOP_Server_Request.cpp b/TAO/tao/GIOP_Server_Request.cpp index 4f54afdd2bb..d9dd357be29 100644 --- a/TAO/tao/GIOP_Server_Request.cpp +++ b/TAO/tao/GIOP_Server_Request.cpp @@ -55,6 +55,7 @@ TAO_GIOP_ServerRequest:: incoming_ (&input), outgoing_ (&output), response_expected_ (0), + sync_with_server_ (0), lazy_evaluation_ (0), #if !defined (TAO_HAS_MINIMUM_CORBA) @@ -74,7 +75,7 @@ TAO_GIOP_ServerRequest:: requesting_principal_ (0) { ACE_FUNCTION_TIMEPROBE (TAO_SERVER_REQUEST_START); - // parse_error = this->parse_header (); + //no-op } // This constructor is used, by the locate request code @@ -93,6 +94,7 @@ TAO_GIOP_ServerRequest:: operation_ (operation), incoming_ (0), outgoing_ (&output), + sync_with_server_ (0), response_expected_ (response_expected), lazy_evaluation_ (0), @@ -172,7 +174,10 @@ TAO_GIOP_ServerRequest::set_result (const CORBA::Any &value, if (this->retval_ || this->exception_) ACE_THROW (CORBA::BAD_INV_ORDER ()); - this->retval_ = new CORBA::Any (value); + ACE_NEW_THROW_EX (this->retval_, + CORBA::Any (value), + CORBA::NO_MEMORY ()); + ACE_CHECK; } // Store the exception value. @@ -212,7 +217,10 @@ TAO_GIOP_ServerRequest::set_exception (const CORBA::Any &value, #endif /* TAO_HAS_MINIMUM_CORBA */ { - this->exception_ = new CORBA::Any (value); + ACE_NEW_THROW_EX (this->exception_, + CORBA::Any (value), + CORBA::NO_MEMORY ()); + ACE_CHECK; this->exception_type_ = TAO_GIOP_USER_EXCEPTION; @@ -461,8 +469,7 @@ TAO_GIOP_ServerRequest::init_reply (CORBA::Environment &ACE_TRY_ENV) this->params_->_tao_target_alignment (); ptr_arith_t current = - ptr_arith_t(this->outgoing_->current ()->wr_ptr ()) - % ACE_CDR::MAX_ALIGNMENT; + ptr_arith_t(this->outgoing_->current_alignment ()) % ACE_CDR::MAX_ALIGNMENT; CORBA::ULong pad = 0; if (target == 0) diff --git a/TAO/tao/GIOP_Utils.h b/TAO/tao/GIOP_Utils.h index f3ac2a7e61d..5ad053200e0 100644 --- a/TAO/tao/GIOP_Utils.h +++ b/TAO/tao/GIOP_Utils.h @@ -16,8 +16,8 @@ // Balachandran Natarajan <bala@cs.wustl.edu> // // ============================================================================ -#ifndef _TAO_GIOP_UTILS_H_ -#define _TAO_GIOP_UTILS_H_ +#ifndef TAO_GIOP_UTILS_H +#define TAO_GIOP_UTILS_H #include "tao/Pluggable_Messaging.h" @@ -262,4 +262,4 @@ public: # include "tao/GIOP_Utils.i" #endif /* __ACE_INLINE__ */ -#endif /*_TAO_GIOP_UTILS_H_ */ +#endif /*TAO_GIOP_UTILS_H */ diff --git a/TAO/tao/IIOP_Acceptor.cpp b/TAO/tao/IIOP_Acceptor.cpp index 3388e8948ce..fe3645acfd8 100644 --- a/TAO/tao/IIOP_Acceptor.cpp +++ b/TAO/tao/IIOP_Acceptor.cpp @@ -1,8 +1,6 @@ // This may look like C, but it's really -*- C++ -*- // $Id$ - - #include "tao/IIOP_Acceptor.h" #include "tao/IIOP_Profile.h" #include "tao/MProfile.h" @@ -10,11 +8,12 @@ #include "tao/Server_Strategy_Factory.h" #include "tao/debug.h" +#include "ace/Auto_Ptr.h" + #if !defined(__ACE_INLINE__) #include "tao/IIOP_Acceptor.i" #endif /* __ACE_INLINE__ */ - ACE_RCSID(tao, IIOP_Acceptor, "$Id$") #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) @@ -45,6 +44,9 @@ template class TAO_Accept_Strategy<TAO_IIOP_Server_Connection_Handler, ACE_SOCK_ TAO_IIOP_Acceptor::TAO_IIOP_Acceptor (CORBA::Boolean flag) : TAO_Acceptor (TAO_TAG_IIOP_PROFILE), + addrs_ (0), + hosts_ (0), + num_hosts_ (0), version_ (TAO_DEF_GIOP_MAJOR, TAO_DEF_GIOP_MINOR), orb_core_ (0), base_acceptor_ (), @@ -60,54 +62,57 @@ TAO_IIOP_Acceptor::~TAO_IIOP_Acceptor (void) delete this->creation_strategy_; delete this->concurrency_strategy_; delete this->accept_strategy_; + + delete [] this->addrs_; + delete [] this->hosts_; } // TODO = // 2) For V1.[1,2] there are tagged components -// 3) Create multiple profiles for wild carded endpoints (may be multiple -// interfaces over which we can receive requests. Thus a profile -// must be made for each one. int TAO_IIOP_Acceptor::create_mprofile (const TAO_ObjectKey &object_key, TAO_MProfile &mprofile) { - // @@ we only make one for now + // Adding this->num_hosts_ to the TAO_MProfile. int count = mprofile.profile_count (); - if ((mprofile.size () - count) < 1 - && mprofile.grow (count + 1) == -1) + if ((mprofile.size () - count) < this->num_hosts_ + && mprofile.grow (count + this->num_hosts_) == -1) return -1; - TAO_IIOP_Profile *pfile = 0; - ACE_NEW_RETURN (pfile, - TAO_IIOP_Profile (this->host_.c_str (), - this->address_.get_port_number (), - object_key, - this->address_, - this->version_, - this->orb_core_), - -1); - - if (mprofile.give_profile (pfile) == -1) + for (size_t i = 0; i < this->num_hosts_; ++i) { - pfile->_decr_refcnt (); - pfile = 0; - return -1; - } + TAO_IIOP_Profile *pfile = 0; + ACE_NEW_RETURN (pfile, + TAO_IIOP_Profile (this->hosts_[i].c_str (), + this->addrs_[i].get_port_number (), + object_key, + this->addrs_[i], + this->version_, + this->orb_core_), + -1); + + if (mprofile.give_profile (pfile) == -1) + { + pfile->_decr_refcnt (); + pfile = 0; + return -1; + } - if (this->orb_core_->orb_params ()->std_profile_components () == 0) - return 0; + if (this->orb_core_->orb_params ()->std_profile_components () == 0) + continue; - pfile->tagged_components ().set_orb_type (TAO_ORB_TYPE); + pfile->tagged_components ().set_orb_type (TAO_ORB_TYPE); - CONV_FRAME::CodeSetComponentInfo code_set_info; - code_set_info.ForCharData.native_code_set = - TAO_DEFAULT_CHAR_CODESET_ID; - code_set_info.ForWcharData.native_code_set = - TAO_DEFAULT_WCHAR_CODESET_ID; - pfile->tagged_components ().set_code_sets (code_set_info); + CONV_FRAME::CodeSetComponentInfo code_set_info; + code_set_info.ForCharData.native_code_set = + TAO_DEFAULT_CHAR_CODESET_ID; + code_set_info.ForWcharData.native_code_set = + TAO_DEFAULT_WCHAR_CODESET_ID; + pfile->tagged_components ().set_code_sets (code_set_info); - pfile->tagged_components ().set_tao_priority (this->priority ()); + pfile->tagged_components ().set_tao_priority (this->priority ()); + } return 0; } @@ -116,11 +121,17 @@ int TAO_IIOP_Acceptor::is_collocated (const TAO_Profile *pfile) { const TAO_IIOP_Profile *profile = - ACE_dynamic_cast(const TAO_IIOP_Profile *, - pfile); + ACE_dynamic_cast (const TAO_IIOP_Profile *, + pfile); - // compare the port and sin_addr (numeric host address) - return profile->object_addr () == this->address_; + for (size_t i = 0; i < this->num_hosts_; ++i) + { + // compare the port and sin_addr (numeric host address) + if (profile->object_addr () == this->addrs_[i]) + return 1; // Collocated + } + + return 0; // Not collocated } int @@ -136,6 +147,17 @@ TAO_IIOP_Acceptor::open (TAO_ORB_Core *orb_core, const char *address, const char *options) { + if (this->hosts_ != 0) + { + // The hostname cache has already been set! + // This is bad mojo, i.e. an internal TAO error. + ACE_ERROR_RETURN ((LM_ERROR, + ASYS_TEXT ("TAO (%P|%t) ") + ASYS_TEXT ("IIOP_Acceptor::open - "), + ASYS_TEXT ("hostname already set\n\n")), + -1); + } + if (address == 0) return -1; @@ -181,6 +203,27 @@ TAO_IIOP_Acceptor::open (TAO_ORB_Core *orb_core, // Host and port were specified. return -1; + + this->num_hosts_ = 1; // Only one hostname to store + + ACE_NEW_RETURN (this->addrs_, + ACE_INET_Addr[this->num_hosts_], + -1); + + ACE_NEW_RETURN (this->hosts_, + ACE_CString[this->num_hosts_], + -1); + + if (this->hostname (orb_core, + addr, + this->hosts_[0]) != 0) + return -1; + + // Copy the addr. The port is (re)set in + // TAO_IIOP_Acceptor::open_i(). + if (this->addrs_[0].set (addr) != 0) + return -1; + return this->open_i (orb_core, addr); } @@ -188,27 +231,121 @@ int TAO_IIOP_Acceptor::open_default (TAO_ORB_Core *orb_core, const char *options) { + if (this->hosts_ != 0) + { + // The hostname cache has already been set! + // This is bad mojo, i.e. an internal TAO error. + ACE_ERROR_RETURN ((LM_ERROR, + ASYS_TEXT ("TAO (%P|%t) ") + ASYS_TEXT ("IIOP_Acceptor::open_default - "), + ASYS_TEXT ("hostname already set\n\n")), + -1); + } + // Parse options if (this->parse_options (options) == -1) return -1; - // @@ Until we can support multihomed machines correctly we must - // pick the "default interface" and only listen on that IP - // address. + // Extract the hostname for each network interface, and then cache + // it. The hostnames will then be used when creating a + // TAO_IIOP_Profile for each endpoint setup on the probed + // network interfaces. + ACE_INET_Addr *if_addrs = 0; + size_t if_cnt = 0; - ACE_INET_Addr addr; - char buffer[MAXHOSTNAMELEN + 1]; - if (addr.get_host_name (buffer, - sizeof (buffer)) != 0) + if (ACE::get_ip_interfaces (if_cnt, + if_addrs) != 0) return -1; - if (addr.set (u_short(0), - buffer, + if (if_cnt == 0 || if_addrs == 0) + { + if (TAO_debug_level > 0) + { + ACE_DEBUG ((LM_WARNING, + ASYS_TEXT ("TAO (%P|%t) Unable to probe network ") + ASYS_TEXT ("interfaces. Using default."))); + } + + if_cnt = 1; // Force the network interface count to be one. + delete [] if_addrs; + ACE_NEW_RETURN (if_addrs, + ACE_INET_Addr[if_cnt], + -1); + } + + // Scan for the loopback interface since it shouldn't be included in + // the list of cached hostnames unless it is the only interface. + size_t lo_cnt = 0; // Loopback interface count + for (size_t j = 0; j < if_cnt; ++j) + if (if_addrs[j].get_ip_address() == INADDR_LOOPBACK) + lo_cnt++; + + + { // Begin ACE_Auto_Basic_Array_Ptr<ACE_INET_Addr> scope. + + // @@ It's either this or release the array from the + // ACE_Auto_Basic_Array_Ptr<> and delete it manually. This + // seemed like a more elegant solution, i.e. create a scope for + // it. + // -Ossama + + // The instantiation for this template is in + // tao/IIOP_Connector.cpp. + ACE_Auto_Basic_Array_Ptr<ACE_INET_Addr> safe_if_addrs (if_addrs); + + // If the loopback interface is the only interface then include it + // in the list of interfaces to query for a hostname, otherwise + // exclude it from the list. + if (if_cnt == lo_cnt) + this->num_hosts_ = if_cnt; + else + this->num_hosts_ = if_cnt - lo_cnt; + + ACE_NEW_RETURN (this->addrs_, + ACE_INET_Addr[this->num_hosts_], + -1); + + ACE_NEW_RETURN (this->hosts_, + ACE_CString[this->num_hosts_], + -1); + + // The number of hosts/interfaces we want to cache may not be the + // same as the number of detected interfaces so keep a separate + // count. + size_t host_cnt = 0; + + for (size_t i = 0; i < if_cnt; ++i) + { + // Ignore any loopback interface if there are other + // non-loopback interfaces. + if (if_cnt != lo_cnt && + if_addrs[i].get_ip_address() == INADDR_LOOPBACK) + continue; + + if (this->hostname (orb_core, + if_addrs[i], + this->hosts_[host_cnt]) != 0) + return -1; + + // Copy the addr. The port is (re)set in + // TAO_IIOP_Acceptor::open_i(). + if (this->addrs_[host_cnt].set (if_addrs[i]) != 0) + return -1; + + host_cnt++; + } + } // End ACE_Auto_Basic_Array_Ptr<ACE_INET_Addr> scope. + + // Now that each network interface's hostname has been cached, open + // an endpoint on each network interface using the INADDR_ANY + // address. + ACE_INET_Addr addr; + + if (addr.set (ACE_static_cast(u_short, 0), + ACE_static_cast(ACE_UINT32, INADDR_ANY), 1) != 0) return -1; - this->host_ = buffer; - return this->open_i (orb_core, addr); } @@ -240,21 +377,55 @@ TAO_IIOP_Acceptor::open_i (TAO_ORB_Core* orb_core, { if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("\n\nTAO (%P|%t) IIOP_Acceptor::open_i - %p\n\n"), + ASYS_TEXT ("\n\nTAO (%P|%t) IIOP_Acceptor::open_i ") + ASYS_TEXT ("- %p\n\n"), ASYS_TEXT ("cannot open acceptor"))); return -1; } - // @@ Should this be a catastrophic error??? - if (this->base_acceptor_.acceptor ().get_local_addr (this->address_) != 0) + ACE_INET_Addr address; + + // We do this make sure the port number the endpoint is listening on + // gets set in the addr. + if (this->base_acceptor_.acceptor ().get_local_addr (address) != 0) { + // @@ Should this be a catastrophic error??? if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("\n\nTAO (%P|%t) IIOP_Acceptor::open_i - %p\n\n"), + ASYS_TEXT ("\n\nTAO (%P|%t) IIOP_Acceptor::open_i ") + ASYS_TEXT ("- %p\n\n"), ASYS_TEXT ("cannot get local addr"))); return -1; } + // Set the port for each addr. If there is more than one network + // interface then the endpoint created on each interface will be on + // the same port. This is how a wildcard socket bind() is supposed + // to work. + u_short port = address.get_port_number (); + for (size_t j = 0; j < this->num_hosts_; ++j) + this->addrs_[j].set_port_number (port, 1); + + if (TAO_debug_level > 5) + { + for (size_t i = 0; i < this->num_hosts_; ++i) + { + ACE_DEBUG ((LM_DEBUG, + ASYS_TEXT ("\nTAO (%P|%t) IIOP_Acceptor::open_i - ") + ASYS_TEXT ("listening on: <%s:%u>\n"), + this->hosts_[i].c_str (), + this->addrs_[i].get_port_number ())); + } + } + + return 0; +} + +int +TAO_IIOP_Acceptor::hostname (TAO_ORB_Core *orb_core, + ACE_INET_Addr &addr, + ACE_CString &host) +{ if (orb_core->orb_params ()->use_dotted_decimal_addresses ()) { const char *tmp = addr.get_host_addr (); @@ -262,45 +433,40 @@ TAO_IIOP_Acceptor::open_i (TAO_ORB_Core* orb_core, { if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("\n\nTAO (%P|%t) IIOP_Acceptor::open_i - %p\n\n"), + ASYS_TEXT ("\n\nTAO (%P|%t) ") + ASYS_TEXT ("IIOP_Acceptor::hostname ") + ASYS_TEXT ("- %p\n\n"), ASYS_TEXT ("cannot cache hostname"))); return -1; } - this->host_ = tmp; + + host = tmp; } else { - char tmp_host[MAXHOSTNAMELEN+1]; + char tmp_host[MAXHOSTNAMELEN + 1]; if (addr.get_host_name (tmp_host, - sizeof tmp_host) != 0) + sizeof (tmp_host)) != 0) { if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("\n\nTAO (%P|%t) IIOP_Acceptor::open_i - %p\n\n"), + ASYS_TEXT ("\n\nTAO (%P|%t) ") + ASYS_TEXT ("IIOP_Acceptor::hostname ") + ASYS_TEXT ("- %p\n\n"), ASYS_TEXT ("cannot cache hostname"))); return -1; } - this->host_ = tmp_host; - } - if (TAO_debug_level > 5) - { - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("\nTAO (%P|%t) IIOP_Acceptor::open_i - ") - ASYS_TEXT ("listening on: <%s:%u>\n"), - this->host_.c_str (), - this->address_.get_port_number ())); + host = tmp_host; } + return 0; } CORBA::ULong TAO_IIOP_Acceptor::endpoint_count (void) { - // @@ for now just assume one! - // we should take a look at the local address, if it is zero then - // get the list of available IP interfaces and return this number. - return 1; + return this->num_hosts_; } int diff --git a/TAO/tao/IIOP_Acceptor.h b/TAO/tao/IIOP_Acceptor.h index 62cb3846ad9..a9270ee80b3 100644 --- a/TAO/tao/IIOP_Acceptor.h +++ b/TAO/tao/IIOP_Acceptor.h @@ -1,7 +1,8 @@ // This may look like C, but it's really -*- C++ -*- // $Id$ -// ============================================================================ + +//============================================================================ // // = LIBRARY // TAO @@ -15,7 +16,7 @@ // = AUTHOR // Fred Kuhns // -// ============================================================================ +//============================================================================ #ifndef TAO_IIOP_ACCEPTOR_H #define TAO_IIOP_ACCEPTOR_H @@ -74,22 +75,30 @@ public: virtual CORBA::ULong endpoint_count (void); private: - int open_i (TAO_ORB_Core* orb_core, - const ACE_INET_Addr& addr); + int open_i (TAO_ORB_Core *orb_core, + const ACE_INET_Addr &addr); // Implement the common part of the open*() methods. + int hostname (TAO_ORB_Core *orb_core, + ACE_INET_Addr &addr, + ACE_CString &host); + // Set the host name for the given addr. + virtual int parse_options (const char *options); // Parse protocol specific options. protected: - ACE_INET_Addr address_; - ACE_CString host_; - // Cache the information about the endpoint serviced by this + ACE_INET_Addr *addrs_; + + ACE_CString *hosts_; + // Cache the information about the endpoints serviced by this // acceptor. - // @@ TODO there may in fact be multiple hostnames for this - // endpoint. For example it the IP address is INADDR_ANY - // (0.0.0.0) then there will be possibly a different hostname for - // each interface. + // There may in fact be multiple hostnames for this endpoint. For + // example, if the IP address is INADDR_ANY (0.0.0.0) then there + // will be possibly a different hostname for each interface. + + size_t num_hosts_; + // The number of host names cached in the hosts_ array. TAO_GIOP_Version version_; // The GIOP version for this endpoint diff --git a/TAO/tao/IIOP_Acceptor.i b/TAO/tao/IIOP_Acceptor.i index 28e5f46ce72..f7c171d6e5e 100644 --- a/TAO/tao/IIOP_Acceptor.i +++ b/TAO/tao/IIOP_Acceptor.i @@ -4,5 +4,12 @@ ACE_INLINE const ACE_INET_Addr& TAO_IIOP_Acceptor::address (void) const { - return this->address_; + ACE_ASSERT (this->addrs_ != 0); + + // @@ This is busted. + // The Implementation Repository will have to start supporting + // IORs with multiple profiles. For now, we just return the + // first addr. + // -Ossama + return this->addrs_[0]; } diff --git a/TAO/tao/IIOP_Connect.cpp b/TAO/tao/IIOP_Connect.cpp index 24b38011040..3c71c926911 100644 --- a/TAO/tao/IIOP_Connect.cpp +++ b/TAO/tao/IIOP_Connect.cpp @@ -1,7 +1,5 @@ // $Id$ - - #include "tao/IIOP_Connect.h" #include "tao/Timeprobe.h" #include "tao/debug.h" @@ -20,6 +18,7 @@ ACE_RCSID(tao, IIOP_Connect, "$Id$") + #if defined (ACE_ENABLE_TIMEPROBES) static const char *TAO_IIOP_Connect_Timeprobe_Description[] = diff --git a/TAO/tao/IIOP_Connector.cpp b/TAO/tao/IIOP_Connector.cpp index 765981fb3f2..f0db86ef2e3 100644 --- a/TAO/tao/IIOP_Connector.cpp +++ b/TAO/tao/IIOP_Connector.cpp @@ -9,10 +9,8 @@ #include "tao/Environment.h" #include "ace/Auto_Ptr.h" - ACE_RCSID(tao, IIOP_Connector, "$Id$") - #if defined (TAO_USES_ROBUST_CONNECTION_MGMT) int TAO_IIOP_Connector::purge_connections (void) @@ -341,8 +339,10 @@ typedef ACE_Cached_Connect_Strategy<TAO_IIOP_Client_Connection_Handler, TAO_CACHED_CONNECT_STRATEGY; #endif /* ! TAO_USES_ROBUST_CONNECTION_MGMT */ + TAO_IIOP_Connector::TAO_IIOP_Connector (CORBA::Boolean flag) : TAO_Connector (TAO_TAG_IIOP_PROFILE), + orb_core_ (0), base_connector_ (), lite_flag_ (flag) diff --git a/TAO/tao/IIOP_Profile.cpp b/TAO/tao/IIOP_Profile.cpp index 12e22867cfe..691c49cca2d 100644 --- a/TAO/tao/IIOP_Profile.cpp +++ b/TAO/tao/IIOP_Profile.cpp @@ -1,6 +1,7 @@ // This may look like C, but it's really -*- C++ -*- // $Id$ + #include "tao/IIOP_Profile.h" #include "tao/IIOP_Connect.h" #include "tao/CDR.h" @@ -20,12 +21,13 @@ static const char prefix_[] = "iiop"; const char TAO_IIOP_Profile::object_key_delimiter_ = '/'; -char +char TAO_IIOP_Profile::object_key_delimiter (void) const { return TAO_IIOP_Profile::object_key_delimiter_; } + TAO_IIOP_Profile::TAO_IIOP_Profile (const ACE_INET_Addr &addr, const TAO_ObjectKey &object_key, const TAO_GIOP_Version &version, @@ -147,7 +149,7 @@ TAO_IIOP_Profile::decode (TAO_InputCDR& cdr) // profiles whose versions we don't understand. // CORBA::Octet major, minor; - + if (!(cdr.read_octet (major) && (major == TAO_DEF_GIOP_MAJOR) && cdr.read_octet (minor))) @@ -163,7 +165,7 @@ TAO_IIOP_Profile::decode (TAO_InputCDR& cdr) } this->version_.major = major; - + if (minor <= TAO_DEF_GIOP_MINOR) this->version_.minor = minor; @@ -180,8 +182,17 @@ TAO_IIOP_Profile::decode (TAO_InputCDR& cdr) return -1; } - this->object_addr_.set (this->port_, this->host_.in ()); - + if (this->object_addr_.set (this->port_, + this->host_.in ()) == -1) + { + if (TAO_debug_level > 0) + { + ACE_DEBUG ((LM_DEBUG, + ASYS_TEXT ("TAO (%P|%t) IIOP_Profile::decode - \n") + ASYS_TEXT ("TAO (%P|%t) ACE_INET_Addr::set () failed"))); + } + return -1; + } // ... and object key. if ((cdr >> this->object_key_) == 0) @@ -300,7 +311,17 @@ TAO_IIOP_Profile::parse_string (const char *string, this->host_ = tmp._retn (); - this->object_addr_.set (this->port_, this->host_.in ()); + if (this->object_addr_.set (this->port_, + this->host_.in ()) == -1) + { + if (TAO_debug_level > 0) + { + ACE_DEBUG ((LM_DEBUG, + ASYS_TEXT ("TAO (%P|%t) IIOP_Profile::parse_string - \n") + ASYS_TEXT ("TAO (%P|%t) ACE_INET_Addr::set () failed"))); + } + return -1; + } start = ++okd; // increment past the object key separator @@ -388,7 +409,7 @@ TAO_IIOP_Profile::operator= (const TAO_IIOP_Profile &src) this->version_ = src.version_; this->object_key_ = src.object_key_; - + this->object_addr_.set (src.object_addr_); this->port_ = src.port_; diff --git a/TAO/tao/IIOP_Profile.h b/TAO/tao/IIOP_Profile.h index 665c2b0c910..513090cb1f3 100644 --- a/TAO/tao/IIOP_Profile.h +++ b/TAO/tao/IIOP_Profile.h @@ -1,6 +1,7 @@ // This may look like C, but it's really -*- C++ -*- // $Id$ + // ============================================================================ // // = LIBRARY diff --git a/TAO/tao/IIOP_Profile.i b/TAO/tao/IIOP_Profile.i index 05386c1a335..bc461ad8c0d 100644 --- a/TAO/tao/IIOP_Profile.i +++ b/TAO/tao/IIOP_Profile.i @@ -1,7 +1,6 @@ // -*- C++ -*- // $Id$ - ACE_INLINE const TAO_ObjectKey & TAO_IIOP_Profile::object_key (void) const { diff --git a/TAO/tao/IIOP_Transport.cpp b/TAO/tao/IIOP_Transport.cpp index 5212e753f46..30131f90af0 100644 --- a/TAO/tao/IIOP_Transport.cpp +++ b/TAO/tao/IIOP_Transport.cpp @@ -1,8 +1,6 @@ // This may look like C, but it's really -*- C++ -*- // $Id$ - - #include "tao/IIOP_Transport.h" #include "tao/IIOP_Connect.h" #include "tao/IIOP_Profile.h" @@ -258,12 +256,8 @@ TAO_IIOP_Client_Transport::handle_client_input (int /* block */, // OK, the complete message is here... - TAO_Pluggable_Connector_Params params; - CORBA::ULong reply_status; - result = this->client_mesg_factory_->parse_reply (*message_state, - params, - reply_status); + this->params_); if (result == -1) { if (TAO_debug_level > 0) @@ -275,10 +269,10 @@ TAO_IIOP_Client_Transport::handle_client_input (int /* block */, } result = - this->tms_->dispatch_reply (params.request_id, - reply_status, + this->tms_->dispatch_reply (this->params_.request_id_, + this->params_.reply_status_, message_state->giop_version, - params.svc_ctx, + this->params_.svc_ctx_, message_state); if (result == -1) diff --git a/TAO/tao/IIOP_Transport.h b/TAO/tao/IIOP_Transport.h index 1290157421f..290e882c2bc 100644 --- a/TAO/tao/IIOP_Transport.h +++ b/TAO/tao/IIOP_Transport.h @@ -1,7 +1,6 @@ // This may look like C, but it's really -*- C++ -*- // $Id$ - // ============================================================================ // // = LIBRARY @@ -163,6 +162,9 @@ private: CORBA::Boolean lite_flag_; // Are we using lite? + + TAO_Pluggable_Connector_Params params_; + // The reply data that is sent back by the server }; // **************************************************************** diff --git a/TAO/tao/IOPC.cpp b/TAO/tao/IOPC.cpp index ec9d78943d4..226f26aab0b 100644 --- a/TAO/tao/IOPC.cpp +++ b/TAO/tao/IOPC.cpp @@ -538,12 +538,21 @@ TAO_NAMESPACE_DEFINE (const CORBA::ULong, UnknownExceptionInfo, 9) TAO_NAMESPACE_END void operator<<= (CORBA::Any &_tao_any, const IOP::TaggedProfile &_tao_elem) // copying { - IOP::TaggedProfile *_any_val; + IOP::TaggedProfile *_any_val = 0; ACE_NEW (_any_val, IOP::TaggedProfile (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (IOP::_tc_TaggedProfile, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + IOP::_tc_TaggedProfile, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -557,10 +566,23 @@ void operator<<= (CORBA::Any &_tao_any, IOP::TaggedProfile *_tao_elem) // non co { ACE_TRY_NEW_ENV { - _tao_any.replace (IOP::_tc_TaggedProfile, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + IOP::_tc_TaggedProfile, + 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; } @@ -569,35 +591,98 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::TaggedProfile *&_ta ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (IOP::_tc_TaggedProfile, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (IOP::_tc_TaggedProfile, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (IOP::TaggedProfile *)_tao_any.value (); return 1; - } + } else { ACE_NEW_RETURN (_tao_elem, IOP::TaggedProfile, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (IOP::_tc_TaggedProfile, _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 (IOP::_tc_TaggedProfile, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + IOP::_tc_TaggedProfile, + 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 IOP::TaggedProfile *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (IOP::_tc_TaggedProfile, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (IOP::TaggedProfile *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, IOP::TaggedProfile, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(IOP::TaggedProfile *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + IOP::_tc_TaggedProfile, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (IOP::TaggedProfile *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (IOP::TaggedProfile *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (IOP::TaggedProfile *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; @@ -605,12 +690,21 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::TaggedProfile *&_ta void operator<<= (CORBA::Any &_tao_any, const IOP::IOR &_tao_elem) // copying { - IOP::IOR *_any_val; + IOP::IOR *_any_val = 0; ACE_NEW (_any_val, IOP::IOR (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (IOP::_tc_IOR, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + IOP::_tc_IOR, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -624,10 +718,23 @@ void operator<<= (CORBA::Any &_tao_any, IOP::IOR *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (IOP::_tc_IOR, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + IOP::_tc_IOR, + 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; } @@ -636,35 +743,98 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::IOR *&_tao_elem) ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (IOP::_tc_IOR, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (IOP::_tc_IOR, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (IOP::IOR *)_tao_any.value (); return 1; - } + } else { ACE_NEW_RETURN (_tao_elem, IOP::IOR, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (IOP::_tc_IOR, _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 (IOP::_tc_IOR, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + IOP::_tc_IOR, + 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 IOP::IOR *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (IOP::_tc_IOR, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (IOP::IOR *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, IOP::IOR, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(IOP::IOR *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + IOP::_tc_IOR, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (IOP::IOR *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (IOP::IOR *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (IOP::IOR *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; @@ -672,12 +842,21 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::IOR *&_tao_elem) void operator<<= (CORBA::Any &_tao_any, const IOP::TaggedComponent &_tao_elem) // copying { - IOP::TaggedComponent *_any_val; + IOP::TaggedComponent *_any_val = 0; ACE_NEW (_any_val, IOP::TaggedComponent (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (IOP::_tc_TaggedComponent, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + IOP::_tc_TaggedComponent, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -691,10 +870,23 @@ void operator<<= (CORBA::Any &_tao_any, IOP::TaggedComponent *_tao_elem) // non { ACE_TRY_NEW_ENV { - _tao_any.replace (IOP::_tc_TaggedComponent, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + IOP::_tc_TaggedComponent, + 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; } @@ -703,35 +895,98 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::TaggedComponent *&_ ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (IOP::_tc_TaggedComponent, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (IOP::_tc_TaggedComponent, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (IOP::TaggedComponent *)_tao_any.value (); return 1; - } + } else { ACE_NEW_RETURN (_tao_elem, IOP::TaggedComponent, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (IOP::_tc_TaggedComponent, _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 (IOP::_tc_TaggedComponent, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + IOP::_tc_TaggedComponent, + 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 IOP::TaggedComponent *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (IOP::_tc_TaggedComponent, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (IOP::TaggedComponent *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, IOP::TaggedComponent, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(IOP::TaggedComponent *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + IOP::_tc_TaggedComponent, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (IOP::TaggedComponent *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (IOP::TaggedComponent *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (IOP::TaggedComponent *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; @@ -747,8 +1002,23 @@ void operator<<= ( if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (IOP::_tc_MultipleComponentProfile, _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 ( + IOP::_tc_MultipleComponentProfile, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_any_val; + } } ACE_CATCHANY { @@ -761,10 +1031,23 @@ void operator<<= (CORBA::Any &_tao_any, IOP::MultipleComponentProfile *_tao_elem { ACE_TRY_NEW_ENV { - _tao_any.replace (IOP::_tc_MultipleComponentProfile, _tao_elem, 0, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + IOP::_tc_MultipleComponentProfile, + 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; } @@ -773,7 +1056,11 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::MultipleComponentPr ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (IOP::_tc_MultipleComponentProfile, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (IOP::_tc_MultipleComponentProfile, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { @@ -783,25 +1070,84 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::MultipleComponentPr else { ACE_NEW_RETURN (_tao_elem, IOP::MultipleComponentProfile, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (IOP::_tc_MultipleComponentProfile, _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 (IOP::_tc_MultipleComponentProfile, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + IOP::_tc_MultipleComponentProfile, + 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 IOP::MultipleComponentProfile *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (IOP::_tc_MultipleComponentProfile, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (IOP::MultipleComponentProfile *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, IOP::MultipleComponentProfile, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(IOP::MultipleComponentProfile *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + IOP::_tc_MultipleComponentProfile, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (IOP::MultipleComponentProfile *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (IOP::MultipleComponentProfile *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (IOP::MultipleComponentProfile *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; @@ -809,12 +1155,21 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::MultipleComponentPr void operator<<= (CORBA::Any &_tao_any, const IOP::ServiceContext &_tao_elem) // copying { - IOP::ServiceContext *_any_val; + IOP::ServiceContext *_any_val = 0; ACE_NEW (_any_val, IOP::ServiceContext (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (IOP::_tc_ServiceContext, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + IOP::_tc_ServiceContext, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -828,10 +1183,23 @@ void operator<<= (CORBA::Any &_tao_any, IOP::ServiceContext *_tao_elem) // non c { ACE_TRY_NEW_ENV { - _tao_any.replace (IOP::_tc_ServiceContext, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + IOP::_tc_ServiceContext, + 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; } @@ -840,35 +1208,98 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::ServiceContext *&_t ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (IOP::_tc_ServiceContext, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (IOP::_tc_ServiceContext, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (IOP::ServiceContext *)_tao_any.value (); return 1; - } + } else { ACE_NEW_RETURN (_tao_elem, IOP::ServiceContext, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (IOP::_tc_ServiceContext, _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 (IOP::_tc_ServiceContext, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + IOP::_tc_ServiceContext, + 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 IOP::ServiceContext *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (IOP::_tc_ServiceContext, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (IOP::ServiceContext *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, IOP::ServiceContext, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(IOP::ServiceContext *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + IOP::_tc_ServiceContext, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (IOP::ServiceContext *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (IOP::ServiceContext *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (IOP::ServiceContext *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; @@ -884,8 +1315,23 @@ void operator<<= ( if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (IOP::_tc_ServiceContextList, _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 ( + IOP::_tc_ServiceContextList, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_any_val; + } } ACE_CATCHANY { @@ -898,10 +1344,23 @@ void operator<<= (CORBA::Any &_tao_any, IOP::ServiceContextList *_tao_elem) // n { ACE_TRY_NEW_ENV { - _tao_any.replace (IOP::_tc_ServiceContextList, _tao_elem, 0, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + IOP::_tc_ServiceContextList, + 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; } @@ -910,7 +1369,11 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::ServiceContextList ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (IOP::_tc_ServiceContextList, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (IOP::_tc_ServiceContextList, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { @@ -920,25 +1383,84 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::ServiceContextList else { ACE_NEW_RETURN (_tao_elem, IOP::ServiceContextList, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (IOP::_tc_ServiceContextList, _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 (IOP::_tc_ServiceContextList, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + IOP::_tc_ServiceContextList, + 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 IOP::ServiceContextList *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (IOP::_tc_ServiceContextList, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (IOP::ServiceContextList *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, IOP::ServiceContextList, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(IOP::ServiceContextList *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + IOP::_tc_ServiceContextList, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (IOP::ServiceContextList *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (IOP::ServiceContextList *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (IOP::ServiceContextList *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; diff --git a/TAO/tao/IOPC.h b/TAO/tao/IOPC.h index 80101595c52..721f5cf0956 100644 --- a/TAO/tao/IOPC.h +++ b/TAO/tao/IOPC.h @@ -575,24 +575,55 @@ TAO_NAMESPACE IOP } TAO_NAMESPACE_CLOSE // module IOP -TAO_Export void operator<<= (CORBA::Any &, const IOP::TaggedProfile &); // copying version -TAO_Export void operator<<= (CORBA::Any &, IOP::TaggedProfile*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IOP::TaggedProfile *&); -TAO_Export void operator<<= (CORBA::Any &, const IOP::IOR &); // copying version -TAO_Export void operator<<= (CORBA::Any &, IOP::IOR*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IOP::IOR *&); -TAO_Export void operator<<= (CORBA::Any &, const IOP::TaggedComponent &); // copying version -TAO_Export void operator<<= (CORBA::Any &, IOP::TaggedComponent*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IOP::TaggedComponent *&); -TAO_Export void operator<<= (CORBA::Any &, const IOP::MultipleComponentProfile &); // copying version -TAO_Export void operator<<= (CORBA::Any &, IOP::MultipleComponentProfile*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IOP::MultipleComponentProfile *&); -TAO_Export void operator<<= (CORBA::Any &, const IOP::ServiceContext &); // copying version -TAO_Export void operator<<= (CORBA::Any &, IOP::ServiceContext*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IOP::ServiceContext *&); -TAO_Export void operator<<= (CORBA::Any &, const IOP::ServiceContextList &); // copying version -TAO_Export void operator<<= (CORBA::Any &, IOP::ServiceContextList*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IOP::ServiceContextList *&); +TAO_Export void operator<<= (CORBA::Any &, + const IOP::TaggedProfile &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + IOP::TaggedProfile*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + IOP::TaggedProfile *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const IOP::TaggedProfile *&); +TAO_Export void operator<<= (CORBA::Any &, + const IOP::IOR &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + IOP::IOR*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + IOP::IOR *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const IOP::IOR *&); +TAO_Export void operator<<= (CORBA::Any &, + const IOP::TaggedComponent &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + IOP::TaggedComponent*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + IOP::TaggedComponent *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const IOP::TaggedComponent *&); +TAO_Export void operator<<= (CORBA::Any &, + const IOP::MultipleComponentProfile &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + IOP::MultipleComponentProfile*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + IOP::MultipleComponentProfile *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const IOP::MultipleComponentProfile *&); +TAO_Export void operator<<= (CORBA::Any &, + const IOP::ServiceContext &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + IOP::ServiceContext*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + IOP::ServiceContext *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const IOP::ServiceContext *&); +TAO_Export void operator<<= (CORBA::Any &, + const IOP::ServiceContextList &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + IOP::ServiceContextList*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + IOP::ServiceContextList *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const IOP::ServiceContextList *&); + #ifndef __ACE_INLINE__ diff --git a/TAO/tao/IORC.cpp b/TAO/tao/IORC.cpp index a1871ff6f84..a4ac85e380b 100644 --- a/TAO/tao/IORC.cpp +++ b/TAO/tao/IORC.cpp @@ -1,6 +1,7 @@ /* -*- C++ -*- */ // $Id$ + // ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* // TAO and the TAO IDL Compiler have been developed by the Center for // Distributed Object Computing at Washington University, St. Louis. @@ -21,6 +22,7 @@ ACE_RCSID(tao, IORC, "$Id$") + TAO_IOP::TAO_IOR_Manipulation_ptr TAO_IOP::TAO_IOR_Manipulation::_narrow ( CORBA::Object_ptr obj, CORBA::Environment &ACE_TRY_ENV @@ -106,6 +108,22 @@ void TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList::_raise () TAO_RAISE(*this); } +void TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList::_tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + // TAO extension - the _alloc method CORBA::Exception *TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList::_alloc (void) { @@ -170,6 +188,22 @@ void TAO_IOP::TAO_IOR_Manipulation::NotFound::_raise () TAO_RAISE(*this); } +void TAO_IOP::TAO_IOR_Manipulation::NotFound::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void TAO_IOP::TAO_IOR_Manipulation::NotFound::_tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + // TAO extension - the _alloc method CORBA::Exception *TAO_IOP::TAO_IOR_Manipulation::NotFound::_alloc (void) { @@ -234,6 +268,22 @@ void TAO_IOP::TAO_IOR_Manipulation::Duplicate::_raise () TAO_RAISE(*this); } +void TAO_IOP::TAO_IOR_Manipulation::Duplicate::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void TAO_IOP::TAO_IOR_Manipulation::Duplicate::_tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + // TAO extension - the _alloc method CORBA::Exception *TAO_IOP::TAO_IOR_Manipulation::Duplicate::_alloc (void) { @@ -298,6 +348,22 @@ void TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR::_raise () TAO_RAISE(*this); } +void TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR::_tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + // TAO extension - the _alloc method CORBA::Exception *TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR::_alloc (void) { @@ -401,8 +467,23 @@ void operator<<= (CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipulation_ptr _tao_e { ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); *_tao_obj_ptr = TAO_IOP::TAO_IOR_Manipulation::_duplicate (_tao_elem); - _tao_any.replace (TAO_IOP::_tc_TAO_IOR_Manipulation, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + TAO_IOP::_tc_TAO_IOR_Manipulation, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -414,39 +495,57 @@ void operator<<= (CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipulation_ptr _tao_e CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipulation_ptr &_tao_elem) { CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = TAO_IOP::TAO_IOR_Manipulation::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (TAO_IOP::_tc_TAO_IOR_Manipulation, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (TAO_IOP::_tc_TAO_IOR_Manipulation, 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 (TAO_IOP::_tc_TAO_IOR_Manipulation, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + if (stream >> _tao_obj_var.out ()) { _tao_elem = TAO_IOP::TAO_IOR_Manipulation::_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 (TAO_IOP::_tc_TAO_IOR_Manipulation, tmp, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + TAO_IOP::_tc_TAO_IOR_Manipulation, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = TAO_IOP::TAO_IOR_Manipulation::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = TAO_IOP::TAO_IOR_Manipulation::_nil (); return 0; } -#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) - template class TAO_Object_Field_T<TAO_IOP::TAO_IOR_Manipulation,TAO_IOP::TAO_IOR_Manipulation_var>; +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Field_T<TAO_IOP::TAO_IOR_Manipulation,TAO_IOP::TAO_IOR_Manipulation_var>; template class TAO_Object_Manager<TAO_IOP::TAO_IOR_Manipulation,TAO_IOP::TAO_IOR_Manipulation_var>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) # pragma instantiate TAO_Object_Field_T<TAO_IOP::TAO_IOR_Manipulation,TAO_IOP::TAO_IOR_Manipulation_var> @@ -455,14 +554,24 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul void operator<<= (CORBA::Any &_tao_any, const TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList &_tao_elem) // copying { - TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList *_tao_any_val = new TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList (_tao_elem); + TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList *_tao_any_val = 0; + ACE_NEW (_tao_any_val, TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (TAO_IOP::TAO_IOR_Manipulation::_tc_EmptyProfileList, _tao_any_val, 1, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_any_val; + _tao_any._tao_replace ( + TAO_IOP::TAO_IOR_Manipulation::_tc_EmptyProfileList, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } - ACE_CATCHANY + ACE_CATCHANY { delete _tao_any_val; } @@ -473,10 +582,23 @@ void operator<<= (CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipulation::EmptyProf { ACE_TRY_NEW_ENV { - _tao_any.replace (TAO_IOP::TAO_IOR_Manipulation::_tc_EmptyProfileList, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + TAO_IOP::TAO_IOR_Manipulation::_tc_EmptyProfileList, + 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; } @@ -485,7 +607,11 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (TAO_IOP::TAO_IOR_Manipulation::_tc_EmptyProfileList, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (TAO_IOP::TAO_IOR_Manipulation::_tc_EmptyProfileList, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { @@ -495,25 +621,84 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul else { ACE_NEW_RETURN (_tao_elem, TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (TAO_IOP::TAO_IOR_Manipulation::_tc_EmptyProfileList, _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 (TAO_IOP::TAO_IOR_Manipulation::_tc_EmptyProfileList, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + TAO_IOP::TAO_IOR_Manipulation::_tc_EmptyProfileList, + 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 TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (TAO_IOP::TAO_IOR_Manipulation::_tc_EmptyProfileList, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + TAO_IOP::TAO_IOR_Manipulation::_tc_EmptyProfileList, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; @@ -521,14 +706,24 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul void operator<<= (CORBA::Any &_tao_any, const TAO_IOP::TAO_IOR_Manipulation::NotFound &_tao_elem) // copying { - TAO_IOP::TAO_IOR_Manipulation::NotFound *_tao_any_val = new TAO_IOP::TAO_IOR_Manipulation::NotFound (_tao_elem); + TAO_IOP::TAO_IOR_Manipulation::NotFound *_tao_any_val = 0; + ACE_NEW (_tao_any_val, TAO_IOP::TAO_IOR_Manipulation::NotFound (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (TAO_IOP::TAO_IOR_Manipulation::_tc_NotFound, _tao_any_val, 1, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_any_val; + _tao_any._tao_replace ( + TAO_IOP::TAO_IOR_Manipulation::_tc_NotFound, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } - ACE_CATCHANY + ACE_CATCHANY { delete _tao_any_val; } @@ -539,10 +734,23 @@ void operator<<= (CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipulation::NotFound { ACE_TRY_NEW_ENV { - _tao_any.replace (TAO_IOP::TAO_IOR_Manipulation::_tc_NotFound, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + TAO_IOP::TAO_IOR_Manipulation::_tc_NotFound, + 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; } @@ -551,7 +759,11 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (TAO_IOP::TAO_IOR_Manipulation::_tc_NotFound, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (TAO_IOP::TAO_IOR_Manipulation::_tc_NotFound, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { @@ -561,25 +773,84 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul else { ACE_NEW_RETURN (_tao_elem, TAO_IOP::TAO_IOR_Manipulation::NotFound, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (TAO_IOP::TAO_IOR_Manipulation::_tc_NotFound, _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 (TAO_IOP::TAO_IOR_Manipulation::_tc_NotFound, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + TAO_IOP::TAO_IOR_Manipulation::_tc_NotFound, + 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 TAO_IOP::TAO_IOR_Manipulation::NotFound *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (TAO_IOP::TAO_IOR_Manipulation::_tc_NotFound, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (TAO_IOP::TAO_IOR_Manipulation::NotFound *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, TAO_IOP::TAO_IOR_Manipulation::NotFound, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(TAO_IOP::TAO_IOR_Manipulation::NotFound *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + TAO_IOP::TAO_IOR_Manipulation::_tc_NotFound, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (TAO_IOP::TAO_IOR_Manipulation::NotFound *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (TAO_IOP::TAO_IOR_Manipulation::NotFound *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (TAO_IOP::TAO_IOR_Manipulation::NotFound *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; @@ -587,14 +858,24 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul void operator<<= (CORBA::Any &_tao_any, const TAO_IOP::TAO_IOR_Manipulation::Duplicate &_tao_elem) // copying { - TAO_IOP::TAO_IOR_Manipulation::Duplicate *_tao_any_val = new TAO_IOP::TAO_IOR_Manipulation::Duplicate (_tao_elem); + TAO_IOP::TAO_IOR_Manipulation::Duplicate *_tao_any_val = 0; + ACE_NEW (_tao_any_val, TAO_IOP::TAO_IOR_Manipulation::Duplicate (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (TAO_IOP::TAO_IOR_Manipulation::_tc_Duplicate, _tao_any_val, 1, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_any_val; + _tao_any._tao_replace ( + TAO_IOP::TAO_IOR_Manipulation::_tc_Duplicate, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } - ACE_CATCHANY + ACE_CATCHANY { delete _tao_any_val; } @@ -605,10 +886,23 @@ void operator<<= (CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipulation::Duplicate { ACE_TRY_NEW_ENV { - _tao_any.replace (TAO_IOP::TAO_IOR_Manipulation::_tc_Duplicate, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + TAO_IOP::TAO_IOR_Manipulation::_tc_Duplicate, + 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; } @@ -617,7 +911,11 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (TAO_IOP::TAO_IOR_Manipulation::_tc_Duplicate, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (TAO_IOP::TAO_IOR_Manipulation::_tc_Duplicate, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { @@ -627,25 +925,84 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul else { ACE_NEW_RETURN (_tao_elem, TAO_IOP::TAO_IOR_Manipulation::Duplicate, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (TAO_IOP::TAO_IOR_Manipulation::_tc_Duplicate, _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 (TAO_IOP::TAO_IOR_Manipulation::_tc_Duplicate, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + TAO_IOP::TAO_IOR_Manipulation::_tc_Duplicate, + 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 TAO_IOP::TAO_IOR_Manipulation::Duplicate *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (TAO_IOP::TAO_IOR_Manipulation::_tc_Duplicate, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (TAO_IOP::TAO_IOR_Manipulation::Duplicate *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, TAO_IOP::TAO_IOR_Manipulation::Duplicate, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(TAO_IOP::TAO_IOR_Manipulation::Duplicate *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + TAO_IOP::TAO_IOR_Manipulation::_tc_Duplicate, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (TAO_IOP::TAO_IOR_Manipulation::Duplicate *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (TAO_IOP::TAO_IOR_Manipulation::Duplicate *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (TAO_IOP::TAO_IOR_Manipulation::Duplicate *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; @@ -653,14 +1010,24 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul void operator<<= (CORBA::Any &_tao_any, const TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR &_tao_elem) // copying { - TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR *_tao_any_val = new TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR (_tao_elem); + TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR *_tao_any_val = 0; + ACE_NEW (_tao_any_val, TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (TAO_IOP::TAO_IOR_Manipulation::_tc_Invalid_IOR, _tao_any_val, 1, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_any_val; + _tao_any._tao_replace ( + TAO_IOP::TAO_IOR_Manipulation::_tc_Invalid_IOR, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } - ACE_CATCHANY + ACE_CATCHANY { delete _tao_any_val; } @@ -671,10 +1038,23 @@ void operator<<= (CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipulation::Invalid_I { ACE_TRY_NEW_ENV { - _tao_any.replace (TAO_IOP::TAO_IOR_Manipulation::_tc_Invalid_IOR, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + TAO_IOP::TAO_IOR_Manipulation::_tc_Invalid_IOR, + 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; } @@ -683,7 +1063,11 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (TAO_IOP::TAO_IOR_Manipulation::_tc_Invalid_IOR, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (TAO_IOP::TAO_IOR_Manipulation::_tc_Invalid_IOR, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { @@ -693,25 +1077,84 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul else { ACE_NEW_RETURN (_tao_elem, TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (TAO_IOP::TAO_IOR_Manipulation::_tc_Invalid_IOR, _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 (TAO_IOP::TAO_IOR_Manipulation::_tc_Invalid_IOR, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + TAO_IOP::TAO_IOR_Manipulation::_tc_Invalid_IOR, + 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 TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (TAO_IOP::TAO_IOR_Manipulation::_tc_Invalid_IOR, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + TAO_IOP::TAO_IOR_Manipulation::_tc_Invalid_IOR, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; @@ -727,8 +1170,23 @@ void operator<<= ( if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (TAO_IOP::TAO_IOR_Manipulation::_tc_IORList, _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 ( + TAO_IOP::TAO_IOR_Manipulation::_tc_IORList, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_any_val; + } } ACE_CATCHANY { @@ -741,10 +1199,23 @@ void operator<<= (CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipulation::IORList * { ACE_TRY_NEW_ENV { - _tao_any.replace (TAO_IOP::TAO_IOR_Manipulation::_tc_IORList, _tao_elem, 0, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + TAO_IOP::TAO_IOR_Manipulation::_tc_IORList, + 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; } @@ -753,7 +1224,11 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (TAO_IOP::TAO_IOR_Manipulation::_tc_IORList, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (TAO_IOP::TAO_IOR_Manipulation::_tc_IORList, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { @@ -763,25 +1238,84 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul else { ACE_NEW_RETURN (_tao_elem, TAO_IOP::TAO_IOR_Manipulation::IORList, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (TAO_IOP::TAO_IOR_Manipulation::_tc_IORList, _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 (TAO_IOP::TAO_IOR_Manipulation::_tc_IORList, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + TAO_IOP::TAO_IOR_Manipulation::_tc_IORList, + 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 TAO_IOP::TAO_IOR_Manipulation::IORList *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (TAO_IOP::TAO_IOR_Manipulation::_tc_IORList, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (TAO_IOP::TAO_IOR_Manipulation::IORList *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, TAO_IOP::TAO_IOR_Manipulation::IORList, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(TAO_IOP::TAO_IOR_Manipulation::IORList *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + TAO_IOP::TAO_IOR_Manipulation::_tc_IORList, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (TAO_IOP::TAO_IOR_Manipulation::IORList *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (TAO_IOP::TAO_IOR_Manipulation::IORList *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (TAO_IOP::TAO_IOR_Manipulation::IORList *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; diff --git a/TAO/tao/IORC.h b/TAO/tao/IORC.h index 8867ae07ca4..4c52fccca98 100644 --- a/TAO/tao/IORC.h +++ b/TAO/tao/IORC.h @@ -1,6 +1,7 @@ /* -*- C++ -*- */ // $Id$ + // ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* // TAO and the TAO IDL Compiler have been developed by the Center for // Distributed Object Computing at Washington University, St. Louis. @@ -148,6 +149,11 @@ TAO_NAMESPACE TAO_IOP virtual void _raise (void); + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static EmptyProfileList *_narrow (CORBA::Exception *); @@ -186,6 +192,11 @@ TAO_NAMESPACE TAO_IOP virtual void _raise (void); + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static NotFound *_narrow (CORBA::Exception *); @@ -224,6 +235,11 @@ TAO_NAMESPACE TAO_IOP virtual void _raise (void); + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static Duplicate *_narrow (CORBA::Exception *); @@ -262,6 +278,11 @@ TAO_NAMESPACE TAO_IOP virtual void _raise (void); + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static Invalid_IOR *_narrow (CORBA::Exception *); @@ -458,24 +479,50 @@ TAO_NAMESPACE TAO_IOP TAO_NAMESPACE_CLOSE // module TAO_IOP // Any operators for interface TAO_IOP::TAO_IOR_Manipulation -TAO_Export void operator<<= (CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation_ptr); -CORBA::Boolean operator>>= (const CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation *&); -TAO_Export void operator<<= (CORBA::Any &, const TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList &); // copying version -TAO_Export void operator<<= (CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList *&); -TAO_Export void operator<<= (CORBA::Any &, const TAO_IOP::TAO_IOR_Manipulation::NotFound &); // copying version -TAO_Export void operator<<= (CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::NotFound*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::NotFound *&); -TAO_Export void operator<<= (CORBA::Any &, const TAO_IOP::TAO_IOR_Manipulation::Duplicate &); // copying version -TAO_Export void operator<<= (CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::Duplicate*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::Duplicate *&); -TAO_Export void operator<<= (CORBA::Any &, const TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR &); // copying version -TAO_Export void operator<<= (CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR *&); -TAO_Export void operator<<= (CORBA::Any &, const TAO_IOP::TAO_IOR_Manipulation::IORList &); // copying version -TAO_Export void operator<<= (CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::IORList*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::IORList *&); - +TAO_Export void operator<<= (CORBA::Any &, + TAO_IOP::TAO_IOR_Manipulation_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + TAO_IOP::TAO_IOR_Manipulation *&); +TAO_Export void operator<<= (CORBA::Any &, + const TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList *&); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList *&); +TAO_Export void operator<<= (CORBA::Any &, + const TAO_IOP::TAO_IOR_Manipulation::NotFound &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + TAO_IOP::TAO_IOR_Manipulation::NotFound*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + TAO_IOP::TAO_IOR_Manipulation::NotFound *&); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const TAO_IOP::TAO_IOR_Manipulation::NotFound *&); +TAO_Export void operator<<= (CORBA::Any &, + const TAO_IOP::TAO_IOR_Manipulation::Duplicate &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + TAO_IOP::TAO_IOR_Manipulation::Duplicate*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + TAO_IOP::TAO_IOR_Manipulation::Duplicate *&); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const TAO_IOP::TAO_IOR_Manipulation::Duplicate *&); +TAO_Export void operator<<= (CORBA::Any &, + const TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR *&); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR *&); +TAO_Export void operator<<= (CORBA::Any &, + const TAO_IOP::TAO_IOR_Manipulation::IORList &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + TAO_IOP::TAO_IOR_Manipulation::IORList*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + TAO_IOP::TAO_IOR_Manipulation::IORList *&); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const TAO_IOP::TAO_IOR_Manipulation::IORList *&); #ifndef __ACE_INLINE__ TAO_Export CORBA::Boolean diff --git a/TAO/tao/IORC.i b/TAO/tao/IORC.i index 383f708619a..372c1ac5cc2 100644 --- a/TAO/tao/IORC.i +++ b/TAO/tao/IORC.i @@ -239,7 +239,7 @@ ACE_INLINE TAO_IOP::TAO_IOR_Manipulation::IORList_var::IORList_var (const TAO_IOP::TAO_IOR_Manipulation::IORList_var &p) // copy constructor { if (p.ptr_) - ACE_NEW (this->ptr_, + ACE_NEW (this->ptr_, TAO_IOP::TAO_IOR_Manipulation::IORList(*p.ptr_)); else this->ptr_ = 0; @@ -265,9 +265,9 @@ TAO_IOP::TAO_IOR_Manipulation::IORList_var::operator= (const TAO_IOP::TAO_IOR_Ma if (this != &p) { delete this->ptr_; - ACE_NEW_RETURN (this->ptr_, - TAO_IOP::TAO_IOR_Manipulation::IORList (*p.ptr_), - *this); + ACE_NEW_RETURN (this->ptr_, + TAO_IOP::TAO_IOR_Manipulation::IORList (*p.ptr_), + *this); } return *this; } @@ -428,17 +428,9 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const TAO_IOP::TAO_IO return 0; } -ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList &_tao_aggregate) +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &, TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList &) { - // retrieve RepoID and verify if we are of that type - char *_tao_repoID; - if ((strm >> _tao_repoID) && - (_tao_aggregate._is_a (_tao_repoID))) - { - return 1; - } - else - return 0; + return 1; } ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const TAO_IOP::TAO_IOR_Manipulation::NotFound &_tao_aggregate) @@ -450,17 +442,9 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const TAO_IOP::TAO_IO return 0; } -ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, TAO_IOP::TAO_IOR_Manipulation::NotFound &_tao_aggregate) +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &, TAO_IOP::TAO_IOR_Manipulation::NotFound &) { - // retrieve RepoID and verify if we are of that type - char *_tao_repoID; - if ((strm >> _tao_repoID) && - (_tao_aggregate._is_a (_tao_repoID))) - { - return 1; - } - else - return 0; + return 1; } ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const TAO_IOP::TAO_IOR_Manipulation::Duplicate &_tao_aggregate) @@ -472,17 +456,9 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const TAO_IOP::TAO_IO return 0; } -ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, TAO_IOP::TAO_IOR_Manipulation::Duplicate &_tao_aggregate) +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &, TAO_IOP::TAO_IOR_Manipulation::Duplicate &) { - // retrieve RepoID and verify if we are of that type - char *_tao_repoID; - if ((strm >> _tao_repoID) && - (_tao_aggregate._is_a (_tao_repoID))) - { - return 1; - } - else - return 0; + return 1; } ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR &_tao_aggregate) @@ -494,17 +470,9 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const TAO_IOP::TAO_IO return 0; } -ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR &_tao_aggregate) +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &, TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR &) { - // retrieve RepoID and verify if we are of that type - char *_tao_repoID; - if ((strm >> _tao_repoID) && - (_tao_aggregate._is_a (_tao_repoID))) - { - return 1; - } - else - return 0; + return 1; } CORBA::Boolean operator<< ( diff --git a/TAO/tao/IOR_LookupTable.cpp b/TAO/tao/IOR_LookupTable.cpp index ca40f54cac8..7529a91ebbe 100644 --- a/TAO/tao/IOR_LookupTable.cpp +++ b/TAO/tao/IOR_LookupTable.cpp @@ -11,7 +11,6 @@ ACE_RCSID(tao, IOR_TableLookup, "$Id$") - int TAO_IOR_LookupTable_Callback::find_ior (const ACE_CString &, ACE_CString &) diff --git a/TAO/tao/IOR_LookupTable.h b/TAO/tao/IOR_LookupTable.h index c58c97269ab..73f72837138 100644 --- a/TAO/tao/IOR_LookupTable.h +++ b/TAO/tao/IOR_LookupTable.h @@ -1,8 +1,6 @@ /* -*- C++ -*- */ // $Id$ - - // ============================================================================ // // = LIBRARY diff --git a/TAO/tao/ImplRepoC.cpp b/TAO/tao/ImplRepoC.cpp index 501c2bbf0d8..7d38911b67e 100644 --- a/TAO/tao/ImplRepoC.cpp +++ b/TAO/tao/ImplRepoC.cpp @@ -1,6 +1,7 @@ /* -*- C++ -*- $Id$ */ + // ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* // TAO and the TAO IDL Compiler have been developed by the Center for // Distributed Object Computing at Washington University, St. Louis. @@ -990,6 +991,22 @@ void ImplementationRepository::Administration::AlreadyRegistered::_raise () TAO_RAISE(*this); } +void ImplementationRepository::Administration::AlreadyRegistered::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void ImplementationRepository::Administration::AlreadyRegistered::_tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + // TAO extension - the _alloc method CORBA::Exception *ImplementationRepository::Administration::AlreadyRegistered::_alloc (void) { @@ -1052,6 +1069,22 @@ void ImplementationRepository::Administration::CannotActivate::_raise () TAO_RAISE(*this); } +void ImplementationRepository::Administration::CannotActivate::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void ImplementationRepository::Administration::CannotActivate::_tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + // TAO extension - the _alloc method CORBA::Exception *ImplementationRepository::Administration::CannotActivate::_alloc (void) { @@ -1123,6 +1156,22 @@ void ImplementationRepository::Administration::NotFound::_raise () TAO_RAISE(*this); } +void ImplementationRepository::Administration::NotFound::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void ImplementationRepository::Administration::NotFound::_tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + // TAO extension - the _alloc method CORBA::Exception *ImplementationRepository::Administration::NotFound::_alloc (void) { @@ -2977,8 +3026,23 @@ void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ServerObject_p { ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); *_tao_obj_ptr = ImplementationRepository::ServerObject::_duplicate (_tao_elem); - _tao_any.replace (ImplementationRepository::_tc_ServerObject, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + ImplementationRepository::_tc_ServerObject, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -2990,34 +3054,49 @@ void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ServerObject_p CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::ServerObject_ptr &_tao_elem) { CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = ImplementationRepository::ServerObject::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equivalent (ImplementationRepository::_tc_ServerObject, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (ImplementationRepository::_tc_ServerObject, 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 (ImplementationRepository::_tc_ServerObject, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + if (stream >> _tao_obj_var.out ()) { _tao_elem = ImplementationRepository::ServerObject::_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 (ImplementationRepository::_tc_ServerObject, tmp, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + ImplementationRepository::_tc_ServerObject, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = ImplementationRepository::ServerObject::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = ImplementationRepository::ServerObject::_nil (); return 0; } @@ -3032,12 +3111,21 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::EnvironmentVariable &_tao_elem) // copying { - ImplementationRepository::EnvironmentVariable *_any_val; + ImplementationRepository::EnvironmentVariable *_any_val = 0; ACE_NEW (_any_val, ImplementationRepository::EnvironmentVariable (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (ImplementationRepository::_tc_EnvironmentVariable, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + ImplementationRepository::_tc_EnvironmentVariable, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -3051,10 +3139,23 @@ void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::EnvironmentVar { ACE_TRY_NEW_ENV { - _tao_any.replace (ImplementationRepository::_tc_EnvironmentVariable, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + ImplementationRepository::_tc_EnvironmentVariable, + 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; } @@ -3063,35 +3164,98 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equivalent (ImplementationRepository::_tc_EnvironmentVariable, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (ImplementationRepository::_tc_EnvironmentVariable, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (ImplementationRepository::EnvironmentVariable *)_tao_any.value (); return 1; - } + } else { ACE_NEW_RETURN (_tao_elem, ImplementationRepository::EnvironmentVariable, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (ImplementationRepository::_tc_EnvironmentVariable, _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 (ImplementationRepository::_tc_EnvironmentVariable, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + ImplementationRepository::_tc_EnvironmentVariable, + 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 ImplementationRepository::EnvironmentVariable *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (ImplementationRepository::_tc_EnvironmentVariable, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (ImplementationRepository::EnvironmentVariable *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, ImplementationRepository::EnvironmentVariable, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(ImplementationRepository::EnvironmentVariable *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + ImplementationRepository::_tc_EnvironmentVariable, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (ImplementationRepository::EnvironmentVariable *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (ImplementationRepository::EnvironmentVariable *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (ImplementationRepository::EnvironmentVariable *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; @@ -3107,8 +3271,23 @@ void operator<<= ( if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (ImplementationRepository::_tc_EnvironmentList, _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 ( + ImplementationRepository::_tc_EnvironmentList, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_any_val; + } } ACE_CATCHANY { @@ -3121,10 +3300,23 @@ void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::EnvironmentLis { ACE_TRY_NEW_ENV { - _tao_any.replace (ImplementationRepository::_tc_EnvironmentList, _tao_elem, 0, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + ImplementationRepository::_tc_EnvironmentList, + 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; } @@ -3133,7 +3325,11 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equivalent (ImplementationRepository::_tc_EnvironmentList, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (ImplementationRepository::_tc_EnvironmentList, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { @@ -3143,25 +3339,84 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository else { ACE_NEW_RETURN (_tao_elem, ImplementationRepository::EnvironmentList, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (ImplementationRepository::_tc_EnvironmentList, _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 (ImplementationRepository::_tc_EnvironmentList, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + ImplementationRepository::_tc_EnvironmentList, + 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 ImplementationRepository::EnvironmentList *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (ImplementationRepository::_tc_EnvironmentList, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (ImplementationRepository::EnvironmentList *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, ImplementationRepository::EnvironmentList, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(ImplementationRepository::EnvironmentList *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + ImplementationRepository::_tc_EnvironmentList, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (ImplementationRepository::EnvironmentList *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (ImplementationRepository::EnvironmentList *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (ImplementationRepository::EnvironmentList *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; @@ -3169,18 +3424,27 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ActivationMode _tao_elem) { - ImplementationRepository::ActivationMode *_any_val; - ACE_NEW (_any_val, ImplementationRepository::ActivationMode (_tao_elem)); - if (!_any_val) return; + ImplementationRepository::ActivationMode *_tao_any_val; + ACE_NEW (_tao_any_val, ImplementationRepository::ActivationMode (_tao_elem)); + if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (ImplementationRepository::_tc_ActivationMode, _any_val, 1, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_any_val; + _tao_any._tao_replace ( + ImplementationRepository::_tc_ActivationMode, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY { // free allocated storage - delete _any_val; + delete _tao_any_val; } ACE_ENDTRY; } @@ -3190,14 +3454,19 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equivalent (ImplementationRepository::_tc_ActivationMode, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (ImplementationRepository::_tc_ActivationMode, 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.decode (ImplementationRepository::_tc_ActivationMode, &_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) + { return 1; - ACE_TRY_CHECK; + } } ACE_CATCHANY { @@ -3209,12 +3478,21 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::StartupOptions &_tao_elem) // copying { - ImplementationRepository::StartupOptions *_any_val; + ImplementationRepository::StartupOptions *_any_val = 0; ACE_NEW (_any_val, ImplementationRepository::StartupOptions (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (ImplementationRepository::_tc_StartupOptions, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + ImplementationRepository::_tc_StartupOptions, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -3228,10 +3506,23 @@ void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::StartupOptions { ACE_TRY_NEW_ENV { - _tao_any.replace (ImplementationRepository::_tc_StartupOptions, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + ImplementationRepository::_tc_StartupOptions, + 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; } @@ -3240,35 +3531,98 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equivalent (ImplementationRepository::_tc_StartupOptions, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (ImplementationRepository::_tc_StartupOptions, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (ImplementationRepository::StartupOptions *)_tao_any.value (); return 1; - } + } else { ACE_NEW_RETURN (_tao_elem, ImplementationRepository::StartupOptions, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (ImplementationRepository::_tc_StartupOptions, _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 (ImplementationRepository::_tc_StartupOptions, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + ImplementationRepository::_tc_StartupOptions, + 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 ImplementationRepository::StartupOptions *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (ImplementationRepository::_tc_StartupOptions, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (ImplementationRepository::StartupOptions *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, ImplementationRepository::StartupOptions, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(ImplementationRepository::StartupOptions *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + ImplementationRepository::_tc_StartupOptions, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (ImplementationRepository::StartupOptions *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (ImplementationRepository::StartupOptions *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (ImplementationRepository::StartupOptions *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; @@ -3276,12 +3630,21 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::ServerInformation &_tao_elem) // copying { - ImplementationRepository::ServerInformation *_any_val; + ImplementationRepository::ServerInformation *_any_val = 0; ACE_NEW (_any_val, ImplementationRepository::ServerInformation (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (ImplementationRepository::_tc_ServerInformation, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + ImplementationRepository::_tc_ServerInformation, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -3295,10 +3658,23 @@ void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ServerInformat { ACE_TRY_NEW_ENV { - _tao_any.replace (ImplementationRepository::_tc_ServerInformation, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + ImplementationRepository::_tc_ServerInformation, + 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; } @@ -3307,35 +3683,98 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equivalent (ImplementationRepository::_tc_ServerInformation, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (ImplementationRepository::_tc_ServerInformation, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (ImplementationRepository::ServerInformation *)_tao_any.value (); return 1; - } + } else { ACE_NEW_RETURN (_tao_elem, ImplementationRepository::ServerInformation, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (ImplementationRepository::_tc_ServerInformation, _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 (ImplementationRepository::_tc_ServerInformation, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + ImplementationRepository::_tc_ServerInformation, + 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 ImplementationRepository::ServerInformation *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (ImplementationRepository::_tc_ServerInformation, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (ImplementationRepository::ServerInformation *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, ImplementationRepository::ServerInformation, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(ImplementationRepository::ServerInformation *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + ImplementationRepository::_tc_ServerInformation, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (ImplementationRepository::ServerInformation *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (ImplementationRepository::ServerInformation *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (ImplementationRepository::ServerInformation *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; @@ -3351,8 +3790,23 @@ void operator<<= ( if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (ImplementationRepository::_tc_ServerInformationList, _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 ( + ImplementationRepository::_tc_ServerInformationList, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_any_val; + } } ACE_CATCHANY { @@ -3365,10 +3819,23 @@ void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ServerInformat { ACE_TRY_NEW_ENV { - _tao_any.replace (ImplementationRepository::_tc_ServerInformationList, _tao_elem, 0, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + ImplementationRepository::_tc_ServerInformationList, + 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; } @@ -3377,7 +3844,11 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equivalent (ImplementationRepository::_tc_ServerInformationList, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (ImplementationRepository::_tc_ServerInformationList, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { @@ -3387,25 +3858,84 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository else { ACE_NEW_RETURN (_tao_elem, ImplementationRepository::ServerInformationList, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (ImplementationRepository::_tc_ServerInformationList, _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 (ImplementationRepository::_tc_ServerInformationList, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + ImplementationRepository::_tc_ServerInformationList, + 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 ImplementationRepository::ServerInformationList *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (ImplementationRepository::_tc_ServerInformationList, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (ImplementationRepository::ServerInformationList *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, ImplementationRepository::ServerInformationList, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(ImplementationRepository::ServerInformationList *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + ImplementationRepository::_tc_ServerInformationList, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (ImplementationRepository::ServerInformationList *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (ImplementationRepository::ServerInformationList *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (ImplementationRepository::ServerInformationList *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; @@ -3421,8 +3951,23 @@ void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::Administration { ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); *_tao_obj_ptr = ImplementationRepository::Administration::_duplicate (_tao_elem); - _tao_any.replace (ImplementationRepository::_tc_Administration, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + ImplementationRepository::_tc_Administration, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -3434,34 +3979,49 @@ void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::Administration CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::Administration_ptr &_tao_elem) { CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = ImplementationRepository::Administration::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equivalent (ImplementationRepository::_tc_Administration, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (ImplementationRepository::_tc_Administration, 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 (ImplementationRepository::_tc_Administration, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + if (stream >> _tao_obj_var.out ()) { _tao_elem = ImplementationRepository::Administration::_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 (ImplementationRepository::_tc_Administration, tmp, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + ImplementationRepository::_tc_Administration, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = ImplementationRepository::Administration::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = ImplementationRepository::Administration::_nil (); return 0; } @@ -3478,9 +4038,19 @@ void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::Administ { ImplementationRepository::Administration::AlreadyRegistered *_tao_any_val = 0; ACE_NEW (_tao_any_val, ImplementationRepository::Administration::AlreadyRegistered (_tao_elem)); + if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (ImplementationRepository::Administration::_tc_AlreadyRegistered, _tao_any_val, 1, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_any_val; + _tao_any._tao_replace ( + ImplementationRepository::Administration::_tc_AlreadyRegistered, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -3494,10 +4064,23 @@ void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::Administration { ACE_TRY_NEW_ENV { - _tao_any.replace (ImplementationRepository::Administration::_tc_AlreadyRegistered, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + ImplementationRepository::Administration::_tc_AlreadyRegistered, + 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; } @@ -3506,7 +4089,11 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equivalent (ImplementationRepository::Administration::_tc_AlreadyRegistered, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (ImplementationRepository::Administration::_tc_AlreadyRegistered, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { @@ -3516,25 +4103,84 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository else { ACE_NEW_RETURN (_tao_elem, ImplementationRepository::Administration::AlreadyRegistered, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (ImplementationRepository::Administration::_tc_AlreadyRegistered, _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 (ImplementationRepository::Administration::_tc_AlreadyRegistered, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + ImplementationRepository::Administration::_tc_AlreadyRegistered, + 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 ImplementationRepository::Administration::AlreadyRegistered *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (ImplementationRepository::Administration::_tc_AlreadyRegistered, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (ImplementationRepository::Administration::AlreadyRegistered *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, ImplementationRepository::Administration::AlreadyRegistered, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(ImplementationRepository::Administration::AlreadyRegistered *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + ImplementationRepository::Administration::_tc_AlreadyRegistered, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (ImplementationRepository::Administration::AlreadyRegistered *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (ImplementationRepository::Administration::AlreadyRegistered *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (ImplementationRepository::Administration::AlreadyRegistered *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; @@ -3544,9 +4190,19 @@ void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::Administ { ImplementationRepository::Administration::CannotActivate *_tao_any_val = 0; ACE_NEW (_tao_any_val, ImplementationRepository::Administration::CannotActivate (_tao_elem)); + if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (ImplementationRepository::Administration::_tc_CannotActivate, _tao_any_val, 1, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_any_val; + _tao_any._tao_replace ( + ImplementationRepository::Administration::_tc_CannotActivate, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -3560,10 +4216,23 @@ void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::Administration { ACE_TRY_NEW_ENV { - _tao_any.replace (ImplementationRepository::Administration::_tc_CannotActivate, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + ImplementationRepository::Administration::_tc_CannotActivate, + 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; } @@ -3572,7 +4241,11 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equivalent (ImplementationRepository::Administration::_tc_CannotActivate, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (ImplementationRepository::Administration::_tc_CannotActivate, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { @@ -3582,25 +4255,84 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository else { ACE_NEW_RETURN (_tao_elem, ImplementationRepository::Administration::CannotActivate, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (ImplementationRepository::Administration::_tc_CannotActivate, _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 (ImplementationRepository::Administration::_tc_CannotActivate, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + ImplementationRepository::Administration::_tc_CannotActivate, + 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 ImplementationRepository::Administration::CannotActivate *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (ImplementationRepository::Administration::_tc_CannotActivate, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (ImplementationRepository::Administration::CannotActivate *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, ImplementationRepository::Administration::CannotActivate, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(ImplementationRepository::Administration::CannotActivate *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + ImplementationRepository::Administration::_tc_CannotActivate, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (ImplementationRepository::Administration::CannotActivate *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (ImplementationRepository::Administration::CannotActivate *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (ImplementationRepository::Administration::CannotActivate *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; @@ -3610,9 +4342,19 @@ void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::Administ { ImplementationRepository::Administration::NotFound *_tao_any_val = 0; ACE_NEW (_tao_any_val, ImplementationRepository::Administration::NotFound (_tao_elem)); + if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (ImplementationRepository::Administration::_tc_NotFound, _tao_any_val, 1, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_any_val; + _tao_any._tao_replace ( + ImplementationRepository::Administration::_tc_NotFound, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -3626,10 +4368,23 @@ void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::Administration { ACE_TRY_NEW_ENV { - _tao_any.replace (ImplementationRepository::Administration::_tc_NotFound, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + ImplementationRepository::Administration::_tc_NotFound, + 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; } @@ -3638,7 +4393,11 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equivalent (ImplementationRepository::Administration::_tc_NotFound, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (ImplementationRepository::Administration::_tc_NotFound, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { @@ -3648,25 +4407,84 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository else { ACE_NEW_RETURN (_tao_elem, ImplementationRepository::Administration::NotFound, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (ImplementationRepository::Administration::_tc_NotFound, _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 (ImplementationRepository::Administration::_tc_NotFound, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + ImplementationRepository::Administration::_tc_NotFound, + 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 ImplementationRepository::Administration::NotFound *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (ImplementationRepository::Administration::_tc_NotFound, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (ImplementationRepository::Administration::NotFound *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, ImplementationRepository::Administration::NotFound, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(ImplementationRepository::Administration::NotFound *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + ImplementationRepository::Administration::_tc_NotFound, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (ImplementationRepository::Administration::NotFound *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (ImplementationRepository::Administration::NotFound *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (ImplementationRepository::Administration::NotFound *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; @@ -3682,8 +4500,23 @@ void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ServerInformat { ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); *_tao_obj_ptr = ImplementationRepository::ServerInformationIterator::_duplicate (_tao_elem); - _tao_any.replace (ImplementationRepository::_tc_ServerInformationIterator, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + ImplementationRepository::_tc_ServerInformationIterator, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -3695,34 +4528,49 @@ void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ServerInformat CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::ServerInformationIterator_ptr &_tao_elem) { CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = ImplementationRepository::ServerInformationIterator::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equivalent (ImplementationRepository::_tc_ServerInformationIterator, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (ImplementationRepository::_tc_ServerInformationIterator, 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 (ImplementationRepository::_tc_ServerInformationIterator, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + if (stream >> _tao_obj_var.out ()) { _tao_elem = ImplementationRepository::ServerInformationIterator::_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 (ImplementationRepository::_tc_ServerInformationIterator, tmp, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + ImplementationRepository::_tc_ServerInformationIterator, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = ImplementationRepository::ServerInformationIterator::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = ImplementationRepository::ServerInformationIterator::_nil (); return 0; } diff --git a/TAO/tao/ImplRepoC.h b/TAO/tao/ImplRepoC.h index ea715c172c5..870167331ad 100644 --- a/TAO/tao/ImplRepoC.h +++ b/TAO/tao/ImplRepoC.h @@ -58,7 +58,7 @@ TAO_NAMESPACE ImplementationRepository class ServerObject; typedef ServerObject *ServerObject_ptr; - + #endif /* end #if !defined */ @@ -72,14 +72,14 @@ TAO_NAMESPACE ImplementationRepository ServerObject_var (ServerObject_ptr); ServerObject_var (const ServerObject_var &); // copy constructor ~ServerObject_var (void); // destructor - + ServerObject_var &operator= (ServerObject_ptr); ServerObject_var &operator= (const ServerObject_var &); ServerObject_ptr operator-> (void) const; - + operator const ServerObject_ptr &() const; operator ServerObject_ptr &(); - // in, inout, out, _retn + // in, inout, out, _retn ServerObject_ptr in (void) const; ServerObject_ptr &inout (void); ServerObject_ptr &out (void); @@ -109,7 +109,7 @@ TAO_NAMESPACE ImplementationRepository operator ServerObject_ptr &(); ServerObject_ptr &ptr (void); ServerObject_ptr operator-> (void); - + private: ServerObject_ptr &ptr_; }; @@ -133,12 +133,12 @@ class TAO_Export ServerObject : public virtual ACE_CORBA_1 (Object) static ServerObject_ptr _duplicate (ServerObject_ptr obj); static ServerObject_ptr _narrow ( CORBA::Object_ptr obj, - CORBA::Environment &env = + CORBA::Environment &env = TAO_default_environment () ); static ServerObject_ptr _unchecked_narrow ( CORBA::Object_ptr obj, - CORBA::Environment &env = + CORBA::Environment &env = TAO_default_environment () ); static ServerObject_ptr _nil (void) @@ -147,7 +147,7 @@ class TAO_Export ServerObject : public virtual ACE_CORBA_1 (Object) } virtual void ping ( - CORBA::Environment &ACE_TRY_ENV = + CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ) ACE_THROW_SPEC (( @@ -155,7 +155,7 @@ class TAO_Export ServerObject : public virtual ACE_CORBA_1 (Object) )); virtual void shutdown ( - CORBA::Environment &ACE_TRY_ENV = + CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ) ACE_THROW_SPEC (( @@ -163,16 +163,16 @@ class TAO_Export ServerObject : public virtual ACE_CORBA_1 (Object) )); virtual CORBA::Boolean _is_a ( - const CORBA::Char *type_id, - CORBA::Environment &env = + const CORBA::Char *type_id, + CORBA::Environment &env = TAO_default_environment () ); virtual const char* _interface_repository_id (void) const; protected: ServerObject (void); - ServerObject (TAO_Stub *objref, - TAO_ServantBase *_tao_servant = 0, + ServerObject (TAO_Stub *objref, + TAO_ServantBase *_tao_servant = 0, CORBA::Boolean _tao_collocated = 0 ); virtual ~ServerObject (void); @@ -184,14 +184,14 @@ class TAO_Export ServerObject : public virtual ACE_CORBA_1 (Object) class TAO_ImplementationRepository_ServerObject_Default_Proxy_Factory { public: - + TAO_ImplementationRepository_ServerObject_Default_Proxy_Factory (int register_proxy_factory = 1); - + virtual ~TAO_ImplementationRepository_ServerObject_Default_Proxy_Factory (void); - + virtual ImplementationRepository::ServerObject_ptr create_proxy ( ImplementationRepository::ServerObject_ptr proxy, - CORBA::Environment &env = + CORBA::Environment &env = TAO_default_environment () ); }; @@ -199,23 +199,23 @@ public: class TAO_ImplementationRepository_ServerObject_Proxy_Factory_Adapter { public: - + friend class ACE_Singleton<TAO_ImplementationRepository_ServerObject_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>; - + int register_proxy_factory ( TAO_ImplementationRepository_ServerObject_Default_Proxy_Factory *df, - CORBA::Environment &env = + CORBA::Environment &env = TAO_default_environment () ); - + int unregister_proxy_factory ( - CORBA::Environment &env = + CORBA::Environment &env = TAO_default_environment () ); - + ImplementationRepository::ServerObject_ptr create_proxy ( ImplementationRepository::ServerObject_ptr proxy, - CORBA::Environment &env = + CORBA::Environment &env = TAO_default_environment () ); @@ -237,7 +237,7 @@ protected: TAO_ImplementationRepository_ServerObject_Smart_Proxy_Base (ImplementationRepository::ServerObject_ptr proxy); ~TAO_ImplementationRepository_ServerObject_Smart_Proxy_Base (void); virtual void ping ( - CORBA::Environment &ACE_TRY_ENV = + CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ) ACE_THROW_SPEC (( @@ -245,7 +245,7 @@ protected: )); virtual void shutdown ( - CORBA::Environment &ACE_TRY_ENV = + CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ) ACE_THROW_SPEC (( @@ -284,16 +284,16 @@ public: EnvironmentVariable_var (EnvironmentVariable *); EnvironmentVariable_var (const EnvironmentVariable_var &); // copy constructor ~EnvironmentVariable_var (void); // destructor - + EnvironmentVariable_var &operator= (EnvironmentVariable *); EnvironmentVariable_var &operator= (const EnvironmentVariable_var &); EnvironmentVariable *operator-> (void); const EnvironmentVariable *operator-> (void) const; - + operator const EnvironmentVariable &() const; operator EnvironmentVariable &(); operator EnvironmentVariable &() const; - // in, inout, out, _retn + // in, inout, out, _retn const EnvironmentVariable &in (void) const; EnvironmentVariable &inout (void); EnvironmentVariable *&out (void); @@ -315,7 +315,7 @@ public: operator EnvironmentVariable *&(); EnvironmentVariable *&ptr (void); EnvironmentVariable *operator-> (void); - + private: EnvironmentVariable *&ptr_; // assignment from T_var not allowed @@ -331,7 +331,7 @@ TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Address; #if !defined (TAO_USE_SEQUENCE_TEMPLATES) - + #if !defined (__TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CH_) #define __TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CH_ @@ -339,9 +339,9 @@ TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Address; { public: // = Initialization and termination methods. - + _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList (void); // Default constructor. - _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList (CORBA::ULong maximum); + _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList (CORBA::ULong maximum); _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList (CORBA::ULong maximum, CORBA::ULong length, EnvironmentVariable *data, @@ -358,7 +358,7 @@ TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Address; virtual void _allocate_buffer (CORBA::ULong length); virtual void _deallocate_buffer (void); // Implement the TAO_Base_Sequence methods (see Sequence.h) - + EnvironmentVariable *get_buffer (CORBA::Boolean orphan = 0); const EnvironmentVariable *get_buffer (void) const; void replace (CORBA::ULong max, @@ -370,7 +370,7 @@ TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Address; #endif /* end #if !defined */ -#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ #if !defined (_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CH_) #define _IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CH_ @@ -383,20 +383,20 @@ typedef EnvironmentList* EnvironmentList_ptr; // EnvironmentList // ************************************************************* -class TAO_Export EnvironmentList : public +class TAO_Export EnvironmentList : public #if !defined (TAO_USE_SEQUENCE_TEMPLATES) _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList #else /* TAO_USE_SEQUENCE_TEMPLATES */ TAO_Unbounded_Sequence<EnvironmentVariable> -#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ { public: EnvironmentList (void); // default ctor EnvironmentList (CORBA::ULong max); // uses max size EnvironmentList ( - CORBA::ULong max, - CORBA::ULong length, - EnvironmentVariable *buffer, + CORBA::ULong max, + CORBA::ULong length, + EnvironmentVariable *buffer, CORBA::Boolean release=0 ); EnvironmentList (const EnvironmentList &); // copy ctor @@ -426,17 +426,17 @@ public: EnvironmentList_var (EnvironmentList *); EnvironmentList_var (const EnvironmentList_var &); // copy constructor ~EnvironmentList_var (void); // destructor - + EnvironmentList_var &operator= (EnvironmentList *); EnvironmentList_var &operator= (const EnvironmentList_var &); EnvironmentList *operator-> (void); const EnvironmentList *operator-> (void) const; - + operator const EnvironmentList &() const; operator EnvironmentList &(); operator EnvironmentList &() const; EnvironmentVariable &operator[] (CORBA::ULong index); - // in, inout, out, _retn + // in, inout, out, _retn const EnvironmentList &in (void) const; EnvironmentList &inout (void); EnvironmentList *&out (void); @@ -466,7 +466,7 @@ public: EnvironmentList *&ptr (void); EnvironmentList *operator-> (void); EnvironmentVariable &operator[] (CORBA::ULong index); - + private: EnvironmentList *&ptr_; // assignment from T_var not allowed @@ -514,16 +514,16 @@ public: StartupOptions_var (StartupOptions *); StartupOptions_var (const StartupOptions_var &); // copy constructor ~StartupOptions_var (void); // destructor - + StartupOptions_var &operator= (StartupOptions *); StartupOptions_var &operator= (const StartupOptions_var &); StartupOptions *operator-> (void); const StartupOptions *operator-> (void) const; - + operator const StartupOptions &() const; operator StartupOptions &(); operator StartupOptions &() const; - // in, inout, out, _retn + // in, inout, out, _retn const StartupOptions &in (void) const; StartupOptions &inout (void); StartupOptions *&out (void); @@ -545,7 +545,7 @@ public: operator StartupOptions *&(); StartupOptions *&ptr (void); StartupOptions *operator-> (void); - + private: StartupOptions *&ptr_; // assignment from T_var not allowed @@ -579,16 +579,16 @@ public: ServerInformation_var (ServerInformation *); ServerInformation_var (const ServerInformation_var &); // copy constructor ~ServerInformation_var (void); // destructor - + ServerInformation_var &operator= (ServerInformation *); ServerInformation_var &operator= (const ServerInformation_var &); ServerInformation *operator-> (void); const ServerInformation *operator-> (void) const; - + operator const ServerInformation &() const; operator ServerInformation &(); operator ServerInformation &() const; - // in, inout, out, _retn + // in, inout, out, _retn const ServerInformation &in (void) const; ServerInformation &inout (void); ServerInformation *&out (void); @@ -610,7 +610,7 @@ public: operator ServerInformation *&(); ServerInformation *&ptr (void); ServerInformation *operator-> (void); - + private: ServerInformation *&ptr_; // assignment from T_var not allowed @@ -621,7 +621,7 @@ TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ServerInformation; #if !defined (TAO_USE_SEQUENCE_TEMPLATES) - + #if !defined (__TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CH_) #define __TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CH_ @@ -629,9 +629,9 @@ TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ServerInformation; { public: // = Initialization and termination methods. - + _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList (void); // Default constructor. - _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList (CORBA::ULong maximum); + _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList (CORBA::ULong maximum); _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList (CORBA::ULong maximum, CORBA::ULong length, ServerInformation *data, @@ -648,7 +648,7 @@ TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ServerInformation; virtual void _allocate_buffer (CORBA::ULong length); virtual void _deallocate_buffer (void); // Implement the TAO_Base_Sequence methods (see Sequence.h) - + ServerInformation *get_buffer (CORBA::Boolean orphan = 0); const ServerInformation *get_buffer (void) const; void replace (CORBA::ULong max, @@ -660,7 +660,7 @@ TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ServerInformation; #endif /* end #if !defined */ -#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ #if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CH_) #define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CH_ @@ -673,20 +673,20 @@ typedef ServerInformationList* ServerInformationList_ptr; // ServerInformationList // ************************************************************* -class TAO_Export ServerInformationList : public +class TAO_Export ServerInformationList : public #if !defined (TAO_USE_SEQUENCE_TEMPLATES) _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList #else /* TAO_USE_SEQUENCE_TEMPLATES */ TAO_Unbounded_Sequence<ServerInformation> -#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ { public: ServerInformationList (void); // default ctor ServerInformationList (CORBA::ULong max); // uses max size ServerInformationList ( - CORBA::ULong max, - CORBA::ULong length, - ServerInformation *buffer, + CORBA::ULong max, + CORBA::ULong length, + ServerInformation *buffer, CORBA::Boolean release=0 ); ServerInformationList (const ServerInformationList &); // copy ctor @@ -716,17 +716,17 @@ public: ServerInformationList_var (ServerInformationList *); ServerInformationList_var (const ServerInformationList_var &); // copy constructor ~ServerInformationList_var (void); // destructor - + ServerInformationList_var &operator= (ServerInformationList *); ServerInformationList_var &operator= (const ServerInformationList_var &); ServerInformationList *operator-> (void); const ServerInformationList *operator-> (void) const; - + operator const ServerInformationList &() const; operator ServerInformationList &(); operator ServerInformationList &() const; ServerInformation &operator[] (CORBA::ULong index); - // in, inout, out, _retn + // in, inout, out, _retn const ServerInformationList &in (void) const; ServerInformationList &inout (void); ServerInformationList *&out (void); @@ -756,7 +756,7 @@ public: ServerInformationList *&ptr (void); ServerInformationList *operator-> (void); ServerInformation &operator[] (CORBA::ULong index); - + private: ServerInformationList *&ptr_; // assignment from T_var not allowed @@ -788,14 +788,14 @@ public: ServerInformationIterator_var (ServerInformationIterator_ptr); ServerInformationIterator_var (const ServerInformationIterator_var &); // copy constructor ~ServerInformationIterator_var (void); // destructor - + ServerInformationIterator_var &operator= (ServerInformationIterator_ptr); ServerInformationIterator_var &operator= (const ServerInformationIterator_var &); ServerInformationIterator_ptr operator-> (void) const; - + operator const ServerInformationIterator_ptr &() const; operator ServerInformationIterator_ptr &(); - // in, inout, out, _retn + // in, inout, out, _retn ServerInformationIterator_ptr in (void) const; ServerInformationIterator_ptr &inout (void); ServerInformationIterator_ptr &out (void); @@ -825,7 +825,7 @@ public: operator ServerInformationIterator_ptr &(); ServerInformationIterator_ptr &ptr (void); ServerInformationIterator_ptr operator-> (void); - + private: ServerInformationIterator_ptr &ptr_; }; @@ -853,14 +853,14 @@ public: Administration_var (Administration_ptr); Administration_var (const Administration_var &); // copy constructor ~Administration_var (void); // destructor - + Administration_var &operator= (Administration_ptr); Administration_var &operator= (const Administration_var &); Administration_ptr operator-> (void) const; - + operator const Administration_ptr &() const; operator Administration_ptr &(); - // in, inout, out, _retn + // in, inout, out, _retn Administration_ptr in (void) const; Administration_ptr &inout (void); Administration_ptr &out (void); @@ -890,7 +890,7 @@ public: operator Administration_ptr &(); Administration_ptr &ptr (void); Administration_ptr operator-> (void); - + private: Administration_ptr &ptr_; }; @@ -914,12 +914,12 @@ public: static Administration_ptr _duplicate (Administration_ptr obj); static Administration_ptr _narrow ( CORBA::Object_ptr obj, - CORBA::Environment &env = + CORBA::Environment &env = TAO_default_environment () ); static Administration_ptr _unchecked_narrow ( CORBA::Object_ptr obj, - CORBA::Environment &env = + CORBA::Environment &env = TAO_default_environment () ); static Administration_ptr _nil (void) @@ -933,7 +933,7 @@ public: class AlreadyRegistered; typedef AlreadyRegistered *AlreadyRegistered_ptr; - + #endif /* end #if !defined */ @@ -957,6 +957,11 @@ public: virtual void _raise (void); + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static AlreadyRegistered *_narrow (CORBA::Exception *); @@ -976,7 +981,7 @@ public: class CannotActivate; typedef CannotActivate *CannotActivate_ptr; - + #endif /* end #if !defined */ @@ -1001,6 +1006,11 @@ public: virtual void _raise (void); + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static CannotActivate *_narrow (CORBA::Exception *); CannotActivate ( @@ -1023,7 +1033,7 @@ public: class NotFound; typedef NotFound *NotFound_ptr; - + #endif /* end #if !defined */ @@ -1047,6 +1057,11 @@ public: virtual void _raise (void); + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static NotFound *_narrow (CORBA::Exception *); @@ -1062,7 +1077,7 @@ public: virtual void activate_server ( const char * server, - CORBA::Environment &ACE_TRY_ENV = + CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ) ACE_THROW_SPEC (( @@ -1074,7 +1089,7 @@ public: virtual void register_server ( const char * server, const ImplementationRepository::StartupOptions & options, - CORBA::Environment &ACE_TRY_ENV = + CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ) ACE_THROW_SPEC (( @@ -1085,7 +1100,7 @@ public: virtual void reregister_server ( const char * server, const ImplementationRepository::StartupOptions & options, - CORBA::Environment &ACE_TRY_ENV = + CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ) ACE_THROW_SPEC (( @@ -1094,7 +1109,7 @@ public: virtual void remove_server ( const char * server, - CORBA::Environment &ACE_TRY_ENV = + CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ) ACE_THROW_SPEC (( @@ -1104,7 +1119,7 @@ public: virtual void shutdown_server ( const char * server, - CORBA::Environment &ACE_TRY_ENV = + CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ) ACE_THROW_SPEC (( @@ -1116,7 +1131,7 @@ public: const char * server, const char * addr, ImplementationRepository::ServerObject_ptr server_object, - CORBA::Environment &ACE_TRY_ENV = + CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ) ACE_THROW_SPEC (( @@ -1126,7 +1141,7 @@ public: virtual void server_is_shutting_down ( const char * server, - CORBA::Environment &ACE_TRY_ENV = + CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ) ACE_THROW_SPEC (( @@ -1137,7 +1152,7 @@ public: virtual void find ( const char * server, ImplementationRepository::ServerInformation_out info, - CORBA::Environment &ACE_TRY_ENV = + CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ) ACE_THROW_SPEC (( @@ -1149,7 +1164,7 @@ public: CORBA::ULong how_many, ImplementationRepository::ServerInformationList_out server_list, ImplementationRepository::ServerInformationIterator_out server_iterator, - CORBA::Environment &ACE_TRY_ENV = + CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ) ACE_THROW_SPEC (( @@ -1157,16 +1172,16 @@ public: )); virtual CORBA::Boolean _is_a ( - const CORBA::Char *type_id, - CORBA::Environment &env = + const CORBA::Char *type_id, + CORBA::Environment &env = TAO_default_environment () ); virtual const char* _interface_repository_id (void) const; protected: Administration (void); - Administration (TAO_Stub *objref, - TAO_ServantBase *_tao_servant = 0, + Administration (TAO_Stub *objref, + TAO_ServantBase *_tao_servant = 0, CORBA::Boolean _tao_collocated = 0 ); virtual ~Administration (void); @@ -1178,14 +1193,14 @@ private: class TAO_ImplementationRepository_Administration_Default_Proxy_Factory { public: - + TAO_ImplementationRepository_Administration_Default_Proxy_Factory (int register_proxy_factory = 1); - + virtual ~TAO_ImplementationRepository_Administration_Default_Proxy_Factory (void); - + virtual ImplementationRepository::Administration_ptr create_proxy ( ImplementationRepository::Administration_ptr proxy, - CORBA::Environment &env = + CORBA::Environment &env = TAO_default_environment () ); }; @@ -1193,23 +1208,23 @@ public: class TAO_ImplementationRepository_Administration_Proxy_Factory_Adapter { public: - + friend class ACE_Singleton<TAO_ImplementationRepository_Administration_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>; - + int register_proxy_factory ( TAO_ImplementationRepository_Administration_Default_Proxy_Factory *df, - CORBA::Environment &env = + CORBA::Environment &env = TAO_default_environment () ); - + int unregister_proxy_factory ( - CORBA::Environment &env = + CORBA::Environment &env = TAO_default_environment () ); - + ImplementationRepository::Administration_ptr create_proxy ( ImplementationRepository::Administration_ptr proxy, - CORBA::Environment &env = + CORBA::Environment &env = TAO_default_environment () ); @@ -1232,7 +1247,7 @@ protected: ~TAO_ImplementationRepository_Administration_Smart_Proxy_Base (void); virtual void activate_server ( const char * server, - CORBA::Environment &ACE_TRY_ENV = + CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ) ACE_THROW_SPEC (( @@ -1244,7 +1259,7 @@ protected: virtual void register_server ( const char * server, const ImplementationRepository::StartupOptions & options, - CORBA::Environment &ACE_TRY_ENV = + CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ) ACE_THROW_SPEC (( @@ -1255,7 +1270,7 @@ protected: virtual void reregister_server ( const char * server, const ImplementationRepository::StartupOptions & options, - CORBA::Environment &ACE_TRY_ENV = + CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ) ACE_THROW_SPEC (( @@ -1264,7 +1279,7 @@ protected: virtual void remove_server ( const char * server, - CORBA::Environment &ACE_TRY_ENV = + CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ) ACE_THROW_SPEC (( @@ -1274,7 +1289,7 @@ protected: virtual void shutdown_server ( const char * server, - CORBA::Environment &ACE_TRY_ENV = + CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ) ACE_THROW_SPEC (( @@ -1286,7 +1301,7 @@ protected: const char * server, const char * addr, ImplementationRepository::ServerObject_ptr server_object, - CORBA::Environment &ACE_TRY_ENV = + CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ) ACE_THROW_SPEC (( @@ -1296,7 +1311,7 @@ protected: virtual void server_is_shutting_down ( const char * server, - CORBA::Environment &ACE_TRY_ENV = + CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ) ACE_THROW_SPEC (( @@ -1307,7 +1322,7 @@ protected: virtual void find ( const char * server, ImplementationRepository::ServerInformation_out info, - CORBA::Environment &ACE_TRY_ENV = + CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ) ACE_THROW_SPEC (( @@ -1319,7 +1334,7 @@ protected: CORBA::ULong how_many, ImplementationRepository::ServerInformationList_out server_list, ImplementationRepository::ServerInformationIterator_out server_iterator, - CORBA::Environment &ACE_TRY_ENV = + CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ) ACE_THROW_SPEC (( @@ -1355,14 +1370,14 @@ public: ServerInformationIterator_var (ServerInformationIterator_ptr); ServerInformationIterator_var (const ServerInformationIterator_var &); // copy constructor ~ServerInformationIterator_var (void); // destructor - + ServerInformationIterator_var &operator= (ServerInformationIterator_ptr); ServerInformationIterator_var &operator= (const ServerInformationIterator_var &); ServerInformationIterator_ptr operator-> (void) const; - + operator const ServerInformationIterator_ptr &() const; operator ServerInformationIterator_ptr &(); - // in, inout, out, _retn + // in, inout, out, _retn ServerInformationIterator_ptr in (void) const; ServerInformationIterator_ptr &inout (void); ServerInformationIterator_ptr &out (void); @@ -1392,7 +1407,7 @@ public: operator ServerInformationIterator_ptr &(); ServerInformationIterator_ptr &ptr (void); ServerInformationIterator_ptr operator-> (void); - + private: ServerInformationIterator_ptr &ptr_; }; @@ -1416,12 +1431,12 @@ public: static ServerInformationIterator_ptr _duplicate (ServerInformationIterator_ptr obj); static ServerInformationIterator_ptr _narrow ( CORBA::Object_ptr obj, - CORBA::Environment &env = + CORBA::Environment &env = TAO_default_environment () ); static ServerInformationIterator_ptr _unchecked_narrow ( CORBA::Object_ptr obj, - CORBA::Environment &env = + CORBA::Environment &env = TAO_default_environment () ); static ServerInformationIterator_ptr _nil (void) @@ -1432,7 +1447,7 @@ public: virtual CORBA::Boolean next_n ( CORBA::ULong how_many, ImplementationRepository::ServerInformationList_out server_list, - CORBA::Environment &ACE_TRY_ENV = + CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ) ACE_THROW_SPEC (( @@ -1440,7 +1455,7 @@ public: )); virtual void destroy ( - CORBA::Environment &ACE_TRY_ENV = + CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ) ACE_THROW_SPEC (( @@ -1448,16 +1463,16 @@ public: )); virtual CORBA::Boolean _is_a ( - const CORBA::Char *type_id, - CORBA::Environment &env = + const CORBA::Char *type_id, + CORBA::Environment &env = TAO_default_environment () ); virtual const char* _interface_repository_id (void) const; protected: ServerInformationIterator (void); - ServerInformationIterator (TAO_Stub *objref, - TAO_ServantBase *_tao_servant = 0, + ServerInformationIterator (TAO_Stub *objref, + TAO_ServantBase *_tao_servant = 0, CORBA::Boolean _tao_collocated = 0 ); virtual ~ServerInformationIterator (void); @@ -1469,14 +1484,14 @@ private: class TAO_ImplementationRepository_ServerInformationIterator_Default_Proxy_Factory { public: - + TAO_ImplementationRepository_ServerInformationIterator_Default_Proxy_Factory (int register_proxy_factory = 1); - + virtual ~TAO_ImplementationRepository_ServerInformationIterator_Default_Proxy_Factory (void); - + virtual ImplementationRepository::ServerInformationIterator_ptr create_proxy ( ImplementationRepository::ServerInformationIterator_ptr proxy, - CORBA::Environment &env = + CORBA::Environment &env = TAO_default_environment () ); }; @@ -1484,23 +1499,23 @@ public: class TAO_ImplementationRepository_ServerInformationIterator_Proxy_Factory_Adapter { public: - + friend class ACE_Singleton<TAO_ImplementationRepository_ServerInformationIterator_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>; - + int register_proxy_factory ( TAO_ImplementationRepository_ServerInformationIterator_Default_Proxy_Factory *df, - CORBA::Environment &env = + CORBA::Environment &env = TAO_default_environment () ); - + int unregister_proxy_factory ( - CORBA::Environment &env = + CORBA::Environment &env = TAO_default_environment () ); - + ImplementationRepository::ServerInformationIterator_ptr create_proxy ( ImplementationRepository::ServerInformationIterator_ptr proxy, - CORBA::Environment &env = + CORBA::Environment &env = TAO_default_environment () ); @@ -1524,7 +1539,7 @@ protected: virtual CORBA::Boolean next_n ( CORBA::ULong how_many, ImplementationRepository::ServerInformationList_out server_list, - CORBA::Environment &ACE_TRY_ENV = + CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ) ACE_THROW_SPEC (( @@ -1532,7 +1547,7 @@ protected: )); virtual void destroy ( - CORBA::Environment &ACE_TRY_ENV = + CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ) ACE_THROW_SPEC (( @@ -1556,40 +1571,86 @@ extern TAO_Export ImplementationRepository::ServerObject_ptr (*_TAO_collocation_ CORBA::Object_ptr obj ); // Any operators for interface ImplementationRepository::ServerObject -TAO_Export void operator<<= (CORBA::Any &, ImplementationRepository::ServerObject_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::ServerObject *&); -TAO_Export void operator<<= (CORBA::Any &, const ImplementationRepository::EnvironmentVariable &); // copying version -TAO_Export void operator<<= (CORBA::Any &, ImplementationRepository::EnvironmentVariable*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::EnvironmentVariable *&); -TAO_Export void operator<<= (CORBA::Any &, const ImplementationRepository::EnvironmentList &); // copying version -TAO_Export void operator<<= (CORBA::Any &, ImplementationRepository::EnvironmentList*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::EnvironmentList *&); -TAO_Export void operator<<= (CORBA::Any &, ImplementationRepository::ActivationMode); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::ActivationMode &); -TAO_Export void operator<<= (CORBA::Any &, const ImplementationRepository::StartupOptions &); // copying version -TAO_Export void operator<<= (CORBA::Any &, ImplementationRepository::StartupOptions*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::StartupOptions *&); -TAO_Export void operator<<= (CORBA::Any &, const ImplementationRepository::ServerInformation &); // copying version -TAO_Export void operator<<= (CORBA::Any &, ImplementationRepository::ServerInformation*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::ServerInformation *&); -TAO_Export void operator<<= (CORBA::Any &, const ImplementationRepository::ServerInformationList &); // copying version -TAO_Export void operator<<= (CORBA::Any &, ImplementationRepository::ServerInformationList*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::ServerInformationList *&); +TAO_Export void operator<<= (CORBA::Any &, + ImplementationRepository::ServerObject_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + ImplementationRepository::ServerObject *&); +TAO_Export void operator<<= (CORBA::Any &, + const ImplementationRepository::EnvironmentVariable &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + ImplementationRepository::EnvironmentVariable*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + ImplementationRepository::EnvironmentVariable *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const ImplementationRepository::EnvironmentVariable *&); +TAO_Export void operator<<= (CORBA::Any &, + const ImplementationRepository::EnvironmentList &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + ImplementationRepository::EnvironmentList*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + ImplementationRepository::EnvironmentList *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const ImplementationRepository::EnvironmentList *&); +TAO_Export void operator<<= (CORBA::Any &, + ImplementationRepository::ActivationMode); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + ImplementationRepository::ActivationMode &); +TAO_Export void operator<<= (CORBA::Any &, + const ImplementationRepository::StartupOptions &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + ImplementationRepository::StartupOptions*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + ImplementationRepository::StartupOptions *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const ImplementationRepository::StartupOptions *&); +TAO_Export void operator<<= (CORBA::Any &, + const ImplementationRepository::ServerInformation &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + ImplementationRepository::ServerInformation*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + ImplementationRepository::ServerInformation *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const ImplementationRepository::ServerInformation *&); +TAO_Export void operator<<= (CORBA::Any &, + const ImplementationRepository::ServerInformationList &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + ImplementationRepository::ServerInformationList*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + ImplementationRepository::ServerInformationList *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const ImplementationRepository::ServerInformationList *&); extern TAO_Export ImplementationRepository::Administration_ptr (*_TAO_collocation_ImplementationRepository_Administration_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ); // Any operators for interface ImplementationRepository::Administration -TAO_Export void operator<<= (CORBA::Any &, ImplementationRepository::Administration_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::Administration *&); -TAO_Export void operator<<= (CORBA::Any &, const ImplementationRepository::Administration::AlreadyRegistered &); // copying version -TAO_Export void operator<<= (CORBA::Any &, ImplementationRepository::Administration::AlreadyRegistered*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::Administration::AlreadyRegistered *&); -TAO_Export void operator<<= (CORBA::Any &, const ImplementationRepository::Administration::CannotActivate &); // copying version -TAO_Export void operator<<= (CORBA::Any &, ImplementationRepository::Administration::CannotActivate*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::Administration::CannotActivate *&); -TAO_Export void operator<<= (CORBA::Any &, const ImplementationRepository::Administration::NotFound &); // copying version -TAO_Export void operator<<= (CORBA::Any &, ImplementationRepository::Administration::NotFound*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationRepository::Administration::NotFound *&); +TAO_Export void operator<<= (CORBA::Any &, + ImplementationRepository::Administration_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + ImplementationRepository::Administration *&); +TAO_Export void operator<<= (CORBA::Any &, + const ImplementationRepository::Administration::AlreadyRegistered &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + ImplementationRepository::Administration::AlreadyRegistered*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + ImplementationRepository::Administration::AlreadyRegistered *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const ImplementationRepository::Administration::AlreadyRegistered *&); +TAO_Export void operator<<= (CORBA::Any &, + const ImplementationRepository::Administration::CannotActivate &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + ImplementationRepository::Administration::CannotActivate*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + ImplementationRepository::Administration::CannotActivate *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const ImplementationRepository::Administration::CannotActivate *&); +TAO_Export void operator<<= (CORBA::Any &, + const ImplementationRepository::Administration::NotFound &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + ImplementationRepository::Administration::NotFound*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + ImplementationRepository::Administration::NotFound *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const ImplementationRepository::Administration::NotFound *&); extern TAO_Export ImplementationRepository::ServerInformationIterator_ptr (*_TAO_collocation_ImplementationRepository_ServerInformationIterator_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ); @@ -1620,7 +1681,7 @@ TAO_Export CORBA::Boolean operator>> ( #endif /* _TAO_CDR_OP_ImplementationRepository_EnvironmentList_H_ */ -TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const ImplementationRepository::ActivationMode &); // +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const ImplementationRepository::ActivationMode &); // TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::ActivationMode &); TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const ImplementationRepository::StartupOptions &); TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::StartupOptions &); diff --git a/TAO/tao/ImplRepoC.i b/TAO/tao/ImplRepoC.i index 00d48a0cee4..3a4bac9eea9 100644 --- a/TAO/tao/ImplRepoC.i +++ b/TAO/tao/ImplRepoC.i @@ -38,7 +38,7 @@ ImplementationRepository::ServerObject_var::ServerObject_var (ImplementationRepo : ptr_ (p) {} -ACE_INLINE ImplementationRepository::ServerObject_ptr +ACE_INLINE ImplementationRepository::ServerObject_ptr ImplementationRepository::ServerObject_var::ptr (void) const { return this->ptr_; @@ -74,19 +74,19 @@ ImplementationRepository::ServerObject_var::operator= (const ImplementationRepos return *this; } -ACE_INLINE +ACE_INLINE ImplementationRepository::ServerObject_var::operator const ImplementationRepository::ServerObject_ptr &() const // cast { return this->ptr_; } -ACE_INLINE -ImplementationRepository::ServerObject_var::operator ImplementationRepository::ServerObject_ptr &() // cast +ACE_INLINE +ImplementationRepository::ServerObject_var::operator ImplementationRepository::ServerObject_ptr &() // cast { return this->ptr_; } -ACE_INLINE ImplementationRepository::ServerObject_ptr +ACE_INLINE ImplementationRepository::ServerObject_ptr ImplementationRepository::ServerObject_var::operator-> (void) const { return this->ptr_; @@ -112,7 +112,7 @@ ImplementationRepository::ServerObject_var::out (void) return this->ptr_; } -ACE_INLINE ImplementationRepository::ServerObject_ptr +ACE_INLINE ImplementationRepository::ServerObject_ptr ImplementationRepository::ServerObject_var::_retn (void) { // yield ownership of managed obj reference @@ -173,7 +173,7 @@ ImplementationRepository::ServerObject_out::operator= (ImplementationRepository: return *this; } -ACE_INLINE +ACE_INLINE ImplementationRepository::ServerObject_out::operator ImplementationRepository::ServerObject_ptr &() // cast { return this->ptr_; @@ -185,7 +185,7 @@ ImplementationRepository::ServerObject_out::ptr (void) // ptr return this->ptr_; } -ACE_INLINE ImplementationRepository::ServerObject_ptr +ACE_INLINE ImplementationRepository::ServerObject_ptr ImplementationRepository::ServerObject_out::operator-> (void) { return this->ptr_; @@ -254,20 +254,20 @@ ImplementationRepository::EnvironmentVariable_var::operator-> (void) return this->ptr_; } -ACE_INLINE +ACE_INLINE ImplementationRepository::EnvironmentVariable_var::operator const ImplementationRepository::EnvironmentVariable &() const // cast { return *this->ptr_; } -ACE_INLINE -ImplementationRepository::EnvironmentVariable_var::operator ImplementationRepository::EnvironmentVariable &() // cast +ACE_INLINE +ImplementationRepository::EnvironmentVariable_var::operator ImplementationRepository::EnvironmentVariable &() // cast { return *this->ptr_; } -ACE_INLINE -ImplementationRepository::EnvironmentVariable_var::operator ImplementationRepository::EnvironmentVariable &() const// cast +ACE_INLINE +ImplementationRepository::EnvironmentVariable_var::operator ImplementationRepository::EnvironmentVariable &() const// cast { return *this->ptr_; } @@ -284,7 +284,7 @@ ImplementationRepository::EnvironmentVariable_var::inout (void) return *this->ptr_; } -// mapping for variable size +// mapping for variable size ACE_INLINE ImplementationRepository::EnvironmentVariable *& ImplementationRepository::EnvironmentVariable_var::out (void) { @@ -345,7 +345,7 @@ ImplementationRepository::EnvironmentVariable_out::operator= (ImplementationRepo return *this; } -ACE_INLINE +ACE_INLINE ImplementationRepository::EnvironmentVariable_out::operator ImplementationRepository::EnvironmentVariable *&() // cast { return this->ptr_; @@ -365,7 +365,7 @@ ImplementationRepository::EnvironmentVariable_out::operator-> (void) #if !defined (TAO_USE_SEQUENCE_TEMPLATES) - + #if !defined (__TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CI_) #define __TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CI_ @@ -378,24 +378,24 @@ ImplementationRepository::EnvironmentVariable_out::operator-> (void) ACE_NEW_RETURN (retval, ImplementationRepository::EnvironmentVariable[size], 0); return retval; } - + ACE_INLINE void ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::freebuf (ImplementationRepository::EnvironmentVariable *buffer) // Free the sequence. { delete [] buffer; } - + ACE_INLINE ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList (void) // Default constructor. { } - + ACE_INLINE ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList (CORBA::ULong maximum) // Constructor using a maximum length value. : TAO_Unbounded_Base_Sequence (maximum, ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::allocbuf (maximum)) { } - + ACE_INLINE ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList (CORBA::ULong maximum, CORBA::ULong length, @@ -404,7 +404,7 @@ ImplementationRepository::EnvironmentVariable_out::operator-> (void) : TAO_Unbounded_Base_Sequence (maximum, length, data, release) { } - + ACE_INLINE ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList (const ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList &rhs) // Copy constructor. @@ -414,10 +414,10 @@ ImplementationRepository::EnvironmentVariable_out::operator-> (void) { ImplementationRepository::EnvironmentVariable *tmp1 = ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::allocbuf (this->maximum_); ImplementationRepository::EnvironmentVariable * const tmp2 = ACE_reinterpret_cast (ImplementationRepository::EnvironmentVariable * ACE_CAST_CONST, rhs.buffer_); - + for (CORBA::ULong i = 0; i < this->length_; ++i) tmp1[i] = tmp2[i]; - + this->buffer_ = tmp1; } else @@ -425,14 +425,14 @@ ImplementationRepository::EnvironmentVariable_out::operator-> (void) this->buffer_ = 0; } } - + ACE_INLINE ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList & ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::operator= (const ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList &rhs) // Assignment operator. { if (this == &rhs) return *this; - + if (this->release_) { if (this->maximum_ < rhs.maximum_) @@ -445,18 +445,18 @@ ImplementationRepository::EnvironmentVariable_out::operator-> (void) } else this->buffer_ = ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::allocbuf (rhs.maximum_); - + TAO_Unbounded_Base_Sequence::operator= (rhs); - + ImplementationRepository::EnvironmentVariable *tmp1 = ACE_reinterpret_cast (ImplementationRepository::EnvironmentVariable *, this->buffer_); ImplementationRepository::EnvironmentVariable * const tmp2 = ACE_reinterpret_cast (ImplementationRepository::EnvironmentVariable * ACE_CAST_CONST, rhs.buffer_); - + for (CORBA::ULong i = 0; i < this->length_; ++i) tmp1[i] = tmp2[i]; - + return *this; } - + // = Accessors. ACE_INLINE ImplementationRepository::EnvironmentVariable & ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::operator[] (CORBA::ULong i) @@ -466,7 +466,7 @@ ImplementationRepository::EnvironmentVariable_out::operator-> (void) ImplementationRepository::EnvironmentVariable* tmp = ACE_reinterpret_cast(ImplementationRepository::EnvironmentVariable*,this->buffer_); return tmp[i]; } - + ACE_INLINE const ImplementationRepository::EnvironmentVariable & ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::operator[] (CORBA::ULong i) const // operator [] @@ -475,9 +475,9 @@ ImplementationRepository::EnvironmentVariable_out::operator-> (void) ImplementationRepository::EnvironmentVariable * const tmp = ACE_reinterpret_cast (ImplementationRepository::EnvironmentVariable* ACE_CAST_CONST, this->buffer_); return tmp[i]; } - + // Implement the TAO_Base_Sequence methods (see Sequence.h) - + ACE_INLINE ImplementationRepository::EnvironmentVariable * ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::get_buffer (CORBA::Boolean orphan) { @@ -510,13 +510,13 @@ ImplementationRepository::EnvironmentVariable_out::operator-> (void) } return result; } - + ACE_INLINE const ImplementationRepository::EnvironmentVariable * ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::get_buffer (void) const { return ACE_reinterpret_cast(const ImplementationRepository::EnvironmentVariable * ACE_CAST_CONST, this->buffer_); } - + ACE_INLINE void ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::replace (CORBA::ULong max, CORBA::ULong length, @@ -533,11 +533,11 @@ ImplementationRepository::EnvironmentVariable_out::operator-> (void) this->buffer_ = data; this->release_ = release; } - + #endif /* end #if !defined */ -#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ #if !defined (_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CI_) #define _IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CI_ @@ -602,20 +602,20 @@ ImplementationRepository::EnvironmentList_var::operator-> (void) return this->ptr_; } -ACE_INLINE +ACE_INLINE ImplementationRepository::EnvironmentList_var::operator const ImplementationRepository::EnvironmentList &() const // cast { return *this->ptr_; } -ACE_INLINE -ImplementationRepository::EnvironmentList_var::operator ImplementationRepository::EnvironmentList &() // cast +ACE_INLINE +ImplementationRepository::EnvironmentList_var::operator ImplementationRepository::EnvironmentList &() // cast { return *this->ptr_; } -ACE_INLINE -ImplementationRepository::EnvironmentList_var::operator ImplementationRepository::EnvironmentList &() const// cast +ACE_INLINE +ImplementationRepository::EnvironmentList_var::operator ImplementationRepository::EnvironmentList &() const// cast { return *this->ptr_; } @@ -638,7 +638,7 @@ ImplementationRepository::EnvironmentList_var::inout (void) return *this->ptr_; } -// mapping for variable size +// mapping for variable size ACE_INLINE ImplementationRepository::EnvironmentList *& ImplementationRepository::EnvironmentList_var::out (void) { @@ -699,7 +699,7 @@ ImplementationRepository::EnvironmentList_out::operator= (ImplementationReposito return *this; } -ACE_INLINE +ACE_INLINE ImplementationRepository::EnvironmentList_out::operator ImplementationRepository::EnvironmentList *&() // cast { return this->ptr_; @@ -786,20 +786,20 @@ ImplementationRepository::StartupOptions_var::operator-> (void) return this->ptr_; } -ACE_INLINE +ACE_INLINE ImplementationRepository::StartupOptions_var::operator const ImplementationRepository::StartupOptions &() const // cast { return *this->ptr_; } -ACE_INLINE -ImplementationRepository::StartupOptions_var::operator ImplementationRepository::StartupOptions &() // cast +ACE_INLINE +ImplementationRepository::StartupOptions_var::operator ImplementationRepository::StartupOptions &() // cast { return *this->ptr_; } -ACE_INLINE -ImplementationRepository::StartupOptions_var::operator ImplementationRepository::StartupOptions &() const// cast +ACE_INLINE +ImplementationRepository::StartupOptions_var::operator ImplementationRepository::StartupOptions &() const// cast { return *this->ptr_; } @@ -816,7 +816,7 @@ ImplementationRepository::StartupOptions_var::inout (void) return *this->ptr_; } -// mapping for variable size +// mapping for variable size ACE_INLINE ImplementationRepository::StartupOptions *& ImplementationRepository::StartupOptions_var::out (void) { @@ -877,7 +877,7 @@ ImplementationRepository::StartupOptions_out::operator= (ImplementationRepositor return *this; } -ACE_INLINE +ACE_INLINE ImplementationRepository::StartupOptions_out::operator ImplementationRepository::StartupOptions *&() // cast { return this->ptr_; @@ -955,20 +955,20 @@ ImplementationRepository::ServerInformation_var::operator-> (void) return this->ptr_; } -ACE_INLINE +ACE_INLINE ImplementationRepository::ServerInformation_var::operator const ImplementationRepository::ServerInformation &() const // cast { return *this->ptr_; } -ACE_INLINE -ImplementationRepository::ServerInformation_var::operator ImplementationRepository::ServerInformation &() // cast +ACE_INLINE +ImplementationRepository::ServerInformation_var::operator ImplementationRepository::ServerInformation &() // cast { return *this->ptr_; } -ACE_INLINE -ImplementationRepository::ServerInformation_var::operator ImplementationRepository::ServerInformation &() const// cast +ACE_INLINE +ImplementationRepository::ServerInformation_var::operator ImplementationRepository::ServerInformation &() const// cast { return *this->ptr_; } @@ -985,7 +985,7 @@ ImplementationRepository::ServerInformation_var::inout (void) return *this->ptr_; } -// mapping for variable size +// mapping for variable size ACE_INLINE ImplementationRepository::ServerInformation *& ImplementationRepository::ServerInformation_var::out (void) { @@ -1046,7 +1046,7 @@ ImplementationRepository::ServerInformation_out::operator= (ImplementationReposi return *this; } -ACE_INLINE +ACE_INLINE ImplementationRepository::ServerInformation_out::operator ImplementationRepository::ServerInformation *&() // cast { return this->ptr_; @@ -1066,7 +1066,7 @@ ImplementationRepository::ServerInformation_out::operator-> (void) #if !defined (TAO_USE_SEQUENCE_TEMPLATES) - + #if !defined (__TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CI_) #define __TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CI_ @@ -1079,24 +1079,24 @@ ImplementationRepository::ServerInformation_out::operator-> (void) ACE_NEW_RETURN (retval, ImplementationRepository::ServerInformation[size], 0); return retval; } - + ACE_INLINE void ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::freebuf (ImplementationRepository::ServerInformation *buffer) // Free the sequence. { delete [] buffer; } - + ACE_INLINE ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList (void) // Default constructor. { } - + ACE_INLINE ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList (CORBA::ULong maximum) // Constructor using a maximum length value. : TAO_Unbounded_Base_Sequence (maximum, ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::allocbuf (maximum)) { } - + ACE_INLINE ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList (CORBA::ULong maximum, CORBA::ULong length, @@ -1105,7 +1105,7 @@ ImplementationRepository::ServerInformation_out::operator-> (void) : TAO_Unbounded_Base_Sequence (maximum, length, data, release) { } - + ACE_INLINE ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList (const ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList &rhs) // Copy constructor. @@ -1115,10 +1115,10 @@ ImplementationRepository::ServerInformation_out::operator-> (void) { ImplementationRepository::ServerInformation *tmp1 = ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::allocbuf (this->maximum_); ImplementationRepository::ServerInformation * const tmp2 = ACE_reinterpret_cast (ImplementationRepository::ServerInformation * ACE_CAST_CONST, rhs.buffer_); - + for (CORBA::ULong i = 0; i < this->length_; ++i) tmp1[i] = tmp2[i]; - + this->buffer_ = tmp1; } else @@ -1126,14 +1126,14 @@ ImplementationRepository::ServerInformation_out::operator-> (void) this->buffer_ = 0; } } - + ACE_INLINE ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList & ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::operator= (const ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList &rhs) // Assignment operator. { if (this == &rhs) return *this; - + if (this->release_) { if (this->maximum_ < rhs.maximum_) @@ -1146,18 +1146,18 @@ ImplementationRepository::ServerInformation_out::operator-> (void) } else this->buffer_ = ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::allocbuf (rhs.maximum_); - + TAO_Unbounded_Base_Sequence::operator= (rhs); - + ImplementationRepository::ServerInformation *tmp1 = ACE_reinterpret_cast (ImplementationRepository::ServerInformation *, this->buffer_); ImplementationRepository::ServerInformation * const tmp2 = ACE_reinterpret_cast (ImplementationRepository::ServerInformation * ACE_CAST_CONST, rhs.buffer_); - + for (CORBA::ULong i = 0; i < this->length_; ++i) tmp1[i] = tmp2[i]; - + return *this; } - + // = Accessors. ACE_INLINE ImplementationRepository::ServerInformation & ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::operator[] (CORBA::ULong i) @@ -1167,7 +1167,7 @@ ImplementationRepository::ServerInformation_out::operator-> (void) ImplementationRepository::ServerInformation* tmp = ACE_reinterpret_cast(ImplementationRepository::ServerInformation*,this->buffer_); return tmp[i]; } - + ACE_INLINE const ImplementationRepository::ServerInformation & ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::operator[] (CORBA::ULong i) const // operator [] @@ -1176,9 +1176,9 @@ ImplementationRepository::ServerInformation_out::operator-> (void) ImplementationRepository::ServerInformation * const tmp = ACE_reinterpret_cast (ImplementationRepository::ServerInformation* ACE_CAST_CONST, this->buffer_); return tmp[i]; } - + // Implement the TAO_Base_Sequence methods (see Sequence.h) - + ACE_INLINE ImplementationRepository::ServerInformation * ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::get_buffer (CORBA::Boolean orphan) { @@ -1211,13 +1211,13 @@ ImplementationRepository::ServerInformation_out::operator-> (void) } return result; } - + ACE_INLINE const ImplementationRepository::ServerInformation * ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::get_buffer (void) const { return ACE_reinterpret_cast(const ImplementationRepository::ServerInformation * ACE_CAST_CONST, this->buffer_); } - + ACE_INLINE void ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::replace (CORBA::ULong max, CORBA::ULong length, @@ -1234,11 +1234,11 @@ ImplementationRepository::ServerInformation_out::operator-> (void) this->buffer_ = data; this->release_ = release; } - + #endif /* end #if !defined */ -#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ #if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CI_) #define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CI_ @@ -1303,20 +1303,20 @@ ImplementationRepository::ServerInformationList_var::operator-> (void) return this->ptr_; } -ACE_INLINE +ACE_INLINE ImplementationRepository::ServerInformationList_var::operator const ImplementationRepository::ServerInformationList &() const // cast { return *this->ptr_; } -ACE_INLINE -ImplementationRepository::ServerInformationList_var::operator ImplementationRepository::ServerInformationList &() // cast +ACE_INLINE +ImplementationRepository::ServerInformationList_var::operator ImplementationRepository::ServerInformationList &() // cast { return *this->ptr_; } -ACE_INLINE -ImplementationRepository::ServerInformationList_var::operator ImplementationRepository::ServerInformationList &() const// cast +ACE_INLINE +ImplementationRepository::ServerInformationList_var::operator ImplementationRepository::ServerInformationList &() const// cast { return *this->ptr_; } @@ -1339,7 +1339,7 @@ ImplementationRepository::ServerInformationList_var::inout (void) return *this->ptr_; } -// mapping for variable size +// mapping for variable size ACE_INLINE ImplementationRepository::ServerInformationList *& ImplementationRepository::ServerInformationList_var::out (void) { @@ -1400,7 +1400,7 @@ ImplementationRepository::ServerInformationList_out::operator= (ImplementationRe return *this; } -ACE_INLINE +ACE_INLINE ImplementationRepository::ServerInformationList_out::operator ImplementationRepository::ServerInformationList *&() // cast { return this->ptr_; @@ -1458,7 +1458,7 @@ ImplementationRepository::Administration_var::Administration_var (Implementation : ptr_ (p) {} -ACE_INLINE ImplementationRepository::Administration_ptr +ACE_INLINE ImplementationRepository::Administration_ptr ImplementationRepository::Administration_var::ptr (void) const { return this->ptr_; @@ -1494,19 +1494,19 @@ ImplementationRepository::Administration_var::operator= (const ImplementationRep return *this; } -ACE_INLINE +ACE_INLINE ImplementationRepository::Administration_var::operator const ImplementationRepository::Administration_ptr &() const // cast { return this->ptr_; } -ACE_INLINE -ImplementationRepository::Administration_var::operator ImplementationRepository::Administration_ptr &() // cast +ACE_INLINE +ImplementationRepository::Administration_var::operator ImplementationRepository::Administration_ptr &() // cast { return this->ptr_; } -ACE_INLINE ImplementationRepository::Administration_ptr +ACE_INLINE ImplementationRepository::Administration_ptr ImplementationRepository::Administration_var::operator-> (void) const { return this->ptr_; @@ -1532,7 +1532,7 @@ ImplementationRepository::Administration_var::out (void) return this->ptr_; } -ACE_INLINE ImplementationRepository::Administration_ptr +ACE_INLINE ImplementationRepository::Administration_ptr ImplementationRepository::Administration_var::_retn (void) { // yield ownership of managed obj reference @@ -1593,7 +1593,7 @@ ImplementationRepository::Administration_out::operator= (ImplementationRepositor return *this; } -ACE_INLINE +ACE_INLINE ImplementationRepository::Administration_out::operator ImplementationRepository::Administration_ptr &() // cast { return this->ptr_; @@ -1605,7 +1605,7 @@ ImplementationRepository::Administration_out::ptr (void) // ptr return this->ptr_; } -ACE_INLINE ImplementationRepository::Administration_ptr +ACE_INLINE ImplementationRepository::Administration_ptr ImplementationRepository::Administration_out::operator-> (void) { return this->ptr_; @@ -1657,7 +1657,7 @@ ImplementationRepository::ServerInformationIterator_var::ServerInformationIterat : ptr_ (p) {} -ACE_INLINE ImplementationRepository::ServerInformationIterator_ptr +ACE_INLINE ImplementationRepository::ServerInformationIterator_ptr ImplementationRepository::ServerInformationIterator_var::ptr (void) const { return this->ptr_; @@ -1693,19 +1693,19 @@ ImplementationRepository::ServerInformationIterator_var::operator= (const Implem return *this; } -ACE_INLINE +ACE_INLINE ImplementationRepository::ServerInformationIterator_var::operator const ImplementationRepository::ServerInformationIterator_ptr &() const // cast { return this->ptr_; } -ACE_INLINE -ImplementationRepository::ServerInformationIterator_var::operator ImplementationRepository::ServerInformationIterator_ptr &() // cast +ACE_INLINE +ImplementationRepository::ServerInformationIterator_var::operator ImplementationRepository::ServerInformationIterator_ptr &() // cast { return this->ptr_; } -ACE_INLINE ImplementationRepository::ServerInformationIterator_ptr +ACE_INLINE ImplementationRepository::ServerInformationIterator_ptr ImplementationRepository::ServerInformationIterator_var::operator-> (void) const { return this->ptr_; @@ -1731,7 +1731,7 @@ ImplementationRepository::ServerInformationIterator_var::out (void) return this->ptr_; } -ACE_INLINE ImplementationRepository::ServerInformationIterator_ptr +ACE_INLINE ImplementationRepository::ServerInformationIterator_ptr ImplementationRepository::ServerInformationIterator_var::_retn (void) { // yield ownership of managed obj reference @@ -1792,7 +1792,7 @@ ImplementationRepository::ServerInformationIterator_out::operator= (Implementati return *this; } -ACE_INLINE +ACE_INLINE ImplementationRepository::ServerInformationIterator_out::operator ImplementationRepository::ServerInformationIterator_ptr &() // cast { return this->ptr_; @@ -1804,7 +1804,7 @@ ImplementationRepository::ServerInformationIterator_out::ptr (void) // ptr return this->ptr_; } -ACE_INLINE ImplementationRepository::ServerInformationIterator_ptr +ACE_INLINE ImplementationRepository::ServerInformationIterator_ptr ImplementationRepository::ServerInformationIterator_out::operator-> (void) { return this->ptr_; @@ -1871,7 +1871,7 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const ImplementationR return 1; else return 0; - + } ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, ImplementationRepository::EnvironmentVariable &_tao_aggregate) @@ -1883,7 +1883,7 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, ImplementationReposito return 1; else return 0; - + } @@ -1929,7 +1929,7 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const ImplementationR return 1; else return 0; - + } ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, ImplementationRepository::StartupOptions &_tao_aggregate) @@ -1943,7 +1943,7 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, ImplementationReposito return 1; else return 0; - + } ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const ImplementationRepository::ServerInformation &_tao_aggregate) @@ -1957,7 +1957,7 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const ImplementationR return 1; else return 0; - + } ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, ImplementationRepository::ServerInformation &_tao_aggregate) @@ -1971,7 +1971,7 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, ImplementationReposito return 1; else return 0; - + } @@ -2019,17 +2019,9 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const ImplementationR return 0; } -ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, ImplementationRepository::Administration::AlreadyRegistered &_tao_aggregate) +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::Administration::AlreadyRegistered &) { - // retrieve RepoID and verify if we are of that type - char *_tao_repoID; - if ((strm >> _tao_repoID) && - (_tao_aggregate._is_a (_tao_repoID))) - { - return 1; - } - else - return 0; + return 1; } #if !defined (ACE_LACKS_IOSTREAM_TOTALLY) @@ -2071,21 +2063,12 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const ImplementationR ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, ImplementationRepository::Administration::CannotActivate &_tao_aggregate) { - // retrieve RepoID and verify if we are of that type - char *_tao_repoID; - if ((strm >> _tao_repoID) && - (_tao_aggregate._is_a (_tao_repoID))) - { - // now marshal the members - if ( + // now marshal the members + if ( (strm >> _tao_aggregate.reason.out ()) - ) - return 1; - else - return 0; - } - else - return 0; + ) + return 1; + return 0; } #if !defined (ACE_LACKS_IOSTREAM_TOTALLY) @@ -2117,17 +2100,9 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const ImplementationR return 0; } -ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, ImplementationRepository::Administration::NotFound &_tao_aggregate) +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::Administration::NotFound &) { - // retrieve RepoID and verify if we are of that type - char *_tao_repoID; - if ((strm >> _tao_repoID) && - (_tao_aggregate._is_a (_tao_repoID))) - { - return 1; - } - else - return 0; + return 1; } #if !defined (ACE_LACKS_IOSTREAM_TOTALLY) @@ -2236,4 +2211,3 @@ operator>> ( ACE_ENDTRY; return 0; } - diff --git a/TAO/tao/InconsistentTypeCodeC.cpp b/TAO/tao/InconsistentTypeCodeC.cpp index 3480fea7a0b..c751a1fffb2 100644 --- a/TAO/tao/InconsistentTypeCodeC.cpp +++ b/TAO/tao/InconsistentTypeCodeC.cpp @@ -77,6 +77,19 @@ void CORBA_ORB_InconsistentTypeCode::_raise () TAO_RAISE(*this); } +void CORBA_ORB_InconsistentTypeCode::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << this->_id ()) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void CORBA_ORB_InconsistentTypeCode::_tao_decode (TAO_InputCDR &, + CORBA::Environment &) +{ +} + // TAO extension - the _alloc method CORBA::Exception *CORBA_ORB_InconsistentTypeCode::_alloc (void) { diff --git a/TAO/tao/InconsistentTypeCodeC.h b/TAO/tao/InconsistentTypeCodeC.h index 707631a3120..430d951ed42 100644 --- a/TAO/tao/InconsistentTypeCodeC.h +++ b/TAO/tao/InconsistentTypeCodeC.h @@ -70,6 +70,11 @@ public: virtual void _raise (void); + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static CORBA_ORB_InconsistentTypeCode *_narrow (CORBA::Exception *); // = TAO extension diff --git a/TAO/tao/InterceptorC.cpp b/TAO/tao/InterceptorC.cpp index 57cecf63f05..2bae98a7294 100644 --- a/TAO/tao/InterceptorC.cpp +++ b/TAO/tao/InterceptorC.cpp @@ -444,8 +444,23 @@ void operator<<= (CORBA::Any &_tao_any, PortableInterceptor::Cookie_ptr _tao_ele { ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); *_tao_obj_ptr = PortableInterceptor::Cookie::_duplicate (_tao_elem); - _tao_any.replace (PortableInterceptor::_tc_Cookie, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + PortableInterceptor::_tc_Cookie, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -457,34 +472,49 @@ void operator<<= (CORBA::Any &_tao_any, PortableInterceptor::Cookie_ptr _tao_ele CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableInterceptor::Cookie_ptr &_tao_elem) { CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = PortableInterceptor::Cookie::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (PortableInterceptor::_tc_Cookie, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (PortableInterceptor::_tc_Cookie, 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 (PortableInterceptor::_tc_Cookie, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + if (stream >> _tao_obj_var.out ()) { _tao_elem = PortableInterceptor::Cookie::_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 (PortableInterceptor::_tc_Cookie, tmp, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + PortableInterceptor::_tc_Cookie, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = PortableInterceptor::Cookie::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = PortableInterceptor::Cookie::_nil (); return 0; } @@ -506,8 +536,23 @@ void operator<<= ( if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (PortableInterceptor::_tc_Cookies, _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 ( + PortableInterceptor::_tc_Cookies, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_any_val; + } } ACE_CATCHANY { @@ -520,10 +565,23 @@ void operator<<= (CORBA::Any &_tao_any, PortableInterceptor::Cookies *_tao_elem) { ACE_TRY_NEW_ENV { - _tao_any.replace (PortableInterceptor::_tc_Cookies, _tao_elem, 0, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + PortableInterceptor::_tc_Cookies, + 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; } @@ -532,7 +590,11 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableInterceptor::Coo ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (PortableInterceptor::_tc_Cookies, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (PortableInterceptor::_tc_Cookies, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { @@ -542,25 +604,84 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableInterceptor::Coo else { ACE_NEW_RETURN (_tao_elem, PortableInterceptor::Cookies, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (PortableInterceptor::_tc_Cookies, _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 (PortableInterceptor::_tc_Cookies, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + PortableInterceptor::_tc_Cookies, + 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 PortableInterceptor::Cookies *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (PortableInterceptor::_tc_Cookies, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (PortableInterceptor::Cookies *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, PortableInterceptor::Cookies, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(PortableInterceptor::Cookies *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + PortableInterceptor::_tc_Cookies, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (PortableInterceptor::Cookies *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (PortableInterceptor::Cookies *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (PortableInterceptor::Cookies *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; @@ -573,8 +694,23 @@ void operator<<= (CORBA::Any &_tao_any, PortableInterceptor::Interceptor_ptr _ta { ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); *_tao_obj_ptr = PortableInterceptor::Interceptor::_duplicate (_tao_elem); - _tao_any.replace (PortableInterceptor::_tc_Interceptor, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + PortableInterceptor::_tc_Interceptor, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -586,34 +722,49 @@ void operator<<= (CORBA::Any &_tao_any, PortableInterceptor::Interceptor_ptr _ta CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableInterceptor::Interceptor_ptr &_tao_elem) { CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = PortableInterceptor::Interceptor::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (PortableInterceptor::_tc_Interceptor, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (PortableInterceptor::_tc_Interceptor, 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 (PortableInterceptor::_tc_Interceptor, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + if (stream >> _tao_obj_var.out ()) { _tao_elem = PortableInterceptor::Interceptor::_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 (PortableInterceptor::_tc_Interceptor, tmp, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + PortableInterceptor::_tc_Interceptor, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = PortableInterceptor::Interceptor::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = PortableInterceptor::Interceptor::_nil (); return 0; } @@ -632,8 +783,23 @@ void operator<<= (CORBA::Any &_tao_any, PortableInterceptor::ServerRequestInterc { ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); *_tao_obj_ptr = PortableInterceptor::ServerRequestInterceptor::_duplicate (_tao_elem); - _tao_any.replace (PortableInterceptor::_tc_ServerRequestInterceptor, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + PortableInterceptor::_tc_ServerRequestInterceptor, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -645,34 +811,49 @@ void operator<<= (CORBA::Any &_tao_any, PortableInterceptor::ServerRequestInterc CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableInterceptor::ServerRequestInterceptor_ptr &_tao_elem) { CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = PortableInterceptor::ServerRequestInterceptor::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (PortableInterceptor::_tc_ServerRequestInterceptor, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (PortableInterceptor::_tc_ServerRequestInterceptor, 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 (PortableInterceptor::_tc_ServerRequestInterceptor, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + if (stream >> _tao_obj_var.out ()) { _tao_elem = PortableInterceptor::ServerRequestInterceptor::_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 (PortableInterceptor::_tc_ServerRequestInterceptor, tmp, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + PortableInterceptor::_tc_ServerRequestInterceptor, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = PortableInterceptor::ServerRequestInterceptor::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = PortableInterceptor::ServerRequestInterceptor::_nil (); return 0; } @@ -691,8 +872,23 @@ void operator<<= (CORBA::Any &_tao_any, PortableInterceptor::ClientRequestInterc { ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); *_tao_obj_ptr = PortableInterceptor::ClientRequestInterceptor::_duplicate (_tao_elem); - _tao_any.replace (PortableInterceptor::_tc_ClientRequestInterceptor, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + PortableInterceptor::_tc_ClientRequestInterceptor, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -704,34 +900,49 @@ void operator<<= (CORBA::Any &_tao_any, PortableInterceptor::ClientRequestInterc CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableInterceptor::ClientRequestInterceptor_ptr &_tao_elem) { CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = PortableInterceptor::ClientRequestInterceptor::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (PortableInterceptor::_tc_ClientRequestInterceptor, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (PortableInterceptor::_tc_ClientRequestInterceptor, 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 (PortableInterceptor::_tc_ClientRequestInterceptor, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + if (stream >> _tao_obj_var.out ()) { _tao_elem = PortableInterceptor::ClientRequestInterceptor::_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 (PortableInterceptor::_tc_ClientRequestInterceptor, tmp, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + PortableInterceptor::_tc_ClientRequestInterceptor, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = PortableInterceptor::ClientRequestInterceptor::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = PortableInterceptor::ClientRequestInterceptor::_nil (); return 0; } @@ -743,4 +954,46 @@ template class TAO_Object_Manager<PortableInterceptor::ClientRequestInterceptor, # pragma instantiate TAO_Object_Manager<PortableInterceptor::ClientRequestInterceptor,PortableInterceptor::ClientRequestInterceptor_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ +CORBA::Boolean operator<< ( + TAO_OutputCDR &strm, + const PortableInterceptor::Cookies &_tao_sequence + ) +{ + if (strm << _tao_sequence.length ()) + { + // encode all elements + CORBA::Boolean _tao_marshal_flag = 1; + for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++) + { + _tao_marshal_flag = (strm << _tao_sequence[i].in ()); + } + return _tao_marshal_flag; + } + return 0; // error +} + +CORBA::Boolean operator>> ( + TAO_InputCDR &strm, + PortableInterceptor::Cookies &_tao_sequence + ) +{ + CORBA::ULong _tao_seq_len; + if (strm >> _tao_seq_len) + { + // set the length of the sequence + _tao_sequence.length (_tao_seq_len); + // If length is 0 we return true. + if (0 >= _tao_seq_len) + return 1; + // retrieve all the elements + CORBA::Boolean _tao_marshal_flag = 1; + for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++) + { + _tao_marshal_flag = (strm >> _tao_sequence[i].out ()); + } + return _tao_marshal_flag; + } + return 0; // error +} + #endif /* TAO_HAS_INTERCEPTORS */ diff --git a/TAO/tao/InterceptorC.h b/TAO/tao/InterceptorC.h index 3e0209af772..6a3fde69dbe 100644 --- a/TAO/tao/InterceptorC.h +++ b/TAO/tao/InterceptorC.h @@ -1,7 +1,6 @@ /* -*- C++ -*- $Id$ */ - // ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* // TAO and the TAO IDL Compiler have been developed by the Center for // Distributed Object Computing at Washington University, St. Louis. @@ -716,28 +715,63 @@ class TAO_Export ClientRequestInterceptor: public virtual Interceptor TAO_NAMESPACE_CLOSE // module PortableInterceptor // Any operators for interface PortableInterceptor::Cookie -TAO_Export void operator<<= (CORBA::Any &, PortableInterceptor::Cookie_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableInterceptor::Cookie *&); -TAO_Export void operator<<= (CORBA::Any &, const PortableInterceptor::Cookies &); // copying version -TAO_Export void operator<<= (CORBA::Any &, PortableInterceptor::Cookies*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableInterceptor::Cookies *&); +TAO_Export void operator<<= (CORBA::Any &, + PortableInterceptor::Cookie_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + PortableInterceptor::Cookie *&); +TAO_Export void operator<<= (CORBA::Any &, + const PortableInterceptor::Cookies &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + PortableInterceptor::Cookies*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + PortableInterceptor::Cookies *&); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const PortableInterceptor::Cookies *&); // Any operators for interface PortableInterceptor::Interceptor -TAO_Export void operator<<= (CORBA::Any &, PortableInterceptor::Interceptor_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableInterceptor::Interceptor *&); +TAO_Export void operator<<= (CORBA::Any &, + PortableInterceptor::Interceptor_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + PortableInterceptor::Interceptor *&); // Any operators for interface PortableInterceptor::ServerRequestInterceptor -TAO_Export void operator<<= (CORBA::Any &, PortableInterceptor::ServerRequestInterceptor_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableInterceptor::ServerRequestInterceptor *&); +TAO_Export void operator<<= (CORBA::Any &, + PortableInterceptor::ServerRequestInterceptor_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + PortableInterceptor::ServerRequestInterceptor *&); // Any operators for interface PortableInterceptor::ClientRequestInterceptor -TAO_Export void operator<<= (CORBA::Any &, PortableInterceptor::ClientRequestInterceptor_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableInterceptor::ClientRequestInterceptor *&); - -#endif /* TAO_HAS_INTERCEPTORS */ +TAO_Export void operator<<= (CORBA::Any &, + PortableInterceptor::ClientRequestInterceptor_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + PortableInterceptor::ClientRequestInterceptor *&); #ifndef __ACE_INLINE__ + CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableInterceptor::Cookie_ptr ); + CORBA::Boolean operator>> (TAO_InputCDR &, PortableInterceptor::Cookie_ptr &); + +#if !defined _TAO_CDR_OP_PortableInterceptor_Cookies_H_ +#define _TAO_CDR_OP_PortableInterceptor_Cookies_H_ + + CORBA::Boolean operator<< ( + TAO_OutputCDR &, + const PortableInterceptor::Cookies & + ); + CORBA::Boolean operator>> ( + TAO_InputCDR &, + PortableInterceptor::Cookies & + ); + +#endif /* _TAO_CDR_OP_PortableInterceptor_Cookies_H_ */ + + CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableInterceptor::Interceptor_ptr ); + CORBA::Boolean operator>> (TAO_InputCDR &, PortableInterceptor::Interceptor_ptr &); + CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableInterceptor::ServerRequestInterceptor_ptr ); + CORBA::Boolean operator>> (TAO_InputCDR &, PortableInterceptor::ServerRequestInterceptor_ptr &); + CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableInterceptor::ClientRequestInterceptor_ptr ); + CORBA::Boolean operator>> (TAO_InputCDR &, PortableInterceptor::ClientRequestInterceptor_ptr &); #endif /* __ACE_INLINE__ */ +#endif /* TAO_HAS_INTERCEPTORS */ #if defined (__ACE_INLINE__) #include "tao/InterceptorC.i" diff --git a/TAO/tao/InterceptorC.i b/TAO/tao/InterceptorC.i index 4e1c7934391..96fbd45bf5d 100644 --- a/TAO/tao/InterceptorC.i +++ b/TAO/tao/InterceptorC.i @@ -1095,4 +1095,215 @@ PortableInterceptor::ClientRequestInterceptor_out::operator-> (void) #endif /* end #if !defined */ +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &, + const PortableInterceptor::Cookie_ptr + ); +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &, + PortableInterceptor::Cookie_ptr & + ); + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const PortableInterceptor::Cookie_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + PortableInterceptor::Cookie_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 = + PortableInterceptor::Cookie::_narrow ( + obj.in (), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + ACE_CATCHANY + { + // do nothing + } + ACE_ENDTRY; + return 0; +} + + +#if !defined _TAO_CDR_OP_PortableInterceptor_Cookies_I_ +#define _TAO_CDR_OP_PortableInterceptor_Cookies_I_ + +CORBA::Boolean operator<< ( + TAO_OutputCDR &, + const PortableInterceptor::Cookies & + ); +CORBA::Boolean operator>> ( + TAO_InputCDR &, + PortableInterceptor::Cookies & + ); + +#endif /* _TAO_CDR_OP_PortableInterceptor_Cookies_I_ */ + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &, + const PortableInterceptor::Interceptor_ptr + ); +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &, + PortableInterceptor::Interceptor_ptr & + ); + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const PortableInterceptor::Interceptor_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + PortableInterceptor::Interceptor_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 = + PortableInterceptor::Interceptor::_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 PortableInterceptor::ServerRequestInterceptor_ptr + ); +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &, + PortableInterceptor::ServerRequestInterceptor_ptr & + ); + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const PortableInterceptor::ServerRequestInterceptor_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + PortableInterceptor::ServerRequestInterceptor_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 = + PortableInterceptor::ServerRequestInterceptor::_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 PortableInterceptor::ClientRequestInterceptor_ptr + ); +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &, + PortableInterceptor::ClientRequestInterceptor_ptr & + ); + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const PortableInterceptor::ClientRequestInterceptor_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + PortableInterceptor::ClientRequestInterceptor_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 = + PortableInterceptor::ClientRequestInterceptor::_narrow ( + obj.in (), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + ACE_CATCHANY + { + // do nothing + } + ACE_ENDTRY; + return 0; +} + #endif /* TAO_HAS_INTERCEPTORS */ diff --git a/TAO/tao/InterfaceC.cpp b/TAO/tao/InterfaceC.cpp index d77fe4923a0..f2ca479ac4d 100644 --- a/TAO/tao/InterfaceC.cpp +++ b/TAO/tao/InterfaceC.cpp @@ -9322,6 +9322,7 @@ CORBA_ExceptionDefSeq * CORBA_OperationDef::exceptions ( TAO_GIOP_Twoway_Invocation _tao_call ( istub, "_get_""exceptions", + 15, istub->orb_core () ); @@ -13788,37 +13789,51 @@ TAO_NAMESPACE_TYPE (const CORBA::Short) TAO_NAMESPACE_BEGIN (CORBA) TAO_NAMESPACE_DEFINE (const CORBA::Short, VM_TRUNCATABLE, 3) TAO_NAMESPACE_END -void operator<<= (CORBA_Any &_tao_any,CORBA::DefinitionKind _tao_elem) +void operator<<= (CORBA::Any &_tao_any, CORBA::DefinitionKind _tao_elem) { - CORBA::DefinitionKind *_any_val; - ACE_NEW (_any_val,CORBA::DefinitionKind (_tao_elem)); - if (!_any_val) return; + CORBA::DefinitionKind *_tao_any_val; + ACE_NEW (_tao_any_val, CORBA::DefinitionKind (_tao_elem)); + if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_DefinitionKind, _any_val, 1, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_any_val; + _tao_any._tao_replace ( + CORBA::_tc_DefinitionKind, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY { // free allocated storage - delete _any_val; + delete _tao_any_val; } ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA::DefinitionKind &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::DefinitionKind &_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_DefinitionKind, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_DefinitionKind, 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.decode (CORBA::_tc_DefinitionKind, &_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) + { return 1; - ACE_TRY_CHECK; + } } ACE_CATCHANY { @@ -13828,18 +13843,33 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA::DefinitionKind &_t return 0; } -CORBA_IRObject_ptr (*_TAO_collocation_CORBA_IRObject_Stub_Factory_function_pointer) ( - CORBA_Object_ptr obj +CORBA::IRObject_ptr (*_TAO_collocation_CORBA_IRObject_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj ) = 0; -void operator<<= (CORBA_Any &_tao_any, CORBA_IRObject_ptr _tao_elem) +void operator<<= (CORBA::Any &_tao_any, CORBA::IRObject_ptr _tao_elem) { - CORBA_Object_ptr *_tao_obj_ptr = 0; + CORBA::Object_ptr *_tao_obj_ptr = 0; ACE_TRY_NEW_ENV { - ACE_NEW (_tao_obj_ptr, CORBA_Object_ptr); - *_tao_obj_ptr = CORBA_IRObject::_duplicate (_tao_elem); - _tao_any.replace (CORBA::_tc_IRObject, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); + *_tao_obj_ptr = CORBA::IRObject::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_IRObject, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -13848,60 +13878,91 @@ void operator<<= (CORBA_Any &_tao_any, CORBA_IRObject_ptr _tao_elem) ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_IRObject_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::IRObject_ptr &_tao_elem) { - CORBA_Object_ptr *tmp = 0; + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { - _tao_elem = CORBA_IRObject::_nil (); + _tao_elem = CORBA::IRObject::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_IRObject, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_IRObject, 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; - ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0); - if (stream.decode (CORBA::_tc_IRObject, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - _tao_elem = CORBA_IRObject::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); + 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::IRObject::_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 (CORBA::_tc_IRObject, tmp, 1, ACE_TRY_ENV); + *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_IRObject, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = CORBA::IRObject::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = CORBA::IRObject::_nil (); return 0; } -#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) - template class TAO_Object_Field_T<CORBA_IRObject,CORBA_IRObject_var>; -template class TAO_Object_Manager<CORBA_IRObject,CORBA_IRObject_var>; +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Field_T<CORBA::IRObject,CORBA::IRObject_var>; + template class TAO_Object_Manager<CORBA::IRObject,CORBA::IRObject_var>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) -# pragma instantiate TAO_Object_Field_T<CORBA_IRObject,CORBA_IRObject_var> -# pragma instantiate TAO_Object_Manager<CORBA_IRObject,CORBA_IRObject_var> +# pragma instantiate TAO_Object_Field_T<CORBA::IRObject,CORBA::IRObject_var> +# pragma instantiate TAO_Object_Manager<CORBA::IRObject,CORBA::IRObject_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ -CORBA_Contained_ptr (*_TAO_collocation_CORBA_Contained_Stub_Factory_function_pointer) ( - CORBA_Object_ptr obj +CORBA::Contained_ptr (*_TAO_collocation_CORBA_Contained_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj ) = 0; -void operator<<= (CORBA_Any &_tao_any, CORBA_Contained_ptr _tao_elem) +void operator<<= (CORBA::Any &_tao_any, CORBA::Contained_ptr _tao_elem) { - CORBA_Object_ptr *_tao_obj_ptr = 0; + CORBA::Object_ptr *_tao_obj_ptr = 0; ACE_TRY_NEW_ENV { - ACE_NEW (_tao_obj_ptr, CORBA_Object_ptr); - *_tao_obj_ptr = CORBA_Contained::_duplicate (_tao_elem); - _tao_any.replace (CORBA::_tc_Contained, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); + *_tao_obj_ptr = CORBA::Contained::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_Contained, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -13910,56 +13971,81 @@ void operator<<= (CORBA_Any &_tao_any, CORBA_Contained_ptr _tao_elem) ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_Contained_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Contained_ptr &_tao_elem) { - CORBA_Object_ptr *tmp = 0; + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { - _tao_elem = CORBA_Contained::_nil (); + _tao_elem = CORBA::Contained::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_Contained, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_Contained, 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; - ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0); - if (stream.decode (CORBA::_tc_Contained, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - _tao_elem = CORBA_Contained::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); + 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::Contained::_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 (CORBA::_tc_Contained, tmp, 1, ACE_TRY_ENV); + *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_Contained, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = CORBA::Contained::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = CORBA::Contained::_nil (); return 0; } -#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) - template class TAO_Object_Field_T<CORBA_Contained,CORBA_Contained_var>; -template class TAO_Object_Manager<CORBA_Contained,CORBA_Contained_var>; +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Field_T<CORBA::Contained,CORBA::Contained_var>; + template class TAO_Object_Manager<CORBA::Contained,CORBA::Contained_var>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) -# pragma instantiate TAO_Object_Field_T<CORBA_Contained,CORBA_Contained_var> -# pragma instantiate TAO_Object_Manager<CORBA_Contained,CORBA_Contained_var> +# pragma instantiate TAO_Object_Field_T<CORBA::Contained,CORBA::Contained_var> +# pragma instantiate TAO_Object_Manager<CORBA::Contained,CORBA::Contained_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ -void operator<<= (CORBA_Any &_tao_any, const CORBA_Contained::Description &_tao_elem) // copying +void operator<<= (CORBA::Any &_tao_any, const CORBA::Contained::Description &_tao_elem) // copying { - CORBA_Contained::Description *_any_val; - ACE_NEW (_any_val, CORBA_Contained::Description (_tao_elem)); + CORBA::Contained::Description *_any_val = 0; + ACE_NEW (_any_val, CORBA::Contained::Description (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA_Contained::_tc_Description, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + CORBA::Contained::_tc_Description, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -13969,68 +14055,159 @@ void operator<<= (CORBA_Any &_tao_any, const CORBA_Contained::Description &_tao_ ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_Contained::Description *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::Contained::Description *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA_Contained::_tc_Description, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::Contained::_tc_Description, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_Contained::Description *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Contained::Description *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA_Contained::_tc_Description, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::Contained::_tc_Description, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_Contained::Description *)_tao_any.value (); + _tao_elem = (CORBA::Contained::Description *)_tao_any.value (); return 1; - } + } else { - ACE_NEW_RETURN (_tao_elem, CORBA_Contained::Description, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA_Contained::_tc_Description, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::Contained::Description, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA_Contained::_tc_Description, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::Contained::_tc_Description, + 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 CORBA::Contained::Description *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::Contained::_tc_Description, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::Contained::Description *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::Contained::Description, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::Contained::Description *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::Contained::_tc_Description, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::Contained::Description *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::Contained::Description *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::Contained::Description *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; } void operator<<= ( - CORBA_Any &_tao_any, - const CORBA_InterfaceDefSeq &_tao_elem + CORBA::Any &_tao_any, + const CORBA::InterfaceDefSeq &_tao_elem ) // copying { - CORBA_InterfaceDefSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA_InterfaceDefSeq (_tao_elem)); + CORBA::InterfaceDefSeq *_tao_any_val; + ACE_NEW (_tao_any_val, CORBA::InterfaceDefSeq (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_InterfaceDefSeq, _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 ( + CORBA::_tc_InterfaceDefSeq, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_any_val; + } } ACE_CATCHANY { @@ -14039,68 +14216,159 @@ void operator<<= ( ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_InterfaceDefSeq *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::InterfaceDefSeq *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_InterfaceDefSeq, _tao_elem, 0, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_InterfaceDefSeq, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_InterfaceDefSeq *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InterfaceDefSeq *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_InterfaceDefSeq, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_InterfaceDefSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_InterfaceDefSeq *)_tao_any.value (); + _tao_elem = (CORBA::InterfaceDefSeq *)_tao_any.value (); return 1; } else { - ACE_NEW_RETURN (_tao_elem, CORBA_InterfaceDefSeq, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_InterfaceDefSeq, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::InterfaceDefSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA::_tc_InterfaceDefSeq, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_InterfaceDefSeq, + 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 CORBA::InterfaceDefSeq *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_InterfaceDefSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::InterfaceDefSeq *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::InterfaceDefSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::InterfaceDefSeq *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_InterfaceDefSeq, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::InterfaceDefSeq *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::InterfaceDefSeq *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::InterfaceDefSeq *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; } void operator<<= ( - CORBA_Any &_tao_any, - const CORBA_ValueDefSeq &_tao_elem + CORBA::Any &_tao_any, + const CORBA::ValueDefSeq &_tao_elem ) // copying { - CORBA_ValueDefSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA_ValueDefSeq (_tao_elem)); + CORBA::ValueDefSeq *_tao_any_val; + ACE_NEW (_tao_any_val, CORBA::ValueDefSeq (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_ValueDefSeq, _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 ( + CORBA::_tc_ValueDefSeq, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_any_val; + } } ACE_CATCHANY { @@ -14109,68 +14377,159 @@ void operator<<= ( ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_ValueDefSeq *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::ValueDefSeq *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_ValueDefSeq, _tao_elem, 0, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_ValueDefSeq, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ValueDefSeq *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueDefSeq *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_ValueDefSeq, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_ValueDefSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_ValueDefSeq *)_tao_any.value (); + _tao_elem = (CORBA::ValueDefSeq *)_tao_any.value (); return 1; } else { - ACE_NEW_RETURN (_tao_elem, CORBA_ValueDefSeq, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_ValueDefSeq, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::ValueDefSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA::_tc_ValueDefSeq, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ValueDefSeq, + 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 CORBA::ValueDefSeq *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_ValueDefSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::ValueDefSeq *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::ValueDefSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::ValueDefSeq *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ValueDefSeq, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::ValueDefSeq *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::ValueDefSeq *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::ValueDefSeq *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; } void operator<<= ( - CORBA_Any &_tao_any, - const CORBA_ContainedSeq &_tao_elem + CORBA::Any &_tao_any, + const CORBA::ContainedSeq &_tao_elem ) // copying { - CORBA_ContainedSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA_ContainedSeq (_tao_elem)); + CORBA::ContainedSeq *_tao_any_val; + ACE_NEW (_tao_any_val, CORBA::ContainedSeq (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_ContainedSeq, _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 ( + CORBA::_tc_ContainedSeq, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_any_val; + } } ACE_CATCHANY { @@ -14179,64 +14538,149 @@ void operator<<= ( ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_ContainedSeq *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::ContainedSeq *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_ContainedSeq, _tao_elem, 0, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_ContainedSeq, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ContainedSeq *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ContainedSeq *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_ContainedSeq, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_ContainedSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_ContainedSeq *)_tao_any.value (); + _tao_elem = (CORBA::ContainedSeq *)_tao_any.value (); return 1; } else { - ACE_NEW_RETURN (_tao_elem, CORBA_ContainedSeq, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_ContainedSeq, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::ContainedSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA::_tc_ContainedSeq, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ContainedSeq, + 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 CORBA::ContainedSeq *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_ContainedSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::ContainedSeq *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::ContainedSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::ContainedSeq *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ContainedSeq, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::ContainedSeq *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::ContainedSeq *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::ContainedSeq *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; } -void operator<<= (CORBA_Any &_tao_any, const CORBA_StructMember &_tao_elem) // copying +void operator<<= (CORBA::Any &_tao_any, const CORBA::StructMember &_tao_elem) // copying { - CORBA_StructMember *_any_val; - ACE_NEW (_any_val, CORBA_StructMember (_tao_elem)); + CORBA::StructMember *_any_val = 0; + ACE_NEW (_any_val, CORBA::StructMember (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_StructMember, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + CORBA::_tc_StructMember, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -14246,68 +14690,159 @@ void operator<<= (CORBA_Any &_tao_any, const CORBA_StructMember &_tao_elem) // c ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_StructMember *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::StructMember *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_StructMember, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_StructMember, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_StructMember *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::StructMember *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_StructMember, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_StructMember, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_StructMember *)_tao_any.value (); + _tao_elem = (CORBA::StructMember *)_tao_any.value (); return 1; - } + } else { - ACE_NEW_RETURN (_tao_elem, CORBA_StructMember, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_StructMember, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::StructMember, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA::_tc_StructMember, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_StructMember, + 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 CORBA::StructMember *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_StructMember, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::StructMember *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::StructMember, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::StructMember *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_StructMember, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::StructMember *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::StructMember *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::StructMember *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; } void operator<<= ( - CORBA_Any &_tao_any, - const CORBA_StructMemberSeq &_tao_elem + CORBA::Any &_tao_any, + const CORBA::StructMemberSeq &_tao_elem ) // copying { - CORBA_StructMemberSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA_StructMemberSeq (_tao_elem)); + CORBA::StructMemberSeq *_tao_any_val; + ACE_NEW (_tao_any_val, CORBA::StructMemberSeq (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_StructMemberSeq, _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 ( + CORBA::_tc_StructMemberSeq, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_any_val; + } } ACE_CATCHANY { @@ -14316,64 +14851,149 @@ void operator<<= ( ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_StructMemberSeq *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::StructMemberSeq *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_StructMemberSeq, _tao_elem, 0, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_StructMemberSeq, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_StructMemberSeq *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::StructMemberSeq *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_StructMemberSeq, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_StructMemberSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_StructMemberSeq *)_tao_any.value (); + _tao_elem = (CORBA::StructMemberSeq *)_tao_any.value (); return 1; } else { - ACE_NEW_RETURN (_tao_elem, CORBA_StructMemberSeq, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_StructMemberSeq, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::StructMemberSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA::_tc_StructMemberSeq, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_StructMemberSeq, + 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 CORBA::StructMemberSeq *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_StructMemberSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::StructMemberSeq *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::StructMemberSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::StructMemberSeq *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_StructMemberSeq, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::StructMemberSeq *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::StructMemberSeq *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::StructMemberSeq *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; } -void operator<<= (CORBA_Any &_tao_any, const CORBA_Initializer &_tao_elem) // copying +void operator<<= (CORBA::Any &_tao_any, const CORBA::Initializer &_tao_elem) // copying { - CORBA_Initializer *_any_val; - ACE_NEW (_any_val, CORBA_Initializer (_tao_elem)); + CORBA::Initializer *_any_val = 0; + ACE_NEW (_any_val, CORBA::Initializer (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_Initializer, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + CORBA::_tc_Initializer, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -14383,68 +15003,159 @@ void operator<<= (CORBA_Any &_tao_any, const CORBA_Initializer &_tao_elem) // co ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_Initializer *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::Initializer *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_Initializer, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_Initializer, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_Initializer *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Initializer *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_Initializer, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_Initializer, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_Initializer *)_tao_any.value (); + _tao_elem = (CORBA::Initializer *)_tao_any.value (); return 1; - } + } else { - ACE_NEW_RETURN (_tao_elem, CORBA_Initializer, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_Initializer, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::Initializer, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA::_tc_Initializer, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_Initializer, + 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 CORBA::Initializer *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_Initializer, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::Initializer *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::Initializer, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::Initializer *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_Initializer, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::Initializer *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::Initializer *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::Initializer *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; } void operator<<= ( - CORBA_Any &_tao_any, - const CORBA_InitializerSeq &_tao_elem + CORBA::Any &_tao_any, + const CORBA::InitializerSeq &_tao_elem ) // copying { - CORBA_InitializerSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA_InitializerSeq (_tao_elem)); + CORBA::InitializerSeq *_tao_any_val; + ACE_NEW (_tao_any_val, CORBA::InitializerSeq (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_InitializerSeq, _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 ( + CORBA::_tc_InitializerSeq, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_any_val; + } } ACE_CATCHANY { @@ -14453,64 +15164,149 @@ void operator<<= ( ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_InitializerSeq *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::InitializerSeq *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_InitializerSeq, _tao_elem, 0, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_InitializerSeq, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_InitializerSeq *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InitializerSeq *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_InitializerSeq, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_InitializerSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_InitializerSeq *)_tao_any.value (); + _tao_elem = (CORBA::InitializerSeq *)_tao_any.value (); return 1; } else { - ACE_NEW_RETURN (_tao_elem, CORBA_InitializerSeq, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_InitializerSeq, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::InitializerSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA::_tc_InitializerSeq, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_InitializerSeq, + 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 CORBA::InitializerSeq *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_InitializerSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::InitializerSeq *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::InitializerSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::InitializerSeq *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_InitializerSeq, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::InitializerSeq *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::InitializerSeq *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::InitializerSeq *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; } -void operator<<= (CORBA_Any &_tao_any, const CORBA_UnionMember &_tao_elem) // copying +void operator<<= (CORBA::Any &_tao_any, const CORBA::UnionMember &_tao_elem) // copying { - CORBA_UnionMember *_any_val; - ACE_NEW (_any_val, CORBA_UnionMember (_tao_elem)); + CORBA::UnionMember *_any_val = 0; + ACE_NEW (_any_val, CORBA::UnionMember (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_UnionMember, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + CORBA::_tc_UnionMember, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -14520,68 +15316,159 @@ void operator<<= (CORBA_Any &_tao_any, const CORBA_UnionMember &_tao_elem) // co ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_UnionMember *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::UnionMember *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_UnionMember, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_UnionMember, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_UnionMember *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::UnionMember *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_UnionMember, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_UnionMember, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_UnionMember *)_tao_any.value (); + _tao_elem = (CORBA::UnionMember *)_tao_any.value (); return 1; - } + } else { - ACE_NEW_RETURN (_tao_elem, CORBA_UnionMember, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_UnionMember, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::UnionMember, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA::_tc_UnionMember, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_UnionMember, + 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 CORBA::UnionMember *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_UnionMember, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::UnionMember *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::UnionMember, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::UnionMember *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_UnionMember, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::UnionMember *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::UnionMember *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::UnionMember *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; } void operator<<= ( - CORBA_Any &_tao_any, - const CORBA_UnionMemberSeq &_tao_elem + CORBA::Any &_tao_any, + const CORBA::UnionMemberSeq &_tao_elem ) // copying { - CORBA_UnionMemberSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA_UnionMemberSeq (_tao_elem)); + CORBA::UnionMemberSeq *_tao_any_val; + ACE_NEW (_tao_any_val, CORBA::UnionMemberSeq (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_UnionMemberSeq, _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 ( + CORBA::_tc_UnionMemberSeq, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_any_val; + } } ACE_CATCHANY { @@ -14590,68 +15477,159 @@ void operator<<= ( ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_UnionMemberSeq *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::UnionMemberSeq *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_UnionMemberSeq, _tao_elem, 0, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_UnionMemberSeq, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_UnionMemberSeq *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::UnionMemberSeq *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_UnionMemberSeq, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_UnionMemberSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_UnionMemberSeq *)_tao_any.value (); + _tao_elem = (CORBA::UnionMemberSeq *)_tao_any.value (); return 1; } else { - ACE_NEW_RETURN (_tao_elem, CORBA_UnionMemberSeq, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_UnionMemberSeq, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::UnionMemberSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA::_tc_UnionMemberSeq, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_UnionMemberSeq, + 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 CORBA::UnionMemberSeq *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_UnionMemberSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::UnionMemberSeq *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::UnionMemberSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::UnionMemberSeq *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_UnionMemberSeq, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::UnionMemberSeq *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::UnionMemberSeq *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::UnionMemberSeq *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; } void operator<<= ( - CORBA_Any &_tao_any, - const CORBA_EnumMemberSeq &_tao_elem + CORBA::Any &_tao_any, + const CORBA::EnumMemberSeq &_tao_elem ) // copying { - CORBA_EnumMemberSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA_EnumMemberSeq (_tao_elem)); + CORBA::EnumMemberSeq *_tao_any_val; + ACE_NEW (_tao_any_val, CORBA::EnumMemberSeq (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_EnumMemberSeq, _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 ( + CORBA::_tc_EnumMemberSeq, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_any_val; + } } ACE_CATCHANY { @@ -14660,68 +15638,159 @@ void operator<<= ( ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_EnumMemberSeq *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::EnumMemberSeq *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_EnumMemberSeq, _tao_elem, 0, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_EnumMemberSeq, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_EnumMemberSeq *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::EnumMemberSeq *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_EnumMemberSeq, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_EnumMemberSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_EnumMemberSeq *)_tao_any.value (); + _tao_elem = (CORBA::EnumMemberSeq *)_tao_any.value (); return 1; } else { - ACE_NEW_RETURN (_tao_elem, CORBA_EnumMemberSeq, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_EnumMemberSeq, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::EnumMemberSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA::_tc_EnumMemberSeq, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_EnumMemberSeq, + 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_Container_ptr (*_TAO_collocation_CORBA_Container_Stub_Factory_function_pointer) ( - CORBA_Object_ptr obj - ) = 0; -void operator<<= (CORBA_Any &_tao_any, CORBA_Container_ptr _tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::EnumMemberSeq *&_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_Container::_duplicate (_tao_elem); - _tao_any.replace (CORBA::_tc_Container, _tao_obj_ptr, 1, ACE_TRY_ENV); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_EnumMemberSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::EnumMemberSeq *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::EnumMemberSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::EnumMemberSeq *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_EnumMemberSeq, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::EnumMemberSeq *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::EnumMemberSeq *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::EnumMemberSeq *&, _tao_elem); + _tao_elem = 0; + return 0; + } + ACE_ENDTRY; + return 0; +} + +CORBA::Container_ptr (*_TAO_collocation_CORBA_Container_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj + ) = 0; +void operator<<= (CORBA::Any &_tao_any, CORBA::Container_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::Container::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_Container, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -14730,56 +15799,81 @@ void operator<<= (CORBA_Any &_tao_any, CORBA_Container_ptr _tao_elem) ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_Container_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Container_ptr &_tao_elem) { - CORBA_Object_ptr *tmp = 0; + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { - _tao_elem = CORBA_Container::_nil (); + _tao_elem = CORBA::Container::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_Container, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_Container, 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; - ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0); - if (stream.decode (CORBA::_tc_Container, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - _tao_elem = CORBA_Container::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); + 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::Container::_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 (CORBA::_tc_Container, tmp, 1, ACE_TRY_ENV); + *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_Container, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = CORBA::Container::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = CORBA::Container::_nil (); return 0; } -#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) - template class TAO_Object_Field_T<CORBA_Container,CORBA_Container_var>; -template class TAO_Object_Manager<CORBA_Container,CORBA_Container_var>; +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Field_T<CORBA::Container,CORBA::Container_var>; + template class TAO_Object_Manager<CORBA::Container,CORBA::Container_var>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) -# pragma instantiate TAO_Object_Field_T<CORBA_Container,CORBA_Container_var> -# pragma instantiate TAO_Object_Manager<CORBA_Container,CORBA_Container_var> +# pragma instantiate TAO_Object_Field_T<CORBA::Container,CORBA::Container_var> +# pragma instantiate TAO_Object_Manager<CORBA::Container,CORBA::Container_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ -void operator<<= (CORBA_Any &_tao_any, const CORBA_Container::Description &_tao_elem) // copying +void operator<<= (CORBA::Any &_tao_any, const CORBA::Container::Description &_tao_elem) // copying { - CORBA_Container::Description *_any_val; - ACE_NEW (_any_val, CORBA_Container::Description (_tao_elem)); + CORBA::Container::Description *_any_val = 0; + ACE_NEW (_any_val, CORBA::Container::Description (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA_Container::_tc_Description, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + CORBA::Container::_tc_Description, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -14789,68 +15883,159 @@ void operator<<= (CORBA_Any &_tao_any, const CORBA_Container::Description &_tao_ ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_Container::Description *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::Container::Description *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA_Container::_tc_Description, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::Container::_tc_Description, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_Container::Description *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Container::Description *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA_Container::_tc_Description, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::Container::_tc_Description, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_Container::Description *)_tao_any.value (); + _tao_elem = (CORBA::Container::Description *)_tao_any.value (); return 1; - } + } else { - ACE_NEW_RETURN (_tao_elem, CORBA_Container::Description, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA_Container::_tc_Description, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::Container::Description, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA_Container::_tc_Description, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::Container::_tc_Description, + 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 CORBA::Container::Description *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::Container::_tc_Description, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::Container::Description *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::Container::Description, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::Container::Description *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::Container::_tc_Description, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::Container::Description *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::Container::Description *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::Container::Description *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; } void operator<<= ( - CORBA_Any &_tao_any, - const CORBA_Container::DescriptionSeq &_tao_elem + CORBA::Any &_tao_any, + const CORBA::Container::DescriptionSeq &_tao_elem ) // copying { - CORBA_Container::DescriptionSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA_Container::DescriptionSeq (_tao_elem)); + CORBA::Container::DescriptionSeq *_tao_any_val; + ACE_NEW (_tao_any_val, CORBA::Container::DescriptionSeq (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA_Container::_tc_DescriptionSeq, _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 ( + CORBA::Container::_tc_DescriptionSeq, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_any_val; + } } ACE_CATCHANY { @@ -14859,68 +16044,159 @@ void operator<<= ( ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_Container::DescriptionSeq *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::Container::DescriptionSeq *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA_Container::_tc_DescriptionSeq, _tao_elem, 0, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::Container::_tc_DescriptionSeq, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_Container::DescriptionSeq *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Container::DescriptionSeq *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA_Container::_tc_DescriptionSeq, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::Container::_tc_DescriptionSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_Container::DescriptionSeq *)_tao_any.value (); + _tao_elem = (CORBA::Container::DescriptionSeq *)_tao_any.value (); return 1; } else { - ACE_NEW_RETURN (_tao_elem, CORBA_Container::DescriptionSeq, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA_Container::_tc_DescriptionSeq, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::Container::DescriptionSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA_Container::_tc_DescriptionSeq, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::Container::_tc_DescriptionSeq, + 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_IDLType_ptr (*_TAO_collocation_CORBA_IDLType_Stub_Factory_function_pointer) ( - CORBA_Object_ptr obj - ) = 0; -void operator<<= (CORBA_Any &_tao_any, CORBA_IDLType_ptr _tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::Container::DescriptionSeq *&_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_IDLType::_duplicate (_tao_elem); - _tao_any.replace (CORBA::_tc_IDLType, _tao_obj_ptr, 1, ACE_TRY_ENV); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::Container::_tc_DescriptionSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::Container::DescriptionSeq *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::Container::DescriptionSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::Container::DescriptionSeq *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::Container::_tc_DescriptionSeq, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::Container::DescriptionSeq *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::Container::DescriptionSeq *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::Container::DescriptionSeq *&, _tao_elem); + _tao_elem = 0; + return 0; + } + ACE_ENDTRY; + return 0; +} + +CORBA::IDLType_ptr (*_TAO_collocation_CORBA_IDLType_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj + ) = 0; +void operator<<= (CORBA::Any &_tao_any, CORBA::IDLType_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::IDLType::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_IDLType, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -14929,79 +16205,109 @@ void operator<<= (CORBA_Any &_tao_any, CORBA_IDLType_ptr _tao_elem) ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_IDLType_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::IDLType_ptr &_tao_elem) { - CORBA_Object_ptr *tmp = 0; + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { - _tao_elem = CORBA_IDLType::_nil (); + _tao_elem = CORBA::IDLType::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_IDLType, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_IDLType, 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; - ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0); - if (stream.decode (CORBA::_tc_IDLType, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - _tao_elem = CORBA_IDLType::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); + 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::IDLType::_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 (CORBA::_tc_IDLType, tmp, 1, ACE_TRY_ENV); + *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_IDLType, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = CORBA::IDLType::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = CORBA::IDLType::_nil (); return 0; } -#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) - template class TAO_Object_Field_T<CORBA_IDLType,CORBA_IDLType_var>; -template class TAO_Object_Manager<CORBA_IDLType,CORBA_IDLType_var>; +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Field_T<CORBA::IDLType,CORBA::IDLType_var>; + template class TAO_Object_Manager<CORBA::IDLType,CORBA::IDLType_var>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) -# pragma instantiate TAO_Object_Field_T<CORBA_IDLType,CORBA_IDLType_var> -# pragma instantiate TAO_Object_Manager<CORBA_IDLType,CORBA_IDLType_var> +# pragma instantiate TAO_Object_Field_T<CORBA::IDLType,CORBA::IDLType_var> +# pragma instantiate TAO_Object_Manager<CORBA::IDLType,CORBA::IDLType_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ -void operator<<= (CORBA_Any &_tao_any, CORBA::PrimitiveKind _tao_elem) +void operator<<= (CORBA::Any &_tao_any, CORBA::PrimitiveKind _tao_elem) { - CORBA::PrimitiveKind *_any_val; - ACE_NEW (_any_val, CORBA::PrimitiveKind (_tao_elem)); - if (!_any_val) return; + CORBA::PrimitiveKind *_tao_any_val; + ACE_NEW (_tao_any_val, CORBA::PrimitiveKind (_tao_elem)); + if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_PrimitiveKind, _any_val, 1, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_any_val; + _tao_any._tao_replace ( + CORBA::_tc_PrimitiveKind, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY { // free allocated storage - delete _any_val; + delete _tao_any_val; } ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA::PrimitiveKind &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PrimitiveKind &_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_PrimitiveKind, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_PrimitiveKind, 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.decode (CORBA::_tc_PrimitiveKind, &_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) + { return 1; - ACE_TRY_CHECK; + } } ACE_CATCHANY { @@ -15011,18 +16317,33 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA::PrimitiveKind &_ta return 0; } -CORBA_Repository_ptr (*_TAO_collocation_CORBA_Repository_Stub_Factory_function_pointer) ( - CORBA_Object_ptr obj +CORBA::Repository_ptr (*_TAO_collocation_CORBA_Repository_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj ) = 0; -void operator<<= (CORBA_Any &_tao_any, CORBA_Repository_ptr _tao_elem) +void operator<<= (CORBA::Any &_tao_any, CORBA::Repository_ptr _tao_elem) { - CORBA_Object_ptr *_tao_obj_ptr = 0; + CORBA::Object_ptr *_tao_obj_ptr = 0; ACE_TRY_NEW_ENV { - ACE_NEW (_tao_obj_ptr, CORBA_Object_ptr); - *_tao_obj_ptr = CORBA_Repository::_duplicate (_tao_elem); - _tao_any.replace (CORBA::_tc_Repository, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); + *_tao_obj_ptr = CORBA::Repository::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_Repository, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -15031,60 +16352,91 @@ void operator<<= (CORBA_Any &_tao_any, CORBA_Repository_ptr _tao_elem) ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_Repository_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Repository_ptr &_tao_elem) { - CORBA_Object_ptr *tmp = 0; + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { - _tao_elem = CORBA_Repository::_nil (); + _tao_elem = CORBA::Repository::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_Repository, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_Repository, 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; - ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0); - if (stream.decode (CORBA::_tc_Repository, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - _tao_elem = CORBA_Repository::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); + 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::Repository::_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 (CORBA::_tc_Repository, tmp, 1, ACE_TRY_ENV); + *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_Repository, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = CORBA::Repository::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = CORBA::Repository::_nil (); return 0; } -#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) - template class TAO_Object_Field_T<CORBA_Repository,CORBA_Repository_var>; -template class TAO_Object_Manager<CORBA_Repository,CORBA_Repository_var>; +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Field_T<CORBA::Repository,CORBA::Repository_var>; + template class TAO_Object_Manager<CORBA::Repository,CORBA::Repository_var>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) -# pragma instantiate TAO_Object_Field_T<CORBA_Repository,CORBA_Repository_var> -# pragma instantiate TAO_Object_Manager<CORBA_Repository,CORBA_Repository_var> +# pragma instantiate TAO_Object_Field_T<CORBA::Repository,CORBA::Repository_var> +# pragma instantiate TAO_Object_Manager<CORBA::Repository,CORBA::Repository_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ -CORBA_ModuleDef_ptr (*_TAO_collocation_CORBA_ModuleDef_Stub_Factory_function_pointer) ( - CORBA_Object_ptr obj +CORBA::ModuleDef_ptr (*_TAO_collocation_CORBA_ModuleDef_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj ) = 0; -void operator<<= (CORBA_Any &_tao_any, CORBA_ModuleDef_ptr _tao_elem) +void operator<<= (CORBA::Any &_tao_any, CORBA::ModuleDef_ptr _tao_elem) { - CORBA_Object_ptr *_tao_obj_ptr = 0; + CORBA::Object_ptr *_tao_obj_ptr = 0; ACE_TRY_NEW_ENV { - ACE_NEW (_tao_obj_ptr, CORBA_Object_ptr); - *_tao_obj_ptr = CORBA_ModuleDef::_duplicate (_tao_elem); - _tao_any.replace (CORBA::_tc_ModuleDef, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); + *_tao_obj_ptr = CORBA::ModuleDef::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_ModuleDef, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -15093,56 +16445,81 @@ void operator<<= (CORBA_Any &_tao_any, CORBA_ModuleDef_ptr _tao_elem) ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ModuleDef_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ModuleDef_ptr &_tao_elem) { - CORBA_Object_ptr *tmp = 0; + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { - _tao_elem = CORBA_ModuleDef::_nil (); + _tao_elem = CORBA::ModuleDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_ModuleDef, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_ModuleDef, 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; - ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0); - if (stream.decode (CORBA::_tc_ModuleDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - _tao_elem = CORBA_ModuleDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); + 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::ModuleDef::_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 (CORBA::_tc_ModuleDef, tmp, 1, ACE_TRY_ENV); + *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ModuleDef, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = CORBA::ModuleDef::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = CORBA::ModuleDef::_nil (); return 0; } -#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) - template class TAO_Object_Field_T<CORBA_ModuleDef,CORBA_ModuleDef_var>; -template class TAO_Object_Manager<CORBA_ModuleDef,CORBA_ModuleDef_var>; +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Field_T<CORBA::ModuleDef,CORBA::ModuleDef_var>; + template class TAO_Object_Manager<CORBA::ModuleDef,CORBA::ModuleDef_var>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) -# pragma instantiate TAO_Object_Field_T<CORBA_ModuleDef,CORBA_ModuleDef_var> -# pragma instantiate TAO_Object_Manager<CORBA_ModuleDef,CORBA_ModuleDef_var> +# pragma instantiate TAO_Object_Field_T<CORBA::ModuleDef,CORBA::ModuleDef_var> +# pragma instantiate TAO_Object_Manager<CORBA::ModuleDef,CORBA::ModuleDef_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ -void operator<<= (CORBA_Any &_tao_any, const CORBA_ModuleDescription &_tao_elem) // copying +void operator<<= (CORBA::Any &_tao_any, const CORBA::ModuleDescription &_tao_elem) // copying { - CORBA_ModuleDescription *_any_val; - ACE_NEW (_any_val, CORBA_ModuleDescription (_tao_elem)); + CORBA::ModuleDescription *_any_val = 0; + ACE_NEW (_any_val, CORBA::ModuleDescription (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_ModuleDescription, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + CORBA::_tc_ModuleDescription, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -15152,68 +16529,159 @@ void operator<<= (CORBA_Any &_tao_any, const CORBA_ModuleDescription &_tao_elem) ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_ModuleDescription *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::ModuleDescription *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_ModuleDescription, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_ModuleDescription, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ModuleDescription *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ModuleDescription *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_ModuleDescription, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_ModuleDescription, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_ModuleDescription *)_tao_any.value (); + _tao_elem = (CORBA::ModuleDescription *)_tao_any.value (); return 1; - } + } else { - ACE_NEW_RETURN (_tao_elem, CORBA_ModuleDescription, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_ModuleDescription, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::ModuleDescription, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA::_tc_ModuleDescription, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ModuleDescription, + 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_ConstantDef_ptr (*_TAO_collocation_CORBA_ConstantDef_Stub_Factory_function_pointer) ( - CORBA_Object_ptr obj - ) = 0; -void operator<<= (CORBA_Any &_tao_any, CORBA_ConstantDef_ptr _tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ModuleDescription *&_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_ConstantDef::_duplicate (_tao_elem); - _tao_any.replace (CORBA::_tc_ConstantDef, _tao_obj_ptr, 1, ACE_TRY_ENV); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_ModuleDescription, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::ModuleDescription *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::ModuleDescription, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::ModuleDescription *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ModuleDescription, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::ModuleDescription *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::ModuleDescription *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::ModuleDescription *&, _tao_elem); + _tao_elem = 0; + return 0; + } + ACE_ENDTRY; + return 0; +} + +CORBA::ConstantDef_ptr (*_TAO_collocation_CORBA_ConstantDef_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj + ) = 0; +void operator<<= (CORBA::Any &_tao_any, CORBA::ConstantDef_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::ConstantDef::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_ConstantDef, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -15222,56 +16690,81 @@ void operator<<= (CORBA_Any &_tao_any, CORBA_ConstantDef_ptr _tao_elem) ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ConstantDef_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ConstantDef_ptr &_tao_elem) { - CORBA_Object_ptr *tmp = 0; + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { - _tao_elem = CORBA_ConstantDef::_nil (); + _tao_elem = CORBA::ConstantDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_ConstantDef, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_ConstantDef, 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; - ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0); - if (stream.decode (CORBA::_tc_ConstantDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - _tao_elem = CORBA_ConstantDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); + 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::ConstantDef::_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 (CORBA::_tc_ConstantDef, tmp, 1, ACE_TRY_ENV); + *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ConstantDef, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = CORBA::ConstantDef::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = CORBA::ConstantDef::_nil (); return 0; } -#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) - template class TAO_Object_Field_T<CORBA_ConstantDef,CORBA_ConstantDef_var>; -template class TAO_Object_Manager<CORBA_ConstantDef,CORBA_ConstantDef_var>; +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Field_T<CORBA::ConstantDef,CORBA::ConstantDef_var>; + template class TAO_Object_Manager<CORBA::ConstantDef,CORBA::ConstantDef_var>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) -# pragma instantiate TAO_Object_Field_T<CORBA_ConstantDef,CORBA_ConstantDef_var> -# pragma instantiate TAO_Object_Manager<CORBA_ConstantDef,CORBA_ConstantDef_var> +# pragma instantiate TAO_Object_Field_T<CORBA::ConstantDef,CORBA::ConstantDef_var> +# pragma instantiate TAO_Object_Manager<CORBA::ConstantDef,CORBA::ConstantDef_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ -void operator<<= (CORBA_Any &_tao_any, const CORBA_ConstantDescription &_tao_elem) // copying +void operator<<= (CORBA::Any &_tao_any, const CORBA::ConstantDescription &_tao_elem) // copying { - CORBA_ConstantDescription *_any_val; - ACE_NEW (_any_val, CORBA_ConstantDescription (_tao_elem)); + CORBA::ConstantDescription *_any_val = 0; + ACE_NEW (_any_val, CORBA::ConstantDescription (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_ConstantDescription, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + CORBA::_tc_ConstantDescription, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -15281,68 +16774,159 @@ void operator<<= (CORBA_Any &_tao_any, const CORBA_ConstantDescription &_tao_ele ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_ConstantDescription *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::ConstantDescription *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_ConstantDescription, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_ConstantDescription, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ConstantDescription *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ConstantDescription *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_ConstantDescription, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_ConstantDescription, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_ConstantDescription *)_tao_any.value (); + _tao_elem = (CORBA::ConstantDescription *)_tao_any.value (); return 1; - } + } else { - ACE_NEW_RETURN (_tao_elem, CORBA_ConstantDescription, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_ConstantDescription, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::ConstantDescription, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA::_tc_ConstantDescription, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ConstantDescription, + 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_TypedefDef_ptr (*_TAO_collocation_CORBA_TypedefDef_Stub_Factory_function_pointer) ( - CORBA_Object_ptr obj - ) = 0; -void operator<<= (CORBA_Any &_tao_any, CORBA_TypedefDef_ptr _tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ConstantDescription *&_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_TypedefDef::_duplicate (_tao_elem); - _tao_any.replace (CORBA::_tc_TypedefDef, _tao_obj_ptr, 1, ACE_TRY_ENV); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_ConstantDescription, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::ConstantDescription *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::ConstantDescription, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::ConstantDescription *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ConstantDescription, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::ConstantDescription *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::ConstantDescription *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::ConstantDescription *&, _tao_elem); + _tao_elem = 0; + return 0; + } + ACE_ENDTRY; + return 0; +} + +CORBA::TypedefDef_ptr (*_TAO_collocation_CORBA_TypedefDef_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj + ) = 0; +void operator<<= (CORBA::Any &_tao_any, CORBA::TypedefDef_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::TypedefDef::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_TypedefDef, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -15351,56 +16935,81 @@ void operator<<= (CORBA_Any &_tao_any, CORBA_TypedefDef_ptr _tao_elem) ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_TypedefDef_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::TypedefDef_ptr &_tao_elem) { - CORBA_Object_ptr *tmp = 0; + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { - _tao_elem = CORBA_TypedefDef::_nil (); + _tao_elem = CORBA::TypedefDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_TypedefDef, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_TypedefDef, 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; - ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0); - if (stream.decode (CORBA::_tc_TypedefDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - _tao_elem = CORBA_TypedefDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); + 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::TypedefDef::_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 (CORBA::_tc_TypedefDef, tmp, 1, ACE_TRY_ENV); + *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_TypedefDef, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = CORBA::TypedefDef::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = CORBA::TypedefDef::_nil (); return 0; } -#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) - template class TAO_Object_Field_T<CORBA_TypedefDef,CORBA_TypedefDef_var>; -template class TAO_Object_Manager<CORBA_TypedefDef,CORBA_TypedefDef_var>; +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Field_T<CORBA::TypedefDef,CORBA::TypedefDef_var>; + template class TAO_Object_Manager<CORBA::TypedefDef,CORBA::TypedefDef_var>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) -# pragma instantiate TAO_Object_Field_T<CORBA_TypedefDef,CORBA_TypedefDef_var> -# pragma instantiate TAO_Object_Manager<CORBA_TypedefDef,CORBA_TypedefDef_var> +# pragma instantiate TAO_Object_Field_T<CORBA::TypedefDef,CORBA::TypedefDef_var> +# pragma instantiate TAO_Object_Manager<CORBA::TypedefDef,CORBA::TypedefDef_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ -void operator<<= (CORBA_Any &_tao_any, const CORBA_TypeDescription &_tao_elem) // copying +void operator<<= (CORBA::Any &_tao_any, const CORBA::TypeDescription &_tao_elem) // copying { - CORBA_TypeDescription *_any_val; - ACE_NEW (_any_val, CORBA_TypeDescription (_tao_elem)); + CORBA::TypeDescription *_any_val = 0; + ACE_NEW (_any_val, CORBA::TypeDescription (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_TypeDescription, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + CORBA::_tc_TypeDescription, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -15410,68 +17019,159 @@ void operator<<= (CORBA_Any &_tao_any, const CORBA_TypeDescription &_tao_elem) / ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_TypeDescription *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::TypeDescription *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_TypeDescription, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_TypeDescription, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_TypeDescription *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::TypeDescription *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_TypeDescription, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_TypeDescription, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_TypeDescription *)_tao_any.value (); + _tao_elem = (CORBA::TypeDescription *)_tao_any.value (); return 1; - } + } else { - ACE_NEW_RETURN (_tao_elem, CORBA_TypeDescription, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_TypeDescription, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::TypeDescription, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA::_tc_TypeDescription, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_TypeDescription, + 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_StructDef_ptr (*_TAO_collocation_CORBA_StructDef_Stub_Factory_function_pointer) ( - CORBA_Object_ptr obj - ) = 0; -void operator<<= (CORBA_Any &_tao_any, CORBA_StructDef_ptr _tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::TypeDescription *&_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_StructDef::_duplicate (_tao_elem); - _tao_any.replace (CORBA::_tc_StructDef, _tao_obj_ptr, 1, ACE_TRY_ENV); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_TypeDescription, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::TypeDescription *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::TypeDescription, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::TypeDescription *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_TypeDescription, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::TypeDescription *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::TypeDescription *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::TypeDescription *&, _tao_elem); + _tao_elem = 0; + return 0; + } + ACE_ENDTRY; + return 0; +} + +CORBA::StructDef_ptr (*_TAO_collocation_CORBA_StructDef_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj + ) = 0; +void operator<<= (CORBA::Any &_tao_any, CORBA::StructDef_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::StructDef::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_StructDef, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -15480,60 +17180,91 @@ void operator<<= (CORBA_Any &_tao_any, CORBA_StructDef_ptr _tao_elem) ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_StructDef_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::StructDef_ptr &_tao_elem) { - CORBA_Object_ptr *tmp = 0; + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { - _tao_elem = CORBA_StructDef::_nil (); + _tao_elem = CORBA::StructDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_StructDef, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_StructDef, 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; - ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0); - if (stream.decode (CORBA::_tc_StructDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - _tao_elem = CORBA_StructDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); + 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::StructDef::_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 (CORBA::_tc_StructDef, tmp, 1, ACE_TRY_ENV); + *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_StructDef, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = CORBA::StructDef::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = CORBA::StructDef::_nil (); return 0; } -#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) - template class TAO_Object_Field_T<CORBA_StructDef,CORBA_StructDef_var>; -template class TAO_Object_Manager<CORBA_StructDef,CORBA_StructDef_var>; +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Field_T<CORBA::StructDef,CORBA::StructDef_var>; + template class TAO_Object_Manager<CORBA::StructDef,CORBA::StructDef_var>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) -# pragma instantiate TAO_Object_Field_T<CORBA_StructDef,CORBA_StructDef_var> -# pragma instantiate TAO_Object_Manager<CORBA_StructDef,CORBA_StructDef_var> +# pragma instantiate TAO_Object_Field_T<CORBA::StructDef,CORBA::StructDef_var> +# pragma instantiate TAO_Object_Manager<CORBA::StructDef,CORBA::StructDef_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ -CORBA_UnionDef_ptr (*_TAO_collocation_CORBA_UnionDef_Stub_Factory_function_pointer) ( - CORBA_Object_ptr obj +CORBA::UnionDef_ptr (*_TAO_collocation_CORBA_UnionDef_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj ) = 0; -void operator<<= (CORBA_Any &_tao_any, CORBA_UnionDef_ptr _tao_elem) +void operator<<= (CORBA::Any &_tao_any, CORBA::UnionDef_ptr _tao_elem) { - CORBA_Object_ptr *_tao_obj_ptr = 0; + CORBA::Object_ptr *_tao_obj_ptr = 0; ACE_TRY_NEW_ENV { - ACE_NEW (_tao_obj_ptr, CORBA_Object_ptr); - *_tao_obj_ptr = CORBA_UnionDef::_duplicate (_tao_elem); - _tao_any.replace (CORBA::_tc_UnionDef, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); + *_tao_obj_ptr = CORBA::UnionDef::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_UnionDef, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -15542,60 +17273,91 @@ void operator<<= (CORBA_Any &_tao_any, CORBA_UnionDef_ptr _tao_elem) ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_UnionDef_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::UnionDef_ptr &_tao_elem) { - CORBA_Object_ptr *tmp = 0; + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { - _tao_elem = CORBA_UnionDef::_nil (); + _tao_elem = CORBA::UnionDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_UnionDef, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_UnionDef, 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; - ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0); - if (stream.decode (CORBA::_tc_UnionDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - _tao_elem = CORBA_UnionDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); + 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::UnionDef::_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 (CORBA::_tc_UnionDef, tmp, 1, ACE_TRY_ENV); + *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_UnionDef, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = CORBA::UnionDef::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = CORBA::UnionDef::_nil (); return 0; } -#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) - template class TAO_Object_Field_T<CORBA_UnionDef,CORBA_UnionDef_var>; -template class TAO_Object_Manager<CORBA_UnionDef,CORBA_UnionDef_var>; +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Field_T<CORBA::UnionDef,CORBA::UnionDef_var>; + template class TAO_Object_Manager<CORBA::UnionDef,CORBA::UnionDef_var>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) -# pragma instantiate TAO_Object_Field_T<CORBA_UnionDef,CORBA_UnionDef_var> -# pragma instantiate TAO_Object_Manager<CORBA_UnionDef,CORBA_UnionDef_var> +# pragma instantiate TAO_Object_Field_T<CORBA::UnionDef,CORBA::UnionDef_var> +# pragma instantiate TAO_Object_Manager<CORBA::UnionDef,CORBA::UnionDef_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ -CORBA_EnumDef_ptr (*_TAO_collocation_CORBA_EnumDef_Stub_Factory_function_pointer) ( - CORBA_Object_ptr obj +CORBA::EnumDef_ptr (*_TAO_collocation_CORBA_EnumDef_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj ) = 0; -void operator<<= (CORBA_Any &_tao_any, CORBA_EnumDef_ptr _tao_elem) +void operator<<= (CORBA::Any &_tao_any, CORBA::EnumDef_ptr _tao_elem) { - CORBA_Object_ptr *_tao_obj_ptr = 0; + CORBA::Object_ptr *_tao_obj_ptr = 0; ACE_TRY_NEW_ENV { - ACE_NEW (_tao_obj_ptr, CORBA_Object_ptr); - *_tao_obj_ptr = CORBA_EnumDef::_duplicate (_tao_elem); - _tao_any.replace (CORBA::_tc_EnumDef, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); + *_tao_obj_ptr = CORBA::EnumDef::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_EnumDef, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -15604,60 +17366,91 @@ void operator<<= (CORBA_Any &_tao_any, CORBA_EnumDef_ptr _tao_elem) ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_EnumDef_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::EnumDef_ptr &_tao_elem) { - CORBA_Object_ptr *tmp = 0; + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { - _tao_elem = CORBA_EnumDef::_nil (); + _tao_elem = CORBA::EnumDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_EnumDef, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_EnumDef, 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; - ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0); - if (stream.decode (CORBA::_tc_EnumDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - _tao_elem = CORBA_EnumDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); + 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::EnumDef::_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 (CORBA::_tc_EnumDef, tmp, 1, ACE_TRY_ENV); + *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_EnumDef, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = CORBA::EnumDef::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = CORBA::EnumDef::_nil (); return 0; } -#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) - template class TAO_Object_Field_T<CORBA_EnumDef,CORBA_EnumDef_var>; -template class TAO_Object_Manager<CORBA_EnumDef,CORBA_EnumDef_var>; +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Field_T<CORBA::EnumDef,CORBA::EnumDef_var>; + template class TAO_Object_Manager<CORBA::EnumDef,CORBA::EnumDef_var>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) -# pragma instantiate TAO_Object_Field_T<CORBA_EnumDef,CORBA_EnumDef_var> -# pragma instantiate TAO_Object_Manager<CORBA_EnumDef,CORBA_EnumDef_var> +# pragma instantiate TAO_Object_Field_T<CORBA::EnumDef,CORBA::EnumDef_var> +# pragma instantiate TAO_Object_Manager<CORBA::EnumDef,CORBA::EnumDef_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ -CORBA_AliasDef_ptr (*_TAO_collocation_CORBA_AliasDef_Stub_Factory_function_pointer) ( - CORBA_Object_ptr obj +CORBA::AliasDef_ptr (*_TAO_collocation_CORBA_AliasDef_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj ) = 0; -void operator<<= (CORBA_Any &_tao_any, CORBA_AliasDef_ptr _tao_elem) +void operator<<= (CORBA::Any &_tao_any, CORBA::AliasDef_ptr _tao_elem) { - CORBA_Object_ptr *_tao_obj_ptr = 0; + CORBA::Object_ptr *_tao_obj_ptr = 0; ACE_TRY_NEW_ENV { - ACE_NEW (_tao_obj_ptr, CORBA_Object_ptr); - *_tao_obj_ptr = CORBA_AliasDef::_duplicate (_tao_elem); - _tao_any.replace (CORBA::_tc_AliasDef, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); + *_tao_obj_ptr = CORBA::AliasDef::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_AliasDef, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -15666,60 +17459,91 @@ void operator<<= (CORBA_Any &_tao_any, CORBA_AliasDef_ptr _tao_elem) ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_AliasDef_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AliasDef_ptr &_tao_elem) { - CORBA_Object_ptr *tmp = 0; + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { - _tao_elem = CORBA_AliasDef::_nil (); + _tao_elem = CORBA::AliasDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_AliasDef, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_AliasDef, 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; - ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0); - if (stream.decode (CORBA::_tc_AliasDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - _tao_elem = CORBA_AliasDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); + 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::AliasDef::_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 (CORBA::_tc_AliasDef, tmp, 1, ACE_TRY_ENV); + *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_AliasDef, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = CORBA::AliasDef::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = CORBA::AliasDef::_nil (); return 0; } -#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) - template class TAO_Object_Field_T<CORBA_AliasDef,CORBA_AliasDef_var>; -template class TAO_Object_Manager<CORBA_AliasDef,CORBA_AliasDef_var>; +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Field_T<CORBA::AliasDef,CORBA::AliasDef_var>; + template class TAO_Object_Manager<CORBA::AliasDef,CORBA::AliasDef_var>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) -# pragma instantiate TAO_Object_Field_T<CORBA_AliasDef,CORBA_AliasDef_var> -# pragma instantiate TAO_Object_Manager<CORBA_AliasDef,CORBA_AliasDef_var> +# pragma instantiate TAO_Object_Field_T<CORBA::AliasDef,CORBA::AliasDef_var> +# pragma instantiate TAO_Object_Manager<CORBA::AliasDef,CORBA::AliasDef_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ -CORBA_PrimitiveDef_ptr (*_TAO_collocation_CORBA_PrimitiveDef_Stub_Factory_function_pointer) ( - CORBA_Object_ptr obj +CORBA::PrimitiveDef_ptr (*_TAO_collocation_CORBA_PrimitiveDef_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj ) = 0; -void operator<<= (CORBA_Any &_tao_any, CORBA_PrimitiveDef_ptr _tao_elem) +void operator<<= (CORBA::Any &_tao_any, CORBA::PrimitiveDef_ptr _tao_elem) { - CORBA_Object_ptr *_tao_obj_ptr = 0; + CORBA::Object_ptr *_tao_obj_ptr = 0; ACE_TRY_NEW_ENV { - ACE_NEW (_tao_obj_ptr, CORBA_Object_ptr); - *_tao_obj_ptr = CORBA_PrimitiveDef::_duplicate (_tao_elem); - _tao_any.replace (CORBA::_tc_PrimitiveDef, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); + *_tao_obj_ptr = CORBA::PrimitiveDef::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_PrimitiveDef, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -15728,60 +17552,91 @@ void operator<<= (CORBA_Any &_tao_any, CORBA_PrimitiveDef_ptr _tao_elem) ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_PrimitiveDef_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PrimitiveDef_ptr &_tao_elem) { - CORBA_Object_ptr *tmp = 0; + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { - _tao_elem = CORBA_PrimitiveDef::_nil (); + _tao_elem = CORBA::PrimitiveDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_PrimitiveDef, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_PrimitiveDef, 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; - ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0); - if (stream.decode (CORBA::_tc_PrimitiveDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - _tao_elem = CORBA_PrimitiveDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); + 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::PrimitiveDef::_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 (CORBA::_tc_PrimitiveDef, tmp, 1, ACE_TRY_ENV); + *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_PrimitiveDef, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = CORBA::PrimitiveDef::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = CORBA::PrimitiveDef::_nil (); return 0; } -#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) - template class TAO_Object_Field_T<CORBA_PrimitiveDef,CORBA_PrimitiveDef_var>; -template class TAO_Object_Manager<CORBA_PrimitiveDef,CORBA_PrimitiveDef_var>; +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Field_T<CORBA::PrimitiveDef,CORBA::PrimitiveDef_var>; + template class TAO_Object_Manager<CORBA::PrimitiveDef,CORBA::PrimitiveDef_var>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) -# pragma instantiate TAO_Object_Field_T<CORBA_PrimitiveDef,CORBA_PrimitiveDef_var> -# pragma instantiate TAO_Object_Manager<CORBA_PrimitiveDef,CORBA_PrimitiveDef_var> +# pragma instantiate TAO_Object_Field_T<CORBA::PrimitiveDef,CORBA::PrimitiveDef_var> +# pragma instantiate TAO_Object_Manager<CORBA::PrimitiveDef,CORBA::PrimitiveDef_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ -CORBA_StringDef_ptr (*_TAO_collocation_CORBA_StringDef_Stub_Factory_function_pointer) ( - CORBA_Object_ptr obj +CORBA::StringDef_ptr (*_TAO_collocation_CORBA_StringDef_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj ) = 0; -void operator<<= (CORBA_Any &_tao_any, CORBA_StringDef_ptr _tao_elem) +void operator<<= (CORBA::Any &_tao_any, CORBA::StringDef_ptr _tao_elem) { - CORBA_Object_ptr *_tao_obj_ptr = 0; + CORBA::Object_ptr *_tao_obj_ptr = 0; ACE_TRY_NEW_ENV { - ACE_NEW (_tao_obj_ptr, CORBA_Object_ptr); - *_tao_obj_ptr = CORBA_StringDef::_duplicate (_tao_elem); - _tao_any.replace (CORBA::_tc_StringDef, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); + *_tao_obj_ptr = CORBA::StringDef::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_StringDef, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -15790,60 +17645,91 @@ void operator<<= (CORBA_Any &_tao_any, CORBA_StringDef_ptr _tao_elem) ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_StringDef_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::StringDef_ptr &_tao_elem) { - CORBA_Object_ptr *tmp = 0; + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { - _tao_elem = CORBA_StringDef::_nil (); + _tao_elem = CORBA::StringDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_StringDef, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_StringDef, 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; - ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0); - if (stream.decode (CORBA::_tc_StringDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - _tao_elem = CORBA_StringDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); + 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::StringDef::_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 (CORBA::_tc_StringDef, tmp, 1, ACE_TRY_ENV); + *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_StringDef, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = CORBA::StringDef::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = CORBA::StringDef::_nil (); return 0; } -#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) - template class TAO_Object_Field_T<CORBA_StringDef,CORBA_StringDef_var>; -template class TAO_Object_Manager<CORBA_StringDef,CORBA_StringDef_var>; +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Field_T<CORBA::StringDef,CORBA::StringDef_var>; + template class TAO_Object_Manager<CORBA::StringDef,CORBA::StringDef_var>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) -# pragma instantiate TAO_Object_Field_T<CORBA_StringDef,CORBA_StringDef_var> -# pragma instantiate TAO_Object_Manager<CORBA_StringDef,CORBA_StringDef_var> +# pragma instantiate TAO_Object_Field_T<CORBA::StringDef,CORBA::StringDef_var> +# pragma instantiate TAO_Object_Manager<CORBA::StringDef,CORBA::StringDef_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ -CORBA_WstringDef_ptr (*_TAO_collocation_CORBA_WstringDef_Stub_Factory_function_pointer) ( - CORBA_Object_ptr obj +CORBA::WstringDef_ptr (*_TAO_collocation_CORBA_WstringDef_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj ) = 0; -void operator<<= (CORBA_Any &_tao_any, CORBA_WstringDef_ptr _tao_elem) +void operator<<= (CORBA::Any &_tao_any, CORBA::WstringDef_ptr _tao_elem) { - CORBA_Object_ptr *_tao_obj_ptr = 0; + CORBA::Object_ptr *_tao_obj_ptr = 0; ACE_TRY_NEW_ENV { - ACE_NEW (_tao_obj_ptr, CORBA_Object_ptr); - *_tao_obj_ptr = CORBA_WstringDef::_duplicate (_tao_elem); - _tao_any.replace (CORBA::_tc_WstringDef, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); + *_tao_obj_ptr = CORBA::WstringDef::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_WstringDef, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -15852,60 +17738,91 @@ void operator<<= (CORBA_Any &_tao_any, CORBA_WstringDef_ptr _tao_elem) ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_WstringDef_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::WstringDef_ptr &_tao_elem) { - CORBA_Object_ptr *tmp = 0; + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { - _tao_elem = CORBA_WstringDef::_nil (); + _tao_elem = CORBA::WstringDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_WstringDef, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_WstringDef, 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; - ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0); - if (stream.decode (CORBA::_tc_WstringDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - _tao_elem = CORBA_WstringDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); + 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::WstringDef::_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 (CORBA::_tc_WstringDef, tmp, 1, ACE_TRY_ENV); + *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_WstringDef, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = CORBA::WstringDef::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = CORBA::WstringDef::_nil (); return 0; } -#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) - template class TAO_Object_Field_T<CORBA_WstringDef,CORBA_WstringDef_var>; -template class TAO_Object_Manager<CORBA_WstringDef,CORBA_WstringDef_var>; +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Field_T<CORBA::WstringDef,CORBA::WstringDef_var>; + template class TAO_Object_Manager<CORBA::WstringDef,CORBA::WstringDef_var>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) -# pragma instantiate TAO_Object_Field_T<CORBA_WstringDef,CORBA_WstringDef_var> -# pragma instantiate TAO_Object_Manager<CORBA_WstringDef,CORBA_WstringDef_var> +# pragma instantiate TAO_Object_Field_T<CORBA::WstringDef,CORBA::WstringDef_var> +# pragma instantiate TAO_Object_Manager<CORBA::WstringDef,CORBA::WstringDef_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ -CORBA_FixedDef_ptr (*_TAO_collocation_CORBA_FixedDef_Stub_Factory_function_pointer) ( - CORBA_Object_ptr obj +CORBA::FixedDef_ptr (*_TAO_collocation_CORBA_FixedDef_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj ) = 0; -void operator<<= (CORBA_Any &_tao_any, CORBA_FixedDef_ptr _tao_elem) +void operator<<= (CORBA::Any &_tao_any, CORBA::FixedDef_ptr _tao_elem) { - CORBA_Object_ptr *_tao_obj_ptr = 0; + CORBA::Object_ptr *_tao_obj_ptr = 0; ACE_TRY_NEW_ENV { - ACE_NEW (_tao_obj_ptr, CORBA_Object_ptr); - *_tao_obj_ptr = CORBA_FixedDef::_duplicate (_tao_elem); - _tao_any.replace (CORBA::_tc_FixedDef, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); + *_tao_obj_ptr = CORBA::FixedDef::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_FixedDef, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -15914,60 +17831,91 @@ void operator<<= (CORBA_Any &_tao_any, CORBA_FixedDef_ptr _tao_elem) ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_FixedDef_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::FixedDef_ptr &_tao_elem) { - CORBA_Object_ptr *tmp = 0; + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { - _tao_elem = CORBA_FixedDef::_nil (); + _tao_elem = CORBA::FixedDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_FixedDef, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_FixedDef, 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; - ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0); - if (stream.decode (CORBA::_tc_FixedDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - _tao_elem = CORBA_FixedDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); + 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::FixedDef::_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 (CORBA::_tc_FixedDef, tmp, 1, ACE_TRY_ENV); + *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_FixedDef, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = CORBA::FixedDef::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = CORBA::FixedDef::_nil (); return 0; } -#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) - template class TAO_Object_Field_T<CORBA_FixedDef,CORBA_FixedDef_var>; -template class TAO_Object_Manager<CORBA_FixedDef,CORBA_FixedDef_var>; +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Field_T<CORBA::FixedDef,CORBA::FixedDef_var>; + template class TAO_Object_Manager<CORBA::FixedDef,CORBA::FixedDef_var>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) -# pragma instantiate TAO_Object_Field_T<CORBA_FixedDef,CORBA_FixedDef_var> -# pragma instantiate TAO_Object_Manager<CORBA_FixedDef,CORBA_FixedDef_var> +# pragma instantiate TAO_Object_Field_T<CORBA::FixedDef,CORBA::FixedDef_var> +# pragma instantiate TAO_Object_Manager<CORBA::FixedDef,CORBA::FixedDef_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ -CORBA_SequenceDef_ptr (*_TAO_collocation_CORBA_SequenceDef_Stub_Factory_function_pointer) ( - CORBA_Object_ptr obj +CORBA::SequenceDef_ptr (*_TAO_collocation_CORBA_SequenceDef_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj ) = 0; -void operator<<= (CORBA_Any &_tao_any, CORBA_SequenceDef_ptr _tao_elem) +void operator<<= (CORBA::Any &_tao_any, CORBA::SequenceDef_ptr _tao_elem) { - CORBA_Object_ptr *_tao_obj_ptr = 0; + CORBA::Object_ptr *_tao_obj_ptr = 0; ACE_TRY_NEW_ENV { - ACE_NEW (_tao_obj_ptr, CORBA_Object_ptr); - *_tao_obj_ptr = CORBA_SequenceDef::_duplicate (_tao_elem); - _tao_any.replace (CORBA::_tc_SequenceDef, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); + *_tao_obj_ptr = CORBA::SequenceDef::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_SequenceDef, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -15976,60 +17924,91 @@ void operator<<= (CORBA_Any &_tao_any, CORBA_SequenceDef_ptr _tao_elem) ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_SequenceDef_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::SequenceDef_ptr &_tao_elem) { - CORBA_Object_ptr *tmp = 0; + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { - _tao_elem = CORBA_SequenceDef::_nil (); + _tao_elem = CORBA::SequenceDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_SequenceDef, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_SequenceDef, 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; - ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0); - if (stream.decode (CORBA::_tc_SequenceDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - _tao_elem = CORBA_SequenceDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); + 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::SequenceDef::_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 (CORBA::_tc_SequenceDef, tmp, 1, ACE_TRY_ENV); + *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_SequenceDef, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = CORBA::SequenceDef::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = CORBA::SequenceDef::_nil (); return 0; } -#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) - template class TAO_Object_Field_T<CORBA_SequenceDef,CORBA_SequenceDef_var>; -template class TAO_Object_Manager<CORBA_SequenceDef,CORBA_SequenceDef_var>; +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Field_T<CORBA::SequenceDef,CORBA::SequenceDef_var>; + template class TAO_Object_Manager<CORBA::SequenceDef,CORBA::SequenceDef_var>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) -# pragma instantiate TAO_Object_Field_T<CORBA_SequenceDef,CORBA_SequenceDef_var> -# pragma instantiate TAO_Object_Manager<CORBA_SequenceDef,CORBA_SequenceDef_var> +# pragma instantiate TAO_Object_Field_T<CORBA::SequenceDef,CORBA::SequenceDef_var> +# pragma instantiate TAO_Object_Manager<CORBA::SequenceDef,CORBA::SequenceDef_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ -CORBA_ArrayDef_ptr (*_TAO_collocation_CORBA_ArrayDef_Stub_Factory_function_pointer) ( - CORBA_Object_ptr obj +CORBA::ArrayDef_ptr (*_TAO_collocation_CORBA_ArrayDef_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj ) = 0; -void operator<<= (CORBA_Any &_tao_any, CORBA_ArrayDef_ptr _tao_elem) +void operator<<= (CORBA::Any &_tao_any, CORBA::ArrayDef_ptr _tao_elem) { - CORBA_Object_ptr *_tao_obj_ptr = 0; + CORBA::Object_ptr *_tao_obj_ptr = 0; ACE_TRY_NEW_ENV { - ACE_NEW (_tao_obj_ptr, CORBA_Object_ptr); - *_tao_obj_ptr = CORBA_ArrayDef::_duplicate (_tao_elem); - _tao_any.replace (CORBA::_tc_ArrayDef, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); + *_tao_obj_ptr = CORBA::ArrayDef::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_ArrayDef, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -16038,60 +18017,91 @@ void operator<<= (CORBA_Any &_tao_any, CORBA_ArrayDef_ptr _tao_elem) ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ArrayDef_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ArrayDef_ptr &_tao_elem) { - CORBA_Object_ptr *tmp = 0; + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { - _tao_elem = CORBA_ArrayDef::_nil (); + _tao_elem = CORBA::ArrayDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_ArrayDef, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_ArrayDef, 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; - ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0); - if (stream.decode (CORBA::_tc_ArrayDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - _tao_elem = CORBA_ArrayDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); + 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::ArrayDef::_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 (CORBA::_tc_ArrayDef, tmp, 1, ACE_TRY_ENV); + *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ArrayDef, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = CORBA::ArrayDef::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = CORBA::ArrayDef::_nil (); return 0; } -#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) - template class TAO_Object_Field_T<CORBA_ArrayDef,CORBA_ArrayDef_var>; -template class TAO_Object_Manager<CORBA_ArrayDef,CORBA_ArrayDef_var>; +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Field_T<CORBA::ArrayDef,CORBA::ArrayDef_var>; + template class TAO_Object_Manager<CORBA::ArrayDef,CORBA::ArrayDef_var>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) -# pragma instantiate TAO_Object_Field_T<CORBA_ArrayDef,CORBA_ArrayDef_var> -# pragma instantiate TAO_Object_Manager<CORBA_ArrayDef,CORBA_ArrayDef_var> +# pragma instantiate TAO_Object_Field_T<CORBA::ArrayDef,CORBA::ArrayDef_var> +# pragma instantiate TAO_Object_Manager<CORBA::ArrayDef,CORBA::ArrayDef_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ -CORBA_ExceptionDef_ptr (*_TAO_collocation_CORBA_ExceptionDef_Stub_Factory_function_pointer) ( - CORBA_Object_ptr obj +CORBA::ExceptionDef_ptr (*_TAO_collocation_CORBA_ExceptionDef_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj ) = 0; -void operator<<= (CORBA_Any &_tao_any, CORBA_ExceptionDef_ptr _tao_elem) +void operator<<= (CORBA::Any &_tao_any, CORBA::ExceptionDef_ptr _tao_elem) { - CORBA_Object_ptr *_tao_obj_ptr = 0; + CORBA::Object_ptr *_tao_obj_ptr = 0; ACE_TRY_NEW_ENV { - ACE_NEW (_tao_obj_ptr, CORBA_Object_ptr); - *_tao_obj_ptr = CORBA_ExceptionDef::_duplicate (_tao_elem); - _tao_any.replace (CORBA::_tc_ExceptionDef, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); + *_tao_obj_ptr = CORBA::ExceptionDef::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_ExceptionDef, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -16100,56 +18110,81 @@ void operator<<= (CORBA_Any &_tao_any, CORBA_ExceptionDef_ptr _tao_elem) ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ExceptionDef_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ExceptionDef_ptr &_tao_elem) { - CORBA_Object_ptr *tmp = 0; + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { - _tao_elem = CORBA_ExceptionDef::_nil (); + _tao_elem = CORBA::ExceptionDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_ExceptionDef, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_ExceptionDef, 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; - ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0); - if (stream.decode (CORBA::_tc_ExceptionDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - _tao_elem = CORBA_ExceptionDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); + 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::ExceptionDef::_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 (CORBA::_tc_ExceptionDef, tmp, 1, ACE_TRY_ENV); + *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ExceptionDef, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = CORBA::ExceptionDef::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = CORBA::ExceptionDef::_nil (); return 0; } -#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) - template class TAO_Object_Field_T<CORBA_ExceptionDef,CORBA_ExceptionDef_var>; -template class TAO_Object_Manager<CORBA_ExceptionDef,CORBA_ExceptionDef_var>; +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Field_T<CORBA::ExceptionDef,CORBA::ExceptionDef_var>; + template class TAO_Object_Manager<CORBA::ExceptionDef,CORBA::ExceptionDef_var>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) -# pragma instantiate TAO_Object_Field_T<CORBA_ExceptionDef,CORBA_ExceptionDef_var> -# pragma instantiate TAO_Object_Manager<CORBA_ExceptionDef,CORBA_ExceptionDef_var> +# pragma instantiate TAO_Object_Field_T<CORBA::ExceptionDef,CORBA::ExceptionDef_var> +# pragma instantiate TAO_Object_Manager<CORBA::ExceptionDef,CORBA::ExceptionDef_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ -void operator<<= (CORBA_Any &_tao_any, const CORBA_ExceptionDescription &_tao_elem) // copying +void operator<<= (CORBA::Any &_tao_any, const CORBA::ExceptionDescription &_tao_elem) // copying { - CORBA_ExceptionDescription *_any_val; - ACE_NEW (_any_val, CORBA_ExceptionDescription (_tao_elem)); + CORBA::ExceptionDescription *_any_val = 0; + ACE_NEW (_any_val, CORBA::ExceptionDescription (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_ExceptionDescription, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + CORBA::_tc_ExceptionDescription, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -16159,87 +18194,177 @@ void operator<<= (CORBA_Any &_tao_any, const CORBA_ExceptionDescription &_tao_el ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_ExceptionDescription *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::ExceptionDescription *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_ExceptionDescription, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_ExceptionDescription, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ExceptionDescription *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ExceptionDescription *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_ExceptionDescription, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_ExceptionDescription, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_ExceptionDescription *)_tao_any.value (); + _tao_elem = (CORBA::ExceptionDescription *)_tao_any.value (); return 1; - } + } else { - ACE_NEW_RETURN (_tao_elem, CORBA_ExceptionDescription, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_ExceptionDescription, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::ExceptionDescription, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA::_tc_ExceptionDescription, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ExceptionDescription, + 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; } -void operator<<= (CORBA_Any &_tao_any, CORBA::AttributeMode _tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ExceptionDescription *&_tao_elem) { - CORBA::AttributeMode *_any_val; - ACE_NEW (_any_val, CORBA::AttributeMode (_tao_elem)); - if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_AttributeMode, _any_val, 1, ACE_TRY_ENV); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_ExceptionDescription, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::ExceptionDescription *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::ExceptionDescription, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::ExceptionDescription *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ExceptionDescription, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::ExceptionDescription *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::ExceptionDescription *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::ExceptionDescription *&, _tao_elem); + _tao_elem = 0; + return 0; + } + ACE_ENDTRY; + return 0; +} + +void operator<<= (CORBA::Any &_tao_any, CORBA::AttributeMode _tao_elem) +{ + CORBA::AttributeMode *_tao_any_val; + ACE_NEW (_tao_any_val, CORBA::AttributeMode (_tao_elem)); + if (!_tao_any_val) return; + ACE_TRY_NEW_ENV + { + TAO_OutputCDR stream; + stream << *_tao_any_val; + _tao_any._tao_replace ( + CORBA::_tc_AttributeMode, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY { // free allocated storage - delete _any_val; + delete _tao_any_val; } ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA::AttributeMode &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AttributeMode &_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_AttributeMode, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_AttributeMode, 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.decode (CORBA::_tc_AttributeMode, &_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) + { return 1; - ACE_TRY_CHECK; + } } ACE_CATCHANY { @@ -16249,18 +18374,33 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA::AttributeMode &_ta return 0; } -CORBA_AttributeDef_ptr (*_TAO_collocation_CORBA_AttributeDef_Stub_Factory_function_pointer) ( - CORBA_Object_ptr obj +CORBA::AttributeDef_ptr (*_TAO_collocation_CORBA_AttributeDef_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj ) = 0; -void operator<<= (CORBA_Any &_tao_any, CORBA_AttributeDef_ptr _tao_elem) +void operator<<= (CORBA::Any &_tao_any, CORBA::AttributeDef_ptr _tao_elem) { - CORBA_Object_ptr *_tao_obj_ptr = 0; + CORBA::Object_ptr *_tao_obj_ptr = 0; ACE_TRY_NEW_ENV { - ACE_NEW (_tao_obj_ptr, CORBA_Object_ptr); - *_tao_obj_ptr = CORBA_AttributeDef::_duplicate (_tao_elem); - _tao_any.replace (CORBA::_tc_AttributeDef, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); + *_tao_obj_ptr = CORBA::AttributeDef::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_AttributeDef, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -16269,56 +18409,81 @@ void operator<<= (CORBA_Any &_tao_any, CORBA_AttributeDef_ptr _tao_elem) ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_AttributeDef_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AttributeDef_ptr &_tao_elem) { - CORBA_Object_ptr *tmp = 0; + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { - _tao_elem = CORBA_AttributeDef::_nil (); + _tao_elem = CORBA::AttributeDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_AttributeDef, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_AttributeDef, 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; - ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0); - if (stream.decode (CORBA::_tc_AttributeDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - _tao_elem = CORBA_AttributeDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); + 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::AttributeDef::_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 (CORBA::_tc_AttributeDef, tmp, 1, ACE_TRY_ENV); + *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_AttributeDef, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = CORBA::AttributeDef::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = CORBA::AttributeDef::_nil (); return 0; } -#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) - template class TAO_Object_Field_T<CORBA_AttributeDef,CORBA_AttributeDef_var>; -template class TAO_Object_Manager<CORBA_AttributeDef,CORBA_AttributeDef_var>; +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Field_T<CORBA::AttributeDef,CORBA::AttributeDef_var>; + template class TAO_Object_Manager<CORBA::AttributeDef,CORBA::AttributeDef_var>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) -# pragma instantiate TAO_Object_Field_T<CORBA_AttributeDef,CORBA_AttributeDef_var> -# pragma instantiate TAO_Object_Manager<CORBA_AttributeDef,CORBA_AttributeDef_var> +# pragma instantiate TAO_Object_Field_T<CORBA::AttributeDef,CORBA::AttributeDef_var> +# pragma instantiate TAO_Object_Manager<CORBA::AttributeDef,CORBA::AttributeDef_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ -void operator<<= (CORBA_Any &_tao_any, const CORBA_AttributeDescription &_tao_elem) // copying +void operator<<= (CORBA::Any &_tao_any, const CORBA::AttributeDescription &_tao_elem) // copying { - CORBA_AttributeDescription *_any_val; - ACE_NEW (_any_val, CORBA_AttributeDescription (_tao_elem)); + CORBA::AttributeDescription *_any_val = 0; + ACE_NEW (_any_val, CORBA::AttributeDescription (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_AttributeDescription, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + CORBA::_tc_AttributeDescription, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -16328,87 +18493,177 @@ void operator<<= (CORBA_Any &_tao_any, const CORBA_AttributeDescription &_tao_el ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_AttributeDescription *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::AttributeDescription *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_AttributeDescription, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_AttributeDescription, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_AttributeDescription *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AttributeDescription *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_AttributeDescription, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_AttributeDescription, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_AttributeDescription *)_tao_any.value (); + _tao_elem = (CORBA::AttributeDescription *)_tao_any.value (); return 1; - } + } else { - ACE_NEW_RETURN (_tao_elem, CORBA_AttributeDescription, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_AttributeDescription, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::AttributeDescription, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA::_tc_AttributeDescription, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_AttributeDescription, + 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; } -void operator<<= (CORBA_Any &_tao_any, CORBA::OperationMode _tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::AttributeDescription *&_tao_elem) { - CORBA::OperationMode *_any_val; - ACE_NEW (_any_val, CORBA::OperationMode (_tao_elem)); - if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_OperationMode, _any_val, 1, ACE_TRY_ENV); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_AttributeDescription, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::AttributeDescription *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::AttributeDescription, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::AttributeDescription *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_AttributeDescription, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::AttributeDescription *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::AttributeDescription *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::AttributeDescription *&, _tao_elem); + _tao_elem = 0; + return 0; + } + ACE_ENDTRY; + return 0; +} + +void operator<<= (CORBA::Any &_tao_any, CORBA::OperationMode _tao_elem) +{ + CORBA::OperationMode *_tao_any_val; + ACE_NEW (_tao_any_val, CORBA::OperationMode (_tao_elem)); + if (!_tao_any_val) return; + ACE_TRY_NEW_ENV + { + TAO_OutputCDR stream; + stream << *_tao_any_val; + _tao_any._tao_replace ( + CORBA::_tc_OperationMode, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY { // free allocated storage - delete _any_val; + delete _tao_any_val; } ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA::OperationMode &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::OperationMode &_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_OperationMode, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_OperationMode, 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.decode (CORBA::_tc_OperationMode, &_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) + { return 1; - ACE_TRY_CHECK; + } } ACE_CATCHANY { @@ -16418,37 +18673,51 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA::OperationMode &_ta return 0; } -void operator<<= (CORBA_Any &_tao_any, CORBA::ParameterMode _tao_elem) +void operator<<= (CORBA::Any &_tao_any, CORBA::ParameterMode _tao_elem) { - CORBA::ParameterMode *_any_val; - ACE_NEW (_any_val, CORBA::ParameterMode (_tao_elem)); - if (!_any_val) return; + CORBA::ParameterMode *_tao_any_val; + ACE_NEW (_tao_any_val, CORBA::ParameterMode (_tao_elem)); + if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_ParameterMode, _any_val, 1, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_any_val; + _tao_any._tao_replace ( + CORBA::_tc_ParameterMode, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY { // free allocated storage - delete _any_val; + delete _tao_any_val; } ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA::ParameterMode &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ParameterMode &_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_ParameterMode, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_ParameterMode, 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.decode (CORBA::_tc_ParameterMode, &_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) + { return 1; - ACE_TRY_CHECK; + } } ACE_CATCHANY { @@ -16458,14 +18727,23 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA::ParameterMode &_ta return 0; } -void operator<<= (CORBA_Any &_tao_any, const CORBA_ParameterDescription &_tao_elem) // copying +void operator<<= (CORBA::Any &_tao_any, const CORBA::ParameterDescription &_tao_elem) // copying { - CORBA_ParameterDescription *_any_val; - ACE_NEW (_any_val, CORBA_ParameterDescription (_tao_elem)); + CORBA::ParameterDescription *_any_val = 0; + ACE_NEW (_any_val, CORBA::ParameterDescription (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_ParameterDescription, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + CORBA::_tc_ParameterDescription, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -16475,68 +18753,159 @@ void operator<<= (CORBA_Any &_tao_any, const CORBA_ParameterDescription &_tao_el ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_ParameterDescription *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::ParameterDescription *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_ParameterDescription, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_ParameterDescription, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ParameterDescription *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ParameterDescription *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_ParameterDescription, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_ParameterDescription, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_ParameterDescription *)_tao_any.value (); + _tao_elem = (CORBA::ParameterDescription *)_tao_any.value (); return 1; - } + } else { - ACE_NEW_RETURN (_tao_elem, CORBA_ParameterDescription, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_ParameterDescription, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::ParameterDescription, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA::_tc_ParameterDescription, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ParameterDescription, + 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 CORBA::ParameterDescription *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_ParameterDescription, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::ParameterDescription *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::ParameterDescription, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::ParameterDescription *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ParameterDescription, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::ParameterDescription *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::ParameterDescription *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::ParameterDescription *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; } void operator<<= ( - CORBA_Any &_tao_any, - const CORBA_ParDescriptionSeq &_tao_elem + CORBA::Any &_tao_any, + const CORBA::ParDescriptionSeq &_tao_elem ) // copying { - CORBA_ParDescriptionSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA_ParDescriptionSeq (_tao_elem)); + CORBA::ParDescriptionSeq *_tao_any_val; + ACE_NEW (_tao_any_val, CORBA::ParDescriptionSeq (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_ParDescriptionSeq, _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 ( + CORBA::_tc_ParDescriptionSeq, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_any_val; + } } ACE_CATCHANY { @@ -16545,68 +18914,159 @@ void operator<<= ( ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_ParDescriptionSeq *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::ParDescriptionSeq *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_ParDescriptionSeq, _tao_elem, 0, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_ParDescriptionSeq, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ParDescriptionSeq *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ParDescriptionSeq *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_ParDescriptionSeq, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_ParDescriptionSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_ParDescriptionSeq *)_tao_any.value (); + _tao_elem = (CORBA::ParDescriptionSeq *)_tao_any.value (); return 1; } else { - ACE_NEW_RETURN (_tao_elem, CORBA_ParDescriptionSeq, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_ParDescriptionSeq, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::ParDescriptionSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA::_tc_ParDescriptionSeq, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ParDescriptionSeq, + 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 CORBA::ParDescriptionSeq *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_ParDescriptionSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::ParDescriptionSeq *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::ParDescriptionSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::ParDescriptionSeq *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ParDescriptionSeq, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::ParDescriptionSeq *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::ParDescriptionSeq *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::ParDescriptionSeq *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; } void operator<<= ( - CORBA_Any &_tao_any, - const CORBA_ContextIdSeq &_tao_elem + CORBA::Any &_tao_any, + const CORBA::ContextIdSeq &_tao_elem ) // copying { - CORBA_ContextIdSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA_ContextIdSeq (_tao_elem)); + CORBA::ContextIdSeq *_tao_any_val; + ACE_NEW (_tao_any_val, CORBA::ContextIdSeq (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_ContextIdSeq, _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 ( + CORBA::_tc_ContextIdSeq, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_any_val; + } } ACE_CATCHANY { @@ -16615,68 +19075,159 @@ void operator<<= ( ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_ContextIdSeq *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::ContextIdSeq *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_ContextIdSeq, _tao_elem, 0, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_ContextIdSeq, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ContextIdSeq *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ContextIdSeq *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_ContextIdSeq, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_ContextIdSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_ContextIdSeq *)_tao_any.value (); + _tao_elem = (CORBA::ContextIdSeq *)_tao_any.value (); return 1; } else { - ACE_NEW_RETURN (_tao_elem, CORBA_ContextIdSeq, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_ContextIdSeq, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::ContextIdSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA::_tc_ContextIdSeq, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ContextIdSeq, + 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 CORBA::ContextIdSeq *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_ContextIdSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::ContextIdSeq *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::ContextIdSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::ContextIdSeq *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ContextIdSeq, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::ContextIdSeq *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::ContextIdSeq *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::ContextIdSeq *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; } void operator<<= ( - CORBA_Any &_tao_any, - const CORBA_ExceptionDefSeq &_tao_elem + CORBA::Any &_tao_any, + const CORBA::ExceptionDefSeq &_tao_elem ) // copying { - CORBA_ExceptionDefSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA_ExceptionDefSeq (_tao_elem)); + CORBA::ExceptionDefSeq *_tao_any_val; + ACE_NEW (_tao_any_val, CORBA::ExceptionDefSeq (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_ExceptionDefSeq, _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 ( + CORBA::_tc_ExceptionDefSeq, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_any_val; + } } ACE_CATCHANY { @@ -16685,68 +19236,159 @@ void operator<<= ( ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_ExceptionDefSeq *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::ExceptionDefSeq *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_ExceptionDefSeq, _tao_elem, 0, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_ExceptionDefSeq, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ExceptionDefSeq *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ExceptionDefSeq *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_ExceptionDefSeq, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_ExceptionDefSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_ExceptionDefSeq *)_tao_any.value (); + _tao_elem = (CORBA::ExceptionDefSeq *)_tao_any.value (); return 1; } else { - ACE_NEW_RETURN (_tao_elem, CORBA_ExceptionDefSeq, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_ExceptionDefSeq, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::ExceptionDefSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA::_tc_ExceptionDefSeq, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ExceptionDefSeq, + 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 CORBA::ExceptionDefSeq *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_ExceptionDefSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::ExceptionDefSeq *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::ExceptionDefSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::ExceptionDefSeq *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ExceptionDefSeq, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::ExceptionDefSeq *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::ExceptionDefSeq *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::ExceptionDefSeq *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; } void operator<<= ( - CORBA_Any &_tao_any, - const CORBA_ExcDescriptionSeq &_tao_elem + CORBA::Any &_tao_any, + const CORBA::ExcDescriptionSeq &_tao_elem ) // copying { - CORBA_ExcDescriptionSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA_ExcDescriptionSeq (_tao_elem)); + CORBA::ExcDescriptionSeq *_tao_any_val; + ACE_NEW (_tao_any_val, CORBA::ExcDescriptionSeq (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_ExcDescriptionSeq, _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 ( + CORBA::_tc_ExcDescriptionSeq, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_any_val; + } } ACE_CATCHANY { @@ -16755,68 +19397,159 @@ void operator<<= ( ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_ExcDescriptionSeq *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::ExcDescriptionSeq *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_ExcDescriptionSeq, _tao_elem, 0, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_ExcDescriptionSeq, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ExcDescriptionSeq *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ExcDescriptionSeq *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_ExcDescriptionSeq, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_ExcDescriptionSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_ExcDescriptionSeq *)_tao_any.value (); + _tao_elem = (CORBA::ExcDescriptionSeq *)_tao_any.value (); return 1; } else { - ACE_NEW_RETURN (_tao_elem, CORBA_ExcDescriptionSeq, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_ExcDescriptionSeq, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::ExcDescriptionSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA::_tc_ExcDescriptionSeq, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ExcDescriptionSeq, + 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_OperationDef_ptr (*_TAO_collocation_CORBA_OperationDef_Stub_Factory_function_pointer) ( - CORBA_Object_ptr obj - ) = 0; -void operator<<= (CORBA_Any &_tao_any, CORBA_OperationDef_ptr _tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ExcDescriptionSeq *&_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_OperationDef::_duplicate (_tao_elem); - _tao_any.replace (CORBA::_tc_OperationDef, _tao_obj_ptr, 1, ACE_TRY_ENV); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_ExcDescriptionSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::ExcDescriptionSeq *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::ExcDescriptionSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::ExcDescriptionSeq *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ExcDescriptionSeq, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::ExcDescriptionSeq *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::ExcDescriptionSeq *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::ExcDescriptionSeq *&, _tao_elem); + _tao_elem = 0; + return 0; + } + ACE_ENDTRY; + return 0; +} + +CORBA::OperationDef_ptr (*_TAO_collocation_CORBA_OperationDef_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj + ) = 0; +void operator<<= (CORBA::Any &_tao_any, CORBA::OperationDef_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::OperationDef::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_OperationDef, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -16825,56 +19558,81 @@ void operator<<= (CORBA_Any &_tao_any, CORBA_OperationDef_ptr _tao_elem) ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_OperationDef_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::OperationDef_ptr &_tao_elem) { - CORBA_Object_ptr *tmp = 0; + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { - _tao_elem = CORBA_OperationDef::_nil (); + _tao_elem = CORBA::OperationDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_OperationDef, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_OperationDef, 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; - ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0); - if (stream.decode (CORBA::_tc_OperationDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - _tao_elem = CORBA_OperationDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); + 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::OperationDef::_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 (CORBA::_tc_OperationDef, tmp, 1, ACE_TRY_ENV); + *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_OperationDef, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = CORBA::OperationDef::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = CORBA::OperationDef::_nil (); return 0; } -#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) - template class TAO_Object_Field_T<CORBA_OperationDef,CORBA_OperationDef_var>; -template class TAO_Object_Manager<CORBA_OperationDef,CORBA_OperationDef_var>; +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Field_T<CORBA::OperationDef,CORBA::OperationDef_var>; + template class TAO_Object_Manager<CORBA::OperationDef,CORBA::OperationDef_var>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) -# pragma instantiate TAO_Object_Field_T<CORBA_OperationDef,CORBA_OperationDef_var> -# pragma instantiate TAO_Object_Manager<CORBA_OperationDef,CORBA_OperationDef_var> +# pragma instantiate TAO_Object_Field_T<CORBA::OperationDef,CORBA::OperationDef_var> +# pragma instantiate TAO_Object_Manager<CORBA::OperationDef,CORBA::OperationDef_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ -void operator<<= (CORBA_Any &_tao_any, const CORBA_OperationDescription &_tao_elem) // copying +void operator<<= (CORBA::Any &_tao_any, const CORBA::OperationDescription &_tao_elem) // copying { - CORBA_OperationDescription *_any_val; - ACE_NEW (_any_val, CORBA_OperationDescription (_tao_elem)); + CORBA::OperationDescription *_any_val = 0; + ACE_NEW (_any_val, CORBA::OperationDescription (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_OperationDescription, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + CORBA::_tc_OperationDescription, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -16884,68 +19642,159 @@ void operator<<= (CORBA_Any &_tao_any, const CORBA_OperationDescription &_tao_el ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_OperationDescription *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::OperationDescription *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_OperationDescription, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_OperationDescription, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_OperationDescription *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::OperationDescription *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_OperationDescription, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_OperationDescription, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_OperationDescription *)_tao_any.value (); + _tao_elem = (CORBA::OperationDescription *)_tao_any.value (); return 1; - } + } else { - ACE_NEW_RETURN (_tao_elem, CORBA_OperationDescription, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_OperationDescription, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::OperationDescription, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA::_tc_OperationDescription, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_OperationDescription, + 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 CORBA::OperationDescription *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_OperationDescription, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::OperationDescription *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::OperationDescription, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::OperationDescription *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_OperationDescription, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::OperationDescription *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::OperationDescription *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::OperationDescription *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; } void operator<<= ( - CORBA_Any &_tao_any, - const CORBA_RepositoryIdSeq &_tao_elem + CORBA::Any &_tao_any, + const CORBA::RepositoryIdSeq &_tao_elem ) // copying { - CORBA_RepositoryIdSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA_RepositoryIdSeq (_tao_elem)); + CORBA::RepositoryIdSeq *_tao_any_val; + ACE_NEW (_tao_any_val, CORBA::RepositoryIdSeq (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_RepositoryIdSeq, _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 ( + CORBA::_tc_RepositoryIdSeq, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_any_val; + } } ACE_CATCHANY { @@ -16954,68 +19803,159 @@ void operator<<= ( ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_RepositoryIdSeq *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::RepositoryIdSeq *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_RepositoryIdSeq, _tao_elem, 0, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_RepositoryIdSeq, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_RepositoryIdSeq *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::RepositoryIdSeq *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_RepositoryIdSeq, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_RepositoryIdSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_RepositoryIdSeq *)_tao_any.value (); + _tao_elem = (CORBA::RepositoryIdSeq *)_tao_any.value (); return 1; } else { - ACE_NEW_RETURN (_tao_elem, CORBA_RepositoryIdSeq, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_RepositoryIdSeq, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::RepositoryIdSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA::_tc_RepositoryIdSeq, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_RepositoryIdSeq, + 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 CORBA::RepositoryIdSeq *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_RepositoryIdSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::RepositoryIdSeq *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::RepositoryIdSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::RepositoryIdSeq *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_RepositoryIdSeq, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::RepositoryIdSeq *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::RepositoryIdSeq *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::RepositoryIdSeq *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; } void operator<<= ( - CORBA_Any &_tao_any, - const CORBA_OpDescriptionSeq &_tao_elem + CORBA::Any &_tao_any, + const CORBA::OpDescriptionSeq &_tao_elem ) // copying { - CORBA_OpDescriptionSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA_OpDescriptionSeq (_tao_elem)); + CORBA::OpDescriptionSeq *_tao_any_val; + ACE_NEW (_tao_any_val, CORBA::OpDescriptionSeq (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_OpDescriptionSeq, _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 ( + CORBA::_tc_OpDescriptionSeq, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_any_val; + } } ACE_CATCHANY { @@ -17024,68 +19964,159 @@ void operator<<= ( ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_OpDescriptionSeq *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::OpDescriptionSeq *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_OpDescriptionSeq, _tao_elem, 0, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_OpDescriptionSeq, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_OpDescriptionSeq *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::OpDescriptionSeq *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_OpDescriptionSeq, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_OpDescriptionSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_OpDescriptionSeq *)_tao_any.value (); + _tao_elem = (CORBA::OpDescriptionSeq *)_tao_any.value (); return 1; } else { - ACE_NEW_RETURN (_tao_elem, CORBA_OpDescriptionSeq, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_OpDescriptionSeq, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::OpDescriptionSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA::_tc_OpDescriptionSeq, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_OpDescriptionSeq, + 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 CORBA::OpDescriptionSeq *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_OpDescriptionSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::OpDescriptionSeq *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::OpDescriptionSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::OpDescriptionSeq *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_OpDescriptionSeq, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::OpDescriptionSeq *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::OpDescriptionSeq *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::OpDescriptionSeq *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; } void operator<<= ( - CORBA_Any &_tao_any, - const CORBA_AttrDescriptionSeq &_tao_elem + CORBA::Any &_tao_any, + const CORBA::AttrDescriptionSeq &_tao_elem ) // copying { - CORBA_AttrDescriptionSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA_AttrDescriptionSeq (_tao_elem)); + CORBA::AttrDescriptionSeq *_tao_any_val; + ACE_NEW (_tao_any_val, CORBA::AttrDescriptionSeq (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_AttrDescriptionSeq, _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 ( + CORBA::_tc_AttrDescriptionSeq, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_any_val; + } } ACE_CATCHANY { @@ -17094,68 +20125,159 @@ void operator<<= ( ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_AttrDescriptionSeq *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::AttrDescriptionSeq *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_AttrDescriptionSeq, _tao_elem, 0, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_AttrDescriptionSeq, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_AttrDescriptionSeq *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AttrDescriptionSeq *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_AttrDescriptionSeq, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_AttrDescriptionSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_AttrDescriptionSeq *)_tao_any.value (); + _tao_elem = (CORBA::AttrDescriptionSeq *)_tao_any.value (); return 1; } else { - ACE_NEW_RETURN (_tao_elem, CORBA_AttrDescriptionSeq, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_AttrDescriptionSeq, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::AttrDescriptionSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA::_tc_AttrDescriptionSeq, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_AttrDescriptionSeq, + 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_InterfaceDef_ptr (*_TAO_collocation_CORBA_InterfaceDef_Stub_Factory_function_pointer) ( - CORBA_Object_ptr obj - ) = 0; -void operator<<= (CORBA_Any &_tao_any, CORBA_InterfaceDef_ptr _tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::AttrDescriptionSeq *&_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_InterfaceDef::_duplicate (_tao_elem); - _tao_any.replace (CORBA::_tc_InterfaceDef, _tao_obj_ptr, 1, ACE_TRY_ENV); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_AttrDescriptionSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::AttrDescriptionSeq *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::AttrDescriptionSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::AttrDescriptionSeq *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_AttrDescriptionSeq, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::AttrDescriptionSeq *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::AttrDescriptionSeq *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::AttrDescriptionSeq *&, _tao_elem); + _tao_elem = 0; + return 0; + } + ACE_ENDTRY; + return 0; +} + +CORBA::InterfaceDef_ptr (*_TAO_collocation_CORBA_InterfaceDef_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj + ) = 0; +void operator<<= (CORBA::Any &_tao_any, CORBA::InterfaceDef_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::InterfaceDef::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_InterfaceDef, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -17164,56 +20286,81 @@ void operator<<= (CORBA_Any &_tao_any, CORBA_InterfaceDef_ptr _tao_elem) ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_InterfaceDef_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InterfaceDef_ptr &_tao_elem) { - CORBA_Object_ptr *tmp = 0; + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { - _tao_elem = CORBA_InterfaceDef::_nil (); + _tao_elem = CORBA::InterfaceDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_InterfaceDef, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_InterfaceDef, 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; - ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0); - if (stream.decode (CORBA::_tc_InterfaceDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - _tao_elem = CORBA_InterfaceDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); + 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::InterfaceDef::_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 (CORBA::_tc_InterfaceDef, tmp, 1, ACE_TRY_ENV); + *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_InterfaceDef, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = CORBA::InterfaceDef::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = CORBA::InterfaceDef::_nil (); return 0; } -#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) - template class TAO_Object_Field_T<CORBA_InterfaceDef,CORBA_InterfaceDef_var>; -template class TAO_Object_Manager<CORBA_InterfaceDef,CORBA_InterfaceDef_var>; +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Field_T<CORBA::InterfaceDef,CORBA::InterfaceDef_var>; + template class TAO_Object_Manager<CORBA::InterfaceDef,CORBA::InterfaceDef_var>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) -# pragma instantiate TAO_Object_Field_T<CORBA_InterfaceDef,CORBA_InterfaceDef_var> -# pragma instantiate TAO_Object_Manager<CORBA_InterfaceDef,CORBA_InterfaceDef_var> +# pragma instantiate TAO_Object_Field_T<CORBA::InterfaceDef,CORBA::InterfaceDef_var> +# pragma instantiate TAO_Object_Manager<CORBA::InterfaceDef,CORBA::InterfaceDef_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ -void operator<<= (CORBA_Any &_tao_any, const CORBA_InterfaceDef::FullInterfaceDescription &_tao_elem) // copying +void operator<<= (CORBA::Any &_tao_any, const CORBA::InterfaceDef::FullInterfaceDescription &_tao_elem) // copying { - CORBA_InterfaceDef::FullInterfaceDescription *_any_val; - ACE_NEW (_any_val, CORBA_InterfaceDef::FullInterfaceDescription (_tao_elem)); + CORBA::InterfaceDef::FullInterfaceDescription *_any_val = 0; + ACE_NEW (_any_val, CORBA::InterfaceDef::FullInterfaceDescription (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA_InterfaceDef::_tc_FullInterfaceDescription, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + CORBA::InterfaceDef::_tc_FullInterfaceDescription, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -17223,64 +20370,149 @@ void operator<<= (CORBA_Any &_tao_any, const CORBA_InterfaceDef::FullInterfaceDe ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_InterfaceDef::FullInterfaceDescription *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::InterfaceDef::FullInterfaceDescription *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA_InterfaceDef::_tc_FullInterfaceDescription, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::InterfaceDef::_tc_FullInterfaceDescription, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_InterfaceDef::FullInterfaceDescription *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InterfaceDef::FullInterfaceDescription *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA_InterfaceDef::_tc_FullInterfaceDescription, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::InterfaceDef::_tc_FullInterfaceDescription, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_InterfaceDef::FullInterfaceDescription *)_tao_any.value (); + _tao_elem = (CORBA::InterfaceDef::FullInterfaceDescription *)_tao_any.value (); return 1; - } + } else { - ACE_NEW_RETURN (_tao_elem, CORBA_InterfaceDef::FullInterfaceDescription, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA_InterfaceDef::_tc_FullInterfaceDescription, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::InterfaceDef::FullInterfaceDescription, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA_InterfaceDef::_tc_FullInterfaceDescription, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::InterfaceDef::_tc_FullInterfaceDescription, + 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 CORBA::InterfaceDef::FullInterfaceDescription *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::InterfaceDef::_tc_FullInterfaceDescription, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::InterfaceDef::FullInterfaceDescription *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::InterfaceDef::FullInterfaceDescription, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::InterfaceDef::FullInterfaceDescription *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::InterfaceDef::_tc_FullInterfaceDescription, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::InterfaceDef::FullInterfaceDescription *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::InterfaceDef::FullInterfaceDescription *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::InterfaceDef::FullInterfaceDescription *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; } -void operator<<= (CORBA_Any &_tao_any, const CORBA_InterfaceDescription &_tao_elem) // copying +void operator<<= (CORBA::Any &_tao_any, const CORBA::InterfaceDescription &_tao_elem) // copying { - CORBA_InterfaceDescription *_any_val; - ACE_NEW (_any_val, CORBA_InterfaceDescription (_tao_elem)); + CORBA::InterfaceDescription *_any_val = 0; + ACE_NEW (_any_val, CORBA::InterfaceDescription (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_InterfaceDescription, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + CORBA::_tc_InterfaceDescription, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -17290,64 +20522,149 @@ void operator<<= (CORBA_Any &_tao_any, const CORBA_InterfaceDescription &_tao_el ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_InterfaceDescription *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::InterfaceDescription *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_InterfaceDescription, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_InterfaceDescription, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_InterfaceDescription *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InterfaceDescription *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_InterfaceDescription, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_InterfaceDescription, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_InterfaceDescription *)_tao_any.value (); + _tao_elem = (CORBA::InterfaceDescription *)_tao_any.value (); return 1; - } + } else { - ACE_NEW_RETURN (_tao_elem, CORBA_InterfaceDescription, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_InterfaceDescription, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::InterfaceDescription, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA::_tc_InterfaceDescription, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_InterfaceDescription, + 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 CORBA::InterfaceDescription *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_InterfaceDescription, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::InterfaceDescription *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::InterfaceDescription, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::InterfaceDescription *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_InterfaceDescription, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::InterfaceDescription *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::InterfaceDescription *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::InterfaceDescription *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; } -void operator<<= (CORBA_Any &_tao_any, const CORBA_ValueMember &_tao_elem) // copying +void operator<<= (CORBA::Any &_tao_any, const CORBA::ValueMember &_tao_elem) // copying { - CORBA_ValueMember *_any_val; - ACE_NEW (_any_val, CORBA_ValueMember (_tao_elem)); + CORBA::ValueMember *_any_val = 0; + ACE_NEW (_any_val, CORBA::ValueMember (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_ValueMember, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + CORBA::_tc_ValueMember, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -17357,68 +20674,159 @@ void operator<<= (CORBA_Any &_tao_any, const CORBA_ValueMember &_tao_elem) // co ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_ValueMember *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::ValueMember *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_ValueMember, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_ValueMember, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ValueMember *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueMember *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_ValueMember, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_ValueMember, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_ValueMember *)_tao_any.value (); + _tao_elem = (CORBA::ValueMember *)_tao_any.value (); return 1; - } + } else { - ACE_NEW_RETURN (_tao_elem, CORBA_ValueMember, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_ValueMember, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::ValueMember, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA::_tc_ValueMember, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ValueMember, + 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 CORBA::ValueMember *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_ValueMember, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::ValueMember *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::ValueMember, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::ValueMember *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ValueMember, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::ValueMember *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::ValueMember *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::ValueMember *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; } void operator<<= ( - CORBA_Any &_tao_any, - const CORBA_ValueMemberSeq &_tao_elem + CORBA::Any &_tao_any, + const CORBA::ValueMemberSeq &_tao_elem ) // copying { - CORBA_ValueMemberSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA_ValueMemberSeq (_tao_elem)); + CORBA::ValueMemberSeq *_tao_any_val; + ACE_NEW (_tao_any_val, CORBA::ValueMemberSeq (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_ValueMemberSeq, _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 ( + CORBA::_tc_ValueMemberSeq, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_any_val; + } } ACE_CATCHANY { @@ -17427,68 +20835,159 @@ void operator<<= ( ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_ValueMemberSeq *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::ValueMemberSeq *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_ValueMemberSeq, _tao_elem, 0, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_ValueMemberSeq, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ValueMemberSeq *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueMemberSeq *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_ValueMemberSeq, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_ValueMemberSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_ValueMemberSeq *)_tao_any.value (); + _tao_elem = (CORBA::ValueMemberSeq *)_tao_any.value (); return 1; } else { - ACE_NEW_RETURN (_tao_elem, CORBA_ValueMemberSeq, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_ValueMemberSeq, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::ValueMemberSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA::_tc_ValueMemberSeq, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ValueMemberSeq, + 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_ValueMemberDef_ptr (*_TAO_collocation_CORBA_ValueMemberDef_Stub_Factory_function_pointer) ( - CORBA_Object_ptr obj - ) = 0; -void operator<<= (CORBA_Any &_tao_any, CORBA_ValueMemberDef_ptr _tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ValueMemberSeq *&_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_ValueMemberDef::_duplicate (_tao_elem); - _tao_any.replace (CORBA::_tc_ValueMemberDef, _tao_obj_ptr, 1, ACE_TRY_ENV); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_ValueMemberSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::ValueMemberSeq *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::ValueMemberSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::ValueMemberSeq *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ValueMemberSeq, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::ValueMemberSeq *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::ValueMemberSeq *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::ValueMemberSeq *&, _tao_elem); + _tao_elem = 0; + return 0; + } + ACE_ENDTRY; + return 0; +} + +CORBA::ValueMemberDef_ptr (*_TAO_collocation_CORBA_ValueMemberDef_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj + ) = 0; +void operator<<= (CORBA::Any &_tao_any, CORBA::ValueMemberDef_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::ValueMemberDef::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_ValueMemberDef, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -17497,60 +20996,91 @@ void operator<<= (CORBA_Any &_tao_any, CORBA_ValueMemberDef_ptr _tao_elem) ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ValueMemberDef_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueMemberDef_ptr &_tao_elem) { - CORBA_Object_ptr *tmp = 0; + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { - _tao_elem = CORBA_ValueMemberDef::_nil (); + _tao_elem = CORBA::ValueMemberDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_ValueMemberDef, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_ValueMemberDef, 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; - ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0); - if (stream.decode (CORBA::_tc_ValueMemberDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - _tao_elem = CORBA_ValueMemberDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); + 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::ValueMemberDef::_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 (CORBA::_tc_ValueMemberDef, tmp, 1, ACE_TRY_ENV); + *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ValueMemberDef, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = CORBA::ValueMemberDef::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = CORBA::ValueMemberDef::_nil (); return 0; } -#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) - template class TAO_Object_Field_T<CORBA_ValueMemberDef,CORBA_ValueMemberDef_var>; -template class TAO_Object_Manager<CORBA_ValueMemberDef,CORBA_ValueMemberDef_var>; +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Field_T<CORBA::ValueMemberDef,CORBA::ValueMemberDef_var>; + template class TAO_Object_Manager<CORBA::ValueMemberDef,CORBA::ValueMemberDef_var>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) -# pragma instantiate TAO_Object_Field_T<CORBA_ValueMemberDef,CORBA_ValueMemberDef_var> -# pragma instantiate TAO_Object_Manager<CORBA_ValueMemberDef,CORBA_ValueMemberDef_var> +# pragma instantiate TAO_Object_Field_T<CORBA::ValueMemberDef,CORBA::ValueMemberDef_var> +# pragma instantiate TAO_Object_Manager<CORBA::ValueMemberDef,CORBA::ValueMemberDef_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ -CORBA_ValueDef_ptr (*_TAO_collocation_CORBA_ValueDef_Stub_Factory_function_pointer) ( - CORBA_Object_ptr obj +CORBA::ValueDef_ptr (*_TAO_collocation_CORBA_ValueDef_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj ) = 0; -void operator<<= (CORBA_Any &_tao_any, CORBA_ValueDef_ptr _tao_elem) +void operator<<= (CORBA::Any &_tao_any, CORBA::ValueDef_ptr _tao_elem) { - CORBA_Object_ptr *_tao_obj_ptr = 0; + CORBA::Object_ptr *_tao_obj_ptr = 0; ACE_TRY_NEW_ENV { - ACE_NEW (_tao_obj_ptr, CORBA_Object_ptr); - *_tao_obj_ptr = CORBA_ValueDef::_duplicate (_tao_elem); - _tao_any.replace (CORBA::_tc_ValueDef, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); + *_tao_obj_ptr = CORBA::ValueDef::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_ValueDef, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -17559,56 +21089,81 @@ void operator<<= (CORBA_Any &_tao_any, CORBA_ValueDef_ptr _tao_elem) ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ValueDef_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueDef_ptr &_tao_elem) { - CORBA_Object_ptr *tmp = 0; + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { - _tao_elem = CORBA_ValueDef::_nil (); + _tao_elem = CORBA::ValueDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_ValueDef, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_ValueDef, 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; - ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0); - if (stream.decode (CORBA::_tc_ValueDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - _tao_elem = CORBA_ValueDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); + 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::ValueDef::_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 (CORBA::_tc_ValueDef, tmp, 1, ACE_TRY_ENV); + *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ValueDef, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = CORBA::ValueDef::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = CORBA::ValueDef::_nil (); return 0; } -#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) - template class TAO_Object_Field_T<CORBA_ValueDef,CORBA_ValueDef_var>; -template class TAO_Object_Manager<CORBA_ValueDef,CORBA_ValueDef_var>; +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Field_T<CORBA::ValueDef,CORBA::ValueDef_var>; + template class TAO_Object_Manager<CORBA::ValueDef,CORBA::ValueDef_var>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) -# pragma instantiate TAO_Object_Field_T<CORBA_ValueDef,CORBA_ValueDef_var> -# pragma instantiate TAO_Object_Manager<CORBA_ValueDef,CORBA_ValueDef_var> +# pragma instantiate TAO_Object_Field_T<CORBA::ValueDef,CORBA::ValueDef_var> +# pragma instantiate TAO_Object_Manager<CORBA::ValueDef,CORBA::ValueDef_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ -void operator<<= (CORBA_Any &_tao_any, const CORBA_ValueDef::FullValueDescription &_tao_elem) // copying +void operator<<= (CORBA::Any &_tao_any, const CORBA::ValueDef::FullValueDescription &_tao_elem) // copying { - CORBA_ValueDef::FullValueDescription *_any_val; - ACE_NEW (_any_val, CORBA_ValueDef::FullValueDescription (_tao_elem)); + CORBA::ValueDef::FullValueDescription *_any_val = 0; + ACE_NEW (_any_val, CORBA::ValueDef::FullValueDescription (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA_ValueDef::_tc_FullValueDescription, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + CORBA::ValueDef::_tc_FullValueDescription, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -17618,64 +21173,149 @@ void operator<<= (CORBA_Any &_tao_any, const CORBA_ValueDef::FullValueDescriptio ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_ValueDef::FullValueDescription *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::ValueDef::FullValueDescription *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA_ValueDef::_tc_FullValueDescription, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::ValueDef::_tc_FullValueDescription, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ValueDef::FullValueDescription *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueDef::FullValueDescription *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA_ValueDef::_tc_FullValueDescription, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::ValueDef::_tc_FullValueDescription, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_ValueDef::FullValueDescription *)_tao_any.value (); + _tao_elem = (CORBA::ValueDef::FullValueDescription *)_tao_any.value (); return 1; - } + } else { - ACE_NEW_RETURN (_tao_elem, CORBA_ValueDef::FullValueDescription, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA_ValueDef::_tc_FullValueDescription, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::ValueDef::FullValueDescription, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA_ValueDef::_tc_FullValueDescription, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::ValueDef::_tc_FullValueDescription, + 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 CORBA::ValueDef::FullValueDescription *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::ValueDef::_tc_FullValueDescription, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::ValueDef::FullValueDescription *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::ValueDef::FullValueDescription, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::ValueDef::FullValueDescription *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::ValueDef::_tc_FullValueDescription, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::ValueDef::FullValueDescription *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::ValueDef::FullValueDescription *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::ValueDef::FullValueDescription *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; } -void operator<<= (CORBA_Any &_tao_any, const CORBA_ValueDescription &_tao_elem) // copying +void operator<<= (CORBA::Any &_tao_any, const CORBA::ValueDescription &_tao_elem) // copying { - CORBA_ValueDescription *_any_val; - ACE_NEW (_any_val, CORBA_ValueDescription (_tao_elem)); + CORBA::ValueDescription *_any_val = 0; + ACE_NEW (_any_val, CORBA::ValueDescription (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_ValueDescription, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + CORBA::_tc_ValueDescription, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -17685,68 +21325,159 @@ void operator<<= (CORBA_Any &_tao_any, const CORBA_ValueDescription &_tao_elem) ACE_ENDTRY; } -void operator<<= (CORBA_Any &_tao_any, CORBA_ValueDescription *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::ValueDescription *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_ValueDescription, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_ValueDescription, + 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; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ValueDescription *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueDescription *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_ValueDescription, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_ValueDescription, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_ValueDescription *)_tao_any.value (); + _tao_elem = (CORBA::ValueDescription *)_tao_any.value (); return 1; - } + } else { - ACE_NEW_RETURN (_tao_elem, CORBA_ValueDescription, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_ValueDescription, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::ValueDescription, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA_Any *)&_tao_any)->replace (CORBA::_tc_ValueDescription, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ValueDescription, + 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_ValueBoxDef_ptr (*_TAO_collocation_CORBA_ValueBoxDef_Stub_Factory_function_pointer) ( - CORBA_Object_ptr obj - ) = 0; -void operator<<= (CORBA_Any &_tao_any, CORBA_ValueBoxDef_ptr _tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ValueDescription *&_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_ValueBoxDef::_duplicate (_tao_elem); - _tao_any.replace (CORBA::_tc_ValueBoxDef, _tao_obj_ptr, 1, ACE_TRY_ENV); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_ValueDescription, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::ValueDescription *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::ValueDescription, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::ValueDescription *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ValueDescription, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::ValueDescription *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::ValueDescription *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::ValueDescription *&, _tao_elem); + _tao_elem = 0; + return 0; + } + ACE_ENDTRY; + return 0; +} + +CORBA::ValueBoxDef_ptr (*_TAO_collocation_CORBA_ValueBoxDef_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj + ) = 0; +void operator<<= (CORBA::Any &_tao_any, CORBA::ValueBoxDef_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::ValueBoxDef::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_ValueBoxDef, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -17755,50 +21486,64 @@ void operator<<= (CORBA_Any &_tao_any, CORBA_ValueBoxDef_ptr _tao_elem) ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ValueBoxDef_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueBoxDef_ptr &_tao_elem) { - CORBA_Object_ptr *tmp = 0; + CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { - _tao_elem = CORBA_ValueBoxDef::_nil (); + _tao_elem = CORBA::ValueBoxDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_ValueBoxDef, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_ValueBoxDef, 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; - ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0); - if (stream.decode (CORBA::_tc_ValueBoxDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - _tao_elem = CORBA_ValueBoxDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); + 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::ValueBoxDef::_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 (CORBA::_tc_ValueBoxDef, tmp, 1, ACE_TRY_ENV); + *tmp = (CORBA::Object_ptr) _tao_elem; // any owns the object + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ValueBoxDef, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = CORBA::ValueBoxDef::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = CORBA::ValueBoxDef::_nil (); return 0; } -#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) - template class TAO_Object_Field_T<CORBA_ValueBoxDef,CORBA_ValueBoxDef_var>; -template class TAO_Object_Manager<CORBA_ValueBoxDef,CORBA_ValueBoxDef_var>; +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Field_T<CORBA::ValueBoxDef,CORBA::ValueBoxDef_var>; + template class TAO_Object_Manager<CORBA::ValueBoxDef,CORBA::ValueBoxDef_var>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) -# pragma instantiate TAO_Object_Field_T<CORBA_ValueBoxDef,CORBA_ValueBoxDef_var> -# pragma instantiate TAO_Object_Manager<CORBA_ValueBoxDef,CORBA_ValueBoxDef_var> +# pragma instantiate TAO_Object_Field_T<CORBA::ValueBoxDef,CORBA::ValueBoxDef_var> +# pragma instantiate TAO_Object_Manager<CORBA::ValueBoxDef,CORBA::ValueBoxDef_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ - - CORBA::Boolean operator<< ( TAO_OutputCDR &strm, const CORBA_InterfaceDefSeq &_tao_sequence diff --git a/TAO/tao/InterfaceC.h b/TAO/tao/InterfaceC.h index 7814acad567..55a6523eb8b 100644 --- a/TAO/tao/InterfaceC.h +++ b/TAO/tao/InterfaceC.h @@ -1,9 +1,6 @@ /* -*- C++ -*- */ //$Id$ - - - // ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* // TAO and the TAO IDL Compiler have been developed by the Center for // Distributed Object Computing at Washington University, St. Louis. @@ -7996,253 +7993,473 @@ extern TAO_Export CORBA::Contained_ptr (*_TAO_collocation_CORBA_Contained_Stub_F CORBA::Object_ptr obj ); // Any operators for interface CORBA::Contained -TAO_Export void operator<<= (CORBA::Any &, CORBA::Contained_ptr); -CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::Contained *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::Contained::Description &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::Contained::Description*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::Contained::Description *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::InterfaceDefSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::InterfaceDefSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::InterfaceDefSeq *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::ValueDefSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::ValueDefSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ValueDefSeq *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::ContainedSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::ContainedSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ContainedSeq *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::StructMember &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::StructMember*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::StructMember *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::StructMemberSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::StructMemberSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::StructMemberSeq *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::Initializer &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::Initializer*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::Initializer *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::InitializerSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::InitializerSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::InitializerSeq *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::UnionMember &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::UnionMember*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::UnionMember *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::UnionMemberSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::UnionMemberSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::UnionMemberSeq *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::EnumMemberSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::EnumMemberSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::EnumMemberSeq *&); +TAO_Export void operator<<= (CORBA::Any &, + CORBA::Contained_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::Contained *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::Contained::Description &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::Contained::Description*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::Contained::Description *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::Contained::Description *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::InterfaceDefSeq &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::InterfaceDefSeq*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::InterfaceDefSeq *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::InterfaceDefSeq *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::ValueDefSeq &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::ValueDefSeq*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::ValueDefSeq *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::ValueDefSeq *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::ContainedSeq &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::ContainedSeq*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::ContainedSeq *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::ContainedSeq *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::StructMember &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::StructMember*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::StructMember *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::StructMember *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::StructMemberSeq &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::StructMemberSeq*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::StructMemberSeq *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::StructMemberSeq *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::Initializer &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::Initializer*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::Initializer *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::Initializer *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::InitializerSeq &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::InitializerSeq*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::InitializerSeq *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::InitializerSeq *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::UnionMember &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::UnionMember*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::UnionMember *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::UnionMember *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::UnionMemberSeq &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::UnionMemberSeq*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::UnionMemberSeq *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::UnionMemberSeq *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::EnumMemberSeq &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::EnumMemberSeq*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::EnumMemberSeq *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::EnumMemberSeq *&); extern TAO_Export CORBA::Container_ptr (*_TAO_collocation_CORBA_Container_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ); // Any operators for interface CORBA::Container -TAO_Export void operator<<= (CORBA::Any &, CORBA::Container_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::Container *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::Container::Description &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::Container::Description*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::Container::Description *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::Container::DescriptionSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::Container::DescriptionSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::Container::DescriptionSeq *&); +TAO_Export void operator<<= (CORBA::Any &, + CORBA::Container_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::Container *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::Container::Description &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::Container::Description*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::Container::Description *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::Container::Description *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::Container::DescriptionSeq &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::Container::DescriptionSeq*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::Container::DescriptionSeq *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::Container::DescriptionSeq *&); extern TAO_Export CORBA::IDLType_ptr (*_TAO_collocation_CORBA_IDLType_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ); // Any operators for interface CORBA::IDLType -TAO_Export void operator<<= (CORBA::Any &, CORBA::IDLType_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::IDLType *&); -TAO_Export void operator<<= (CORBA::Any &, CORBA::PrimitiveKind); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::PrimitiveKind &); +TAO_Export void operator<<= (CORBA::Any &, + CORBA::IDLType_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::IDLType *&); +TAO_Export void operator<<= (CORBA::Any &, + CORBA::PrimitiveKind); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::PrimitiveKind &); extern TAO_Export CORBA::Repository_ptr (*_TAO_collocation_CORBA_Repository_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ); // Any operators for interface CORBA::Repository -TAO_Export void operator<<= (CORBA::Any &, CORBA::Repository_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::Repository *&); +TAO_Export void operator<<= (CORBA::Any &, + CORBA::Repository_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::Repository *&); extern TAO_Export CORBA::ModuleDef_ptr (*_TAO_collocation_CORBA_ModuleDef_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ); // Any operators for interface CORBA::ModuleDef -TAO_Export void operator<<= (CORBA::Any &, CORBA::ModuleDef_ptr); -CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ModuleDef *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::ModuleDescription &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::ModuleDescription*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ModuleDescription *&); +TAO_Export void operator<<= (CORBA::Any &, + CORBA::ModuleDef_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::ModuleDef *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::ModuleDescription &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::ModuleDescription*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::ModuleDescription *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::ModuleDescription *&); extern TAO_Export CORBA::ConstantDef_ptr (*_TAO_collocation_CORBA_ConstantDef_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ); // Any operators for interface CORBA::ConstantDef -TAO_Export void operator<<= (CORBA::Any &, CORBA::ConstantDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ConstantDef *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::ConstantDescription &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::ConstantDescription*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ConstantDescription *&); +TAO_Export void operator<<= (CORBA::Any &, + CORBA::ConstantDef_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::ConstantDef *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::ConstantDescription &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::ConstantDescription*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::ConstantDescription *&); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::ConstantDescription *&); extern TAO_Export CORBA::TypedefDef_ptr (*_TAO_collocation_CORBA_TypedefDef_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ); // Any operators for interface CORBA::TypedefDef -TAO_Export void operator<<= (CORBA::Any &, CORBA::TypedefDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::TypedefDef *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::TypeDescription &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::TypeDescription*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::TypeDescription *&); +TAO_Export void operator<<= (CORBA::Any &, + CORBA::TypedefDef_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::TypedefDef *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::TypeDescription &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::TypeDescription*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::TypeDescription *&); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::TypeDescription *&); extern TAO_Export CORBA::StructDef_ptr (*_TAO_collocation_CORBA_StructDef_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ); // Any operators for interface CORBA::StructDef -TAO_Export void operator<<= (CORBA::Any &, CORBA::StructDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::StructDef *&); +TAO_Export void operator<<= (CORBA::Any &, + CORBA::StructDef_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::StructDef *&); extern TAO_Export CORBA::UnionDef_ptr (*_TAO_collocation_CORBA_UnionDef_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ); // Any operators for interface CORBA::UnionDef TAO_Export void operator<<= (CORBA::Any &, CORBA::UnionDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::UnionDef *&); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::UnionDef *&); extern TAO_Export CORBA::EnumDef_ptr (*_TAO_collocation_CORBA_EnumDef_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ); // Any operators for interface CORBA::EnumDef -TAO_Export void operator<<= (CORBA::Any &, CORBA::EnumDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::EnumDef *&); +TAO_Export void operator<<= (CORBA::Any &, + CORBA::EnumDef_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::EnumDef *&); extern TAO_Export CORBA::AliasDef_ptr (*_TAO_collocation_CORBA_AliasDef_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ); // Any operators for interface CORBA::AliasDef -TAO_Export void operator<<= (CORBA::Any &, CORBA::AliasDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::AliasDef *&); +TAO_Export void operator<<= (CORBA::Any &, + CORBA::AliasDef_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::AliasDef *&); extern TAO_Export CORBA::PrimitiveDef_ptr (*_TAO_collocation_CORBA_PrimitiveDef_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ); // Any operators for interface CORBA::PrimitiveDef -TAO_Export void operator<<= (CORBA::Any &, CORBA::PrimitiveDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::PrimitiveDef *&); +TAO_Export void operator<<= (CORBA::Any &, + CORBA::PrimitiveDef_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::PrimitiveDef *&); extern TAO_Export CORBA::StringDef_ptr (*_TAO_collocation_CORBA_StringDef_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ); // Any operators for interface CORBA::StringDef -TAO_Export void operator<<= (CORBA::Any &, CORBA::StringDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::StringDef *&); +TAO_Export void operator<<= (CORBA::Any &, + CORBA::StringDef_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::StringDef *&); extern TAO_Export CORBA::WstringDef_ptr (*_TAO_collocation_CORBA_WstringDef_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ); // Any operators for interface CORBA::WstringDef -TAO_Export void operator<<= (CORBA::Any &, CORBA::WstringDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::WstringDef *&); +TAO_Export void operator<<= (CORBA::Any &, + CORBA::WstringDef_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::WstringDef *&); extern TAO_Export CORBA::FixedDef_ptr (*_TAO_collocation_CORBA_FixedDef_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ); // Any operators for interface CORBA::FixedDef -TAO_Export void operator<<= (CORBA::Any &, CORBA::FixedDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::FixedDef *&); +TAO_Export void operator<<= (CORBA::Any &, + CORBA::FixedDef_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::FixedDef *&); extern TAO_Export CORBA::SequenceDef_ptr (*_TAO_collocation_CORBA_SequenceDef_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ); // Any operators for interface CORBA::SequenceDef -TAO_Export void operator<<= (CORBA::Any &, CORBA::SequenceDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::SequenceDef *&); +TAO_Export void operator<<= (CORBA::Any &, + CORBA::SequenceDef_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::SequenceDef *&); extern TAO_Export CORBA::ArrayDef_ptr (*_TAO_collocation_CORBA_ArrayDef_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ); // Any operators for interface CORBA::ArrayDef -TAO_Export void operator<<= (CORBA::Any &, CORBA::ArrayDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ArrayDef *&); +TAO_Export void operator<<= (CORBA::Any &, + CORBA::ArrayDef_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::ArrayDef *&); extern TAO_Export CORBA::ExceptionDef_ptr (*_TAO_collocation_CORBA_ExceptionDef_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ); // Any operators for interface CORBA::ExceptionDef -TAO_Export void operator<<= (CORBA::Any &, CORBA::ExceptionDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ExceptionDef *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::ExceptionDescription &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::ExceptionDescription*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ExceptionDescription *&); -TAO_Export void operator<<= (CORBA::Any &, CORBA::AttributeMode); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::AttributeMode &); +TAO_Export void operator<<= (CORBA::Any &, + CORBA::ExceptionDef_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::ExceptionDef *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::ExceptionDescription &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::ExceptionDescription*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::ExceptionDescription *&); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::ExceptionDescription *&); +TAO_Export void operator<<= (CORBA::Any &, + CORBA::AttributeMode); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::AttributeMode &); extern TAO_Export CORBA::AttributeDef_ptr (*_TAO_collocation_CORBA_AttributeDef_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ); // Any operators for interface CORBA::AttributeDef -TAO_Export void operator<<= (CORBA::Any &, CORBA::AttributeDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::AttributeDef *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::AttributeDescription &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::AttributeDescription*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::AttributeDescription *&); -TAO_Export void operator<<= (CORBA::Any &, CORBA::OperationMode); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::OperationMode &); -TAO_Export void operator<<= (CORBA::Any &, CORBA::ParameterMode); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ParameterMode &); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::ParameterDescription &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::ParameterDescription*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ParameterDescription *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::ParDescriptionSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::ParDescriptionSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ParDescriptionSeq *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::ContextIdSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::ContextIdSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ContextIdSeq *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::ExceptionDefSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::ExceptionDefSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ExceptionDefSeq *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::ExcDescriptionSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::ExcDescriptionSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ExcDescriptionSeq *&); +TAO_Export void operator<<= (CORBA::Any &, + CORBA::AttributeDef_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::AttributeDef *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::AttributeDescription &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::AttributeDescription*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::AttributeDescription *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::AttributeDescription *&); +TAO_Export void operator<<= (CORBA::Any &, + CORBA::OperationMode); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::OperationMode &); +TAO_Export void operator<<= (CORBA::Any &, + CORBA::ParameterMode); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::ParameterMode &); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::ParameterDescription &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::ParameterDescription*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::ParameterDescription *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::ParameterDescription *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::ParDescriptionSeq &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::ParDescriptionSeq*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::ParDescriptionSeq *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::ParDescriptionSeq *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::ContextIdSeq &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::ContextIdSeq*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::ContextIdSeq *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::ContextIdSeq *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::ExceptionDefSeq &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::ExceptionDefSeq*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::ExceptionDefSeq *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::ExceptionDefSeq *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::ExcDescriptionSeq &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::ExcDescriptionSeq*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::ExcDescriptionSeq *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::ExcDescriptionSeq *&); extern TAO_Export CORBA::OperationDef_ptr (*_TAO_collocation_CORBA_OperationDef_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ); // Any operators for interface CORBA::OperationDef -TAO_Export void operator<<= (CORBA::Any &, CORBA::OperationDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::OperationDef *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::OperationDescription &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::OperationDescription*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::OperationDescription *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::RepositoryIdSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::RepositoryIdSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::RepositoryIdSeq *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::OpDescriptionSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::OpDescriptionSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::OpDescriptionSeq *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::AttrDescriptionSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::AttrDescriptionSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::AttrDescriptionSeq *&); -extern TAO_Export CORBA::InterfaceDef_ptr (*_TAO_collocation_CORBA_InterfaceDef_Stub_Factory_function_pointer) ( +TAO_Export void operator<<= (CORBA::Any &, + CORBA::OperationDef_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::OperationDef *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::OperationDescription &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::OperationDescription*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::OperationDescription *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::OperationDescription *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::RepositoryIdSeq &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::RepositoryIdSeq*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::RepositoryIdSeq *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::RepositoryIdSeq *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::OpDescriptionSeq &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::OpDescriptionSeq*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::OpDescriptionSeq *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::OpDescriptionSeq *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::AttrDescriptionSeq &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::AttrDescriptionSeq*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::AttrDescriptionSeq *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::AttrDescriptionSeq *&); +extern CORBA::InterfaceDef_ptr (*_TAO_collocation_CORBA_InterfaceDef_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ); // Any operators for interface CORBA::InterfaceDef -TAO_Export void operator<<= (CORBA::Any &, CORBA::InterfaceDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::InterfaceDef *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::InterfaceDef::FullInterfaceDescription &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::InterfaceDef::FullInterfaceDescription*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::InterfaceDef::FullInterfaceDescription *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::InterfaceDescription &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::InterfaceDescription*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::InterfaceDescription *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::ValueMember &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::ValueMember*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ValueMember *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::ValueMemberSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::ValueMemberSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ValueMemberSeq *&); -extern TAO_Export CORBA::ValueMemberDef_ptr (*_TAO_collocation_CORBA_ValueMemberDef_Stub_Factory_function_pointer) ( +TAO_Export void operator<<= (CORBA::Any &, + CORBA::InterfaceDef_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::InterfaceDef *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::InterfaceDef::FullInterfaceDescription &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::InterfaceDef::FullInterfaceDescription*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::InterfaceDef::FullInterfaceDescription *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::InterfaceDef::FullInterfaceDescription *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::InterfaceDescription &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::InterfaceDescription*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::InterfaceDescription *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::InterfaceDescription *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::ValueMember &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::ValueMember*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::ValueMember *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::ValueMember *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::ValueMemberSeq &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::ValueMemberSeq*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::ValueMemberSeq *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::ValueMemberSeq *&); +extern CORBA::ValueMemberDef_ptr (*_TAO_collocation_CORBA_ValueMemberDef_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ); // Any operators for interface CORBA::ValueMemberDef -TAO_Export void operator<<= (CORBA::Any &, CORBA::ValueMemberDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ValueMemberDef *&); -extern TAO_Export CORBA::ValueDef_ptr (*_TAO_collocation_CORBA_ValueDef_Stub_Factory_function_pointer) ( +TAO_Export void operator<<= (CORBA::Any &, + CORBA::ValueMemberDef_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::ValueMemberDef *&); +extern CORBA::ValueDef_ptr (*_TAO_collocation_CORBA_ValueDef_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ); // Any operators for interface CORBA::ValueDef -TAO_Export void operator<<= (CORBA::Any &, CORBA::ValueDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ValueDef *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::ValueDef::FullValueDescription &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::ValueDef::FullValueDescription*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ValueDef::FullValueDescription *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA::ValueDescription &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA::ValueDescription*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ValueDescription *&); -extern TAO_Export CORBA::ValueBoxDef_ptr (*_TAO_collocation_CORBA_ValueBoxDef_Stub_Factory_function_pointer) ( +TAO_Export void operator<<= (CORBA::Any &, + CORBA::ValueDef_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::ValueDef *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::ValueDef::FullValueDescription &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::ValueDef::FullValueDescription*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::ValueDef::FullValueDescription *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::ValueDef::FullValueDescription *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA::ValueDescription &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA::ValueDescription*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::ValueDescription *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::ValueDescription *&); +extern CORBA::ValueBoxDef_ptr (*_TAO_collocation_CORBA_ValueBoxDef_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ); // Any operators for interface CORBA::ValueBoxDef -TAO_Export void operator<<= (CORBA::Any &, CORBA::ValueBoxDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ValueBoxDef *&); +TAO_Export void operator<<= (CORBA::Any &, + CORBA::ValueBoxDef_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::ValueBoxDef *&); #ifndef __ACE_INLINE__ diff --git a/TAO/tao/Invocation.cpp b/TAO/tao/Invocation.cpp index df5bb0a759f..fe11607cb03 100644 --- a/TAO/tao/Invocation.cpp +++ b/TAO/tao/Invocation.cpp @@ -1,7 +1,5 @@ // $Id$ - - #include "tao/Invocation.h" #include "tao/Stub.h" #include "tao/Principal.h" @@ -24,7 +22,6 @@ ACE_RCSID(tao, Invocation, "$Id$") - #if defined (ACE_ENABLE_TIMEPROBES) static const char *TAO_Invocation_Timeprobe_Description[] = @@ -310,7 +307,6 @@ TAO_GIOP_Invocation::prepare_header (CORBA::Octet response_flags, { // Then fill in the rest of the RequestHeader // - // The target specification mode this->target_spec_.target_specifier (this->profile_->object_key ()); @@ -593,11 +589,9 @@ TAO_GIOP_Twoway_Invocation::invoke (CORBA::ExceptionList &exceptions, const ACE_Message_Block* cdr = this->inp_stream ().start (); - CORBA_Any any (tcp, 0, this->inp_stream ().byte_order (), cdr); - CORBA_Exception *exception; ACE_NEW_THROW_EX (exception, @@ -684,9 +678,8 @@ TAO_GIOP_Twoway_Invocation::invoke (TAO_Exception_Data *excepts, CORBA::COMPLETED_YES), TAO_INVOKE_EXCEPTION); - this->inp_stream ().decode (exception->_type (), - exception, 0, - ACE_TRY_ENV); + exception->_tao_decode (this->inp_stream (), + ACE_TRY_ENV); ACE_CHECK_RETURN (TAO_INVOKE_EXCEPTION); if (TAO_debug_level > 5) @@ -828,15 +821,15 @@ TAO_GIOP_Twoway_Invocation::invoke_i (CORBA::Environment &ACE_TRY_ENV) switch (reply_status) { - case TAO_GIOP_NO_EXCEPTION: + case TAO_PLUGGABLE_MESSAGE_NO_EXCEPTION: // Return so that the STUB can demarshal the reply. return TAO_INVOKE_OK; - case TAO_GIOP_USER_EXCEPTION: + case TAO_PLUGGABLE_MESSAGE_USER_EXCEPTION: // Return so the exception can be handled. return TAO_INVOKE_EXCEPTION; - case TAO_GIOP_SYSTEM_EXCEPTION: + case TAO_PLUGGABLE_MESSAGE_SYSTEM_EXCEPTION: { // @@ Add the location macros for this exceptions... @@ -887,7 +880,7 @@ TAO_GIOP_Twoway_Invocation::invoke_i (CORBA::Environment &ACE_TRY_ENV) } // NOTREACHED. - case TAO_GIOP_LOCATION_FORWARD: + case TAO_PLUGGABLE_MESSAGE_LOCATION_FORWARD: // Handle the forwarding and return so the stub restarts the // request! return this->location_forward (this->inp_stream (), ACE_TRY_ENV); @@ -906,7 +899,6 @@ TAO_GIOP_Oneway_Invocation (TAO_Stub *stub, TAO_ORB_Core *orb_core) : TAO_GIOP_Invocation (stub, operation, opname_len, orb_core), sync_scope_ (TAO::SYNC_WITH_TRANSPORT) - { #if (TAO_HAS_CORBA_MESSAGING == 1) TAO_Sync_Scope_Policy *ssp = stub->sync_scope (); @@ -953,7 +945,6 @@ TAO_GIOP_Oneway_Invocation::invoke (CORBA::Environment &ACE_TRY_ENV) ACE_TRY_ENV); } - // Create this only if a reply is required. TAO_Synch_Reply_Dispatcher rd (this->orb_core_, this->op_details_.service_info ()); @@ -1037,11 +1028,11 @@ TAO_GIOP_Oneway_Invocation::invoke (CORBA::Environment &ACE_TRY_ENV) switch (reply_status) { - case TAO_GIOP_NO_EXCEPTION: + case TAO_PLUGGABLE_MESSAGE_NO_EXCEPTION: // Return so that the STUB can demarshal the reply. return TAO_INVOKE_OK; - case TAO_GIOP_USER_EXCEPTION: + case TAO_PLUGGABLE_MESSAGE_USER_EXCEPTION: { // Pull the exception from the stream. CORBA::String_var buf; @@ -1062,7 +1053,7 @@ TAO_GIOP_Oneway_Invocation::invoke (CORBA::Environment &ACE_TRY_ENV) TAO_INVOKE_EXCEPTION); } - case TAO_GIOP_SYSTEM_EXCEPTION: + case TAO_PLUGGABLE_MESSAGE_SYSTEM_EXCEPTION: { // @@ Add the location macros for these exceptions... @@ -1111,7 +1102,7 @@ TAO_GIOP_Oneway_Invocation::invoke (CORBA::Environment &ACE_TRY_ENV) return TAO_INVOKE_OK; } - case TAO_GIOP_LOCATION_FORWARD: + case TAO_PLUGGABLE_MESSAGE_LOCATION_FORWARD: // Handle the forwarding and return so the stub restarts the // request! return this->location_forward (rd.reply_cdr (), diff --git a/TAO/tao/Invocation.i b/TAO/tao/Invocation.i index 9cf44948984..9f210b5069c 100644 --- a/TAO/tao/Invocation.i +++ b/TAO/tao/Invocation.i @@ -1,6 +1,8 @@ // This may look like C, but it's really -*- C++ -*- // // $Id$ +// + ACE_INLINE IOP::ServiceContextList & TAO_GIOP_Invocation::service_info (void) { diff --git a/TAO/tao/Leader_Follower.cpp b/TAO/tao/Leader_Follower.cpp index ff3cb2fef0e..c49a2d2495c 100644 --- a/TAO/tao/Leader_Follower.cpp +++ b/TAO/tao/Leader_Follower.cpp @@ -1,6 +1,5 @@ // $Id$ - #include "tao/Leader_Follower.h" #include "tao/Resource_Factory.h" @@ -8,10 +7,8 @@ # include "tao/Leader_Follower.i" #endif /* ! __ACE_INLINE__ */ - ACE_RCSID(tao, Leader_Follower, "$Id$") - TAO_Leader_Follower::~TAO_Leader_Follower (void) { delete this->reactor_; diff --git a/TAO/tao/Leader_Follower.h b/TAO/tao/Leader_Follower.h index 2c75e012de2..5f496b7b2bf 100644 --- a/TAO/tao/Leader_Follower.h +++ b/TAO/tao/Leader_Follower.h @@ -1,7 +1,5 @@ - // $Id$ - // ============================================================================ // // = LIBRARY diff --git a/TAO/tao/Leader_Follower.i b/TAO/tao/Leader_Follower.i index 2e3431777d2..529ee24e4c0 100644 --- a/TAO/tao/Leader_Follower.i +++ b/TAO/tao/Leader_Follower.i @@ -1,7 +1,6 @@ // -*- C++ -*- // $Id$ - // **************************************************************** ACE_INLINE diff --git a/TAO/tao/Linear_Priority_Mapping.cpp b/TAO/tao/Linear_Priority_Mapping.cpp index d995fc7b2b9..27c346394d4 100644 --- a/TAO/tao/Linear_Priority_Mapping.cpp +++ b/TAO/tao/Linear_Priority_Mapping.cpp @@ -1,6 +1,5 @@ // $Id$ - #include "tao/orbconf.h" #if (TAO_HAS_RT_CORBA == 1) @@ -13,10 +12,8 @@ # include "tao/Linear_Priority_Mapping.i" #endif /* ! __ACE_INLINE__ */ - ACE_RCSID(tao, Linear_Priority_Mapping, "$Id$") - TAO_Linear_Priority_Mapping::TAO_Linear_Priority_Mapping (int policy) : policy_ (policy) { diff --git a/TAO/tao/Linear_Priority_Mapping.h b/TAO/tao/Linear_Priority_Mapping.h index 18032442610..242bc6f27ed 100644 --- a/TAO/tao/Linear_Priority_Mapping.h +++ b/TAO/tao/Linear_Priority_Mapping.h @@ -1,7 +1,5 @@ - // $Id$ - // ============================================================================ // // = LIBRARY diff --git a/TAO/tao/Makefile b/TAO/tao/Makefile index 2c639ced3e8..a2ad49f1c2b 100644 --- a/TAO/tao/Makefile +++ b/TAO/tao/Makefile @@ -32,7 +32,6 @@ PUB_HDRS = \ SHMIOP_Connector \ SHMIOP_Acceptor \ SHMIOP_Connect \ - GIOP \ Invocation \ operation_details \ Asynch_Invocation \ @@ -534,6 +533,8 @@ realclean: $(TAO_ROOT)/tao/Exception.i \ $(TAO_ROOT)/tao/Typecode.i \ $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Sequence.h \ $(TAO_ROOT)/tao/Managed_Types.h \ $(TAO_ROOT)/tao/Managed_Types.i \ @@ -545,8 +546,6 @@ realclean: $(TAO_ROOT)/tao/varout.i \ $(TAO_ROOT)/tao/varout.cpp \ $(TAO_ROOT)/tao/PolicyC.i \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/POAC.i \ $(TAO_ROOT)/tao/Key_Adapters.i \ $(TAO_ROOT)/tao/Server_Strategy_Factory.h \ @@ -652,6 +651,7 @@ realclean: $(TAO_ROOT)/tao/target_identifier.h \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ $(TAO_ROOT)/tao/Reply_Dispatcher.i \ @@ -802,6 +802,8 @@ realclean: $(TAO_ROOT)/tao/Exception.i \ $(TAO_ROOT)/tao/Typecode.i \ $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Sequence.h \ $(TAO_ROOT)/tao/Managed_Types.h \ $(TAO_ROOT)/tao/Managed_Types.i \ @@ -813,8 +815,6 @@ realclean: $(TAO_ROOT)/tao/varout.i \ $(TAO_ROOT)/tao/varout.cpp \ $(TAO_ROOT)/tao/PolicyC.i \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/POAC.i \ $(TAO_ROOT)/tao/Key_Adapters.i @@ -956,6 +956,8 @@ realclean: $(TAO_ROOT)/tao/Exception.i \ $(TAO_ROOT)/tao/Typecode.i \ $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Sequence.h \ $(TAO_ROOT)/tao/Managed_Types.h \ $(TAO_ROOT)/tao/Managed_Types.i \ @@ -967,8 +969,6 @@ realclean: $(TAO_ROOT)/tao/varout.i \ $(TAO_ROOT)/tao/varout.cpp \ $(TAO_ROOT)/tao/PolicyC.i \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/POAC.i \ $(TAO_ROOT)/tao/Key_Adapters.i \ $(TAO_ROOT)/tao/Server_Strategy_Factory.h \ @@ -1073,6 +1073,7 @@ realclean: $(TAO_ROOT)/tao/target_identifier.h \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ $(TAO_ROOT)/tao/Reply_Dispatcher.i \ @@ -1181,6 +1182,8 @@ realclean: $(TAO_ROOT)/tao/Exception.i \ $(TAO_ROOT)/tao/Typecode.i \ $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Sequence.h \ $(TAO_ROOT)/tao/Managed_Types.h \ $(TAO_ROOT)/tao/Managed_Types.i \ @@ -1192,8 +1195,6 @@ realclean: $(TAO_ROOT)/tao/varout.i \ $(TAO_ROOT)/tao/varout.cpp \ $(TAO_ROOT)/tao/PolicyC.i \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/POAC.i \ $(TAO_ROOT)/tao/POAS.h \ $(TAO_ROOT)/tao/Servant_Base.h \ @@ -1345,6 +1346,7 @@ realclean: $(TAO_ROOT)/tao/target_identifier.h \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ $(TAO_ROOT)/tao/Reply_Dispatcher.i \ @@ -1445,6 +1447,8 @@ realclean: $(TAO_ROOT)/tao/Exception.i \ $(TAO_ROOT)/tao/Typecode.i \ $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Sequence.h \ $(TAO_ROOT)/tao/Managed_Types.h \ $(TAO_ROOT)/tao/Managed_Types.i \ @@ -1456,8 +1460,6 @@ realclean: $(TAO_ROOT)/tao/varout.i \ $(TAO_ROOT)/tao/varout.cpp \ $(TAO_ROOT)/tao/PolicyC.i \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/POAC.i \ $(TAO_ROOT)/tao/Servant_Base.h \ $(TAO_ROOT)/tao/Servant_Base.i \ @@ -1645,6 +1647,8 @@ realclean: $(TAO_ROOT)/tao/Exception.i \ $(TAO_ROOT)/tao/Typecode.i \ $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Sequence.h \ $(TAO_ROOT)/tao/Managed_Types.h \ $(TAO_ROOT)/tao/Managed_Types.i \ @@ -1656,8 +1660,6 @@ realclean: $(TAO_ROOT)/tao/varout.i \ $(TAO_ROOT)/tao/varout.cpp \ $(TAO_ROOT)/tao/PolicyC.i \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/POAC.i \ $(TAO_ROOT)/tao/Servant_Base.h \ $(TAO_ROOT)/tao/Servant_Base.i \ @@ -1807,6 +1809,7 @@ realclean: $(TAO_ROOT)/tao/target_identifier.h \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ $(TAO_ROOT)/tao/Reply_Dispatcher.i \ @@ -1953,6 +1956,8 @@ realclean: $(TAO_ROOT)/tao/Exception.i \ $(TAO_ROOT)/tao/Typecode.i \ $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Sequence.h \ $(TAO_ROOT)/tao/Managed_Types.h \ $(TAO_ROOT)/tao/Managed_Types.i \ @@ -1964,8 +1969,6 @@ realclean: $(TAO_ROOT)/tao/varout.i \ $(TAO_ROOT)/tao/varout.cpp \ $(TAO_ROOT)/tao/PolicyC.i \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/POAC.i \ $(TAO_ROOT)/tao/Key_Adapters.i \ $(TAO_ROOT)/tao/Server_Strategy_Factory.h \ @@ -2066,6 +2069,8 @@ realclean: $(TAO_ROOT)/tao/Exception.i \ $(TAO_ROOT)/tao/Typecode.i \ $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Sequence.h \ $(TAO_ROOT)/tao/Managed_Types.h \ $(TAO_ROOT)/tao/Managed_Types.i \ @@ -2077,8 +2082,6 @@ realclean: $(TAO_ROOT)/tao/varout.i \ $(TAO_ROOT)/tao/varout.cpp \ $(TAO_ROOT)/tao/PolicyC.i \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/POAC.i \ $(TAO_ROOT)/tao/Servant_Base.i \ $(TAO_ROOT)/tao/Timeprobe.h \ @@ -2231,6 +2234,7 @@ realclean: $(TAO_ROOT)/tao/target_identifier.h \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ $(TAO_ROOT)/tao/Reply_Dispatcher.i \ @@ -2333,6 +2337,8 @@ realclean: $(TAO_ROOT)/tao/Exception.i \ $(TAO_ROOT)/tao/Typecode.i \ $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Sequence.h \ $(TAO_ROOT)/tao/Managed_Types.h \ $(TAO_ROOT)/tao/Managed_Types.i \ @@ -2344,8 +2350,6 @@ realclean: $(TAO_ROOT)/tao/varout.i \ $(TAO_ROOT)/tao/varout.cpp \ $(TAO_ROOT)/tao/PolicyC.i \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/POAC.i \ $(TAO_ROOT)/tao/Servant_Base.i \ $(TAO_ROOT)/tao/ORB.h \ @@ -2489,6 +2493,8 @@ realclean: $(TAO_ROOT)/tao/Exception.i \ $(TAO_ROOT)/tao/Typecode.i \ $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Sequence.h \ $(TAO_ROOT)/tao/Sequence.i \ $(TAO_ROOT)/tao/Sequence_T.h \ @@ -2498,8 +2504,6 @@ realclean: $(TAO_ROOT)/tao/varout.i \ $(TAO_ROOT)/tao/varout.cpp \ $(TAO_ROOT)/tao/PolicyC.i \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/POAC.i \ $(TAO_ROOT)/tao/Servant_Base.h \ $(TAO_ROOT)/tao/Servant_Base.i \ @@ -2647,6 +2651,7 @@ realclean: $(TAO_ROOT)/tao/target_identifier.h \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ $(TAO_ROOT)/tao/Reply_Dispatcher.i \ @@ -2748,6 +2753,8 @@ realclean: $(TAO_ROOT)/tao/Exception.i \ $(TAO_ROOT)/tao/Typecode.i \ $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Sequence.h \ $(TAO_ROOT)/tao/Sequence.i \ $(TAO_ROOT)/tao/Sequence_T.h \ @@ -2757,8 +2764,6 @@ realclean: $(TAO_ROOT)/tao/varout.i \ $(TAO_ROOT)/tao/varout.cpp \ $(TAO_ROOT)/tao/PolicyC.i \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/POAC.i \ $(TAO_ROOT)/tao/Servant_Base.h \ $(TAO_ROOT)/tao/Servant_Base.i \ @@ -2906,6 +2911,7 @@ realclean: $(TAO_ROOT)/tao/target_identifier.h \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ $(TAO_ROOT)/tao/Reply_Dispatcher.i \ @@ -3128,6 +3134,7 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ $(TAO_ROOT)/tao/Reply_Dispatcher.h \ @@ -4002,10 +4009,12 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ $(TAO_ROOT)/tao/operation_details.h \ $(TAO_ROOT)/tao/operation_details.i \ + $(TAO_ROOT)/tao/IIOP_Transport.i \ $(TAO_ROOT)/tao/IIOP_Connect.i \ $(TAO_ROOT)/tao/Acceptor_Impl.h \ $(TAO_ROOT)/tao/Acceptor_Impl.i \ @@ -4089,6 +4098,291 @@ realclean: $(ACE_ROOT)/ace/Cached_Connect_Strategy_T.i \ $(ACE_ROOT)/ace/Cached_Connect_Strategy_T.cpp +.obj/IIOP_Lite_Factory.o .obj/IIOP_Lite_Factory.so .shobj/IIOP_Lite_Factory.o .shobj/IIOP_Lite_Factory.so: IIOP_Lite_Factory.cpp \ + $(TAO_ROOT)/tao/IIOP_Lite_Factory.h \ + $(TAO_ROOT)/tao/Protocol_Factory.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.6.h \ + $(ACE_ROOT)/ace/config-sunos5.5.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies.i \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/SString.i \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Synch_Options.i \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor.i \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Strategies_T.i \ + $(ACE_ROOT)/ace/Strategies_T.cpp \ + $(ACE_ROOT)/ace/Service_Repository.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/Service_Repository.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.i \ + $(TAO_ROOT)/tao/Pluggable.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/try_macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/varout.h \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/varout.i \ + $(TAO_ROOT)/tao/varout.cpp \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/Pluggable.i \ + $(TAO_ROOT)/tao/IIOP_Acceptor.h \ + $(TAO_ROOT)/tao/IIOP_Connect.h \ + $(ACE_ROOT)/ace/Acceptor.h \ + $(ACE_ROOT)/ace/Svc_Handler.h \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Task.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Task_T.i \ + $(ACE_ROOT)/ace/Task_T.cpp \ + $(ACE_ROOT)/ace/Module.h \ + $(ACE_ROOT)/ace/Module.i \ + $(ACE_ROOT)/ace/Module.cpp \ + $(ACE_ROOT)/ace/Stream_Modules.h \ + $(ACE_ROOT)/ace/Stream_Modules.i \ + $(ACE_ROOT)/ace/Stream_Modules.cpp \ + $(ACE_ROOT)/ace/Svc_Handler.i \ + $(ACE_ROOT)/ace/Svc_Handler.cpp \ + $(ACE_ROOT)/ace/Dynamic.h \ + $(ACE_ROOT)/ace/Dynamic.i \ + $(ACE_ROOT)/ace/Acceptor.i \ + $(ACE_ROOT)/ace/Acceptor.cpp \ + $(ACE_ROOT)/ace/SOCK_Acceptor.h \ + $(ACE_ROOT)/ace/SOCK_Stream.h \ + $(ACE_ROOT)/ace/SOCK_IO.h \ + $(ACE_ROOT)/ace/SOCK.h \ + $(ACE_ROOT)/ace/Addr.h \ + $(ACE_ROOT)/ace/Addr.i \ + $(ACE_ROOT)/ace/IPC_SAP.h \ + $(ACE_ROOT)/ace/IPC_SAP.i \ + $(ACE_ROOT)/ace/QoS_Session.h \ + $(ACE_ROOT)/ace/INET_Addr.h \ + $(ACE_ROOT)/ace/INET_Addr.i \ + $(ACE_ROOT)/ace/SOCK.i \ + $(ACE_ROOT)/ace/SOCK_IO.i \ + $(ACE_ROOT)/ace/SOCK_Stream.i \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/SOCK_Acceptor.i \ + $(TAO_ROOT)/tao/Wait_Strategy.h \ + $(TAO_ROOT)/tao/IIOP_Transport.h \ + $(TAO_ROOT)/tao/GIOP_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging.h \ + $(TAO_ROOT)/tao/target_identifier.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/target_identifier.i \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ + $(TAO_ROOT)/tao/Pluggable_Messaging.i \ + $(TAO_ROOT)/tao/GIOP_Utils.i \ + $(TAO_ROOT)/tao/operation_details.h \ + $(TAO_ROOT)/tao/operation_details.i \ + $(TAO_ROOT)/tao/IIOP_Transport.i \ + $(TAO_ROOT)/tao/IIOP_Connect.i \ + $(TAO_ROOT)/tao/Acceptor_Impl.h \ + $(TAO_ROOT)/tao/Acceptor_Impl.i \ + $(TAO_ROOT)/tao/Acceptor_Impl.cpp \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/IOR_LookupTable.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/Services.i \ + $(TAO_ROOT)/tao/IORManipulation.h \ + $(TAO_ROOT)/tao/IORS.h \ + $(TAO_ROOT)/tao/IORC.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/IORC.i \ + $(TAO_ROOT)/tao/Servant_Base.h \ + $(TAO_ROOT)/tao/POAC.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/POAC.i \ + $(TAO_ROOT)/tao/Servant_Base.i \ + $(TAO_ROOT)/tao/IORS.i \ + $(TAO_ROOT)/tao/Interceptor.h \ + $(TAO_ROOT)/tao/InterceptorS.h \ + $(TAO_ROOT)/tao/InterceptorC.h \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/InterceptorC.i \ + $(TAO_ROOT)/tao/Interceptor.i \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/POA_CORBA.h \ + $(TAO_ROOT)/tao/DynAnyC.h \ + $(TAO_ROOT)/tao/DynAnyC.i \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/DomainC.i \ + $(TAO_ROOT)/tao/Policy_Manager.i \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(ACE_ROOT)/ace/Dynamic_Service.h \ + $(ACE_ROOT)/ace/Dynamic_Service.cpp \ + $(TAO_ROOT)/tao/Server_Strategy_Factory.h \ + $(TAO_ROOT)/tao/Connector_Registry.h \ + $(TAO_ROOT)/tao/Connector_Registry.i \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/IIOP_Acceptor.i \ + $(TAO_ROOT)/tao/IIOP_Connector.h \ + $(ACE_ROOT)/ace/Connector.h \ + $(ACE_ROOT)/ace/Connector.i \ + $(ACE_ROOT)/ace/Connector.cpp \ + $(ACE_ROOT)/ace/SOCK_Connector.h \ + $(ACE_ROOT)/ace/SOCK_Connector.i \ + $(ACE_ROOT)/ace/Cached_Connect_Strategy_T.h \ + $(ACE_ROOT)/ace/Hash_Cache_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Cache_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Pair_T.h \ + $(ACE_ROOT)/ace/Pair.h \ + $(ACE_ROOT)/ace/Pair.i \ + $(ACE_ROOT)/ace/Pair_T.i \ + $(ACE_ROOT)/ace/Pair_T.cpp \ + $(ACE_ROOT)/ace/Cache_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Cache_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Hash_Cache_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Hash_Cache_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Caching_Strategies_T.h \ + $(ACE_ROOT)/ace/Caching_Utility_T.h \ + $(ACE_ROOT)/ace/Cleanup_Strategies_T.h \ + $(ACE_ROOT)/ace/Cleanup_Strategies_T.i \ + $(ACE_ROOT)/ace/Cleanup_Strategies_T.cpp \ + $(ACE_ROOT)/ace/Caching_Utility_T.i \ + $(ACE_ROOT)/ace/Caching_Utility_T.cpp \ + $(ACE_ROOT)/ace/Caching_Strategies_T.i \ + $(ACE_ROOT)/ace/Caching_Strategies_T.cpp \ + $(ACE_ROOT)/ace/Cached_Connect_Strategy_T.i \ + $(ACE_ROOT)/ace/Cached_Connect_Strategy_T.cpp \ + $(ACE_ROOT)/ace/Get_Opt.h \ + $(ACE_ROOT)/ace/Get_Opt.i + .obj/IIOP_Profile.o .obj/IIOP_Profile.so .shobj/IIOP_Profile.o .shobj/IIOP_Profile.so: IIOP_Profile.cpp \ $(TAO_ROOT)/tao/IIOP_Profile.h \ $(TAO_ROOT)/tao/Profile.h \ @@ -4249,6 +4543,7 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ $(TAO_ROOT)/tao/ORB.h \ @@ -4319,6 +4614,7 @@ realclean: $(TAO_ROOT)/tao/IIOP_Transport.h \ $(TAO_ROOT)/tao/operation_details.h \ $(TAO_ROOT)/tao/operation_details.i \ + $(TAO_ROOT)/tao/IIOP_Transport.i \ $(TAO_ROOT)/tao/IIOP_Connect.i \ $(TAO_ROOT)/tao/ORB_Core.h \ $(TAO_ROOT)/tao/Policy_Manager.h \ @@ -4549,10 +4845,12 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ $(TAO_ROOT)/tao/operation_details.h \ $(TAO_ROOT)/tao/operation_details.i \ + $(TAO_ROOT)/tao/IIOP_Transport.i \ $(TAO_ROOT)/tao/IIOP_Connect.h \ $(ACE_ROOT)/ace/Acceptor.h \ $(ACE_ROOT)/ace/Svc_Handler.h \ @@ -4657,7 +4955,24 @@ realclean: $(TAO_ROOT)/tao/ORB_Core.i \ $(ACE_ROOT)/ace/Dynamic_Service.h \ $(ACE_ROOT)/ace/Dynamic_Service.cpp \ - $(TAO_ROOT)/tao/debug.h + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/GIOP_Message_Connectors.h \ + $(TAO_ROOT)/tao/GIOP_Message_Base.h \ + $(TAO_ROOT)/tao/GIOP_Message_Base.i \ + $(TAO_ROOT)/tao/GIOP_Message_Connectors.i \ + $(TAO_ROOT)/tao/GIOP_Message_Lite.h \ + $(TAO_ROOT)/tao/GIOP_Server_Request.h \ + $(TAO_ROOT)/tao/Server_Request.h \ + $(TAO_ROOT)/tao/Server_Request.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/GIOP_Server_Request.i \ + $(TAO_ROOT)/tao/GIOP_Assorted_Headers.h \ + $(TAO_ROOT)/tao/GIOPC.h \ + $(TAO_ROOT)/tao/Union.h \ + $(TAO_ROOT)/tao/GIOPC.i \ + $(TAO_ROOT)/tao/GIOP_Assorted_Headers.i \ + $(TAO_ROOT)/tao/GIOP_Message_Lite.i .obj/IIOP_Connector.o .obj/IIOP_Connector.so .shobj/IIOP_Connector.o .shobj/IIOP_Connector.so: IIOP_Connector.cpp \ $(TAO_ROOT)/tao/IIOP_Connector.h \ @@ -4859,10 +5174,12 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ $(TAO_ROOT)/tao/operation_details.h \ $(TAO_ROOT)/tao/operation_details.i \ + $(TAO_ROOT)/tao/IIOP_Transport.i \ $(TAO_ROOT)/tao/IIOP_Connect.i \ $(TAO_ROOT)/tao/Resource_Factory.h \ $(TAO_ROOT)/tao/Protocol_Factory.h \ @@ -5135,10 +5452,12 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ $(TAO_ROOT)/tao/operation_details.h \ $(TAO_ROOT)/tao/operation_details.i \ + $(TAO_ROOT)/tao/IIOP_Transport.i \ $(TAO_ROOT)/tao/IIOP_Connect.i \ $(TAO_ROOT)/tao/Acceptor_Impl.h \ $(TAO_ROOT)/tao/Acceptor_Impl.i \ @@ -5202,7 +5521,10 @@ realclean: $(TAO_ROOT)/tao/Profile.i \ $(TAO_ROOT)/tao/IIOP_Profile.i \ $(TAO_ROOT)/tao/MProfile.h \ - $(TAO_ROOT)/tao/MProfile.i + $(TAO_ROOT)/tao/MProfile.i \ + $(ACE_ROOT)/ace/Auto_Ptr.h \ + $(ACE_ROOT)/ace/Auto_Ptr.i \ + $(ACE_ROOT)/ace/Auto_Ptr.cpp .obj/IIOP_Connect.o .obj/IIOP_Connect.so .shobj/IIOP_Connect.o .shobj/IIOP_Connect.so: IIOP_Connect.cpp \ $(TAO_ROOT)/tao/IIOP_Connect.h \ @@ -5395,10 +5717,12 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ $(TAO_ROOT)/tao/operation_details.h \ $(TAO_ROOT)/tao/operation_details.i \ + $(TAO_ROOT)/tao/IIOP_Transport.i \ $(TAO_ROOT)/tao/IIOP_Connect.i \ $(TAO_ROOT)/tao/Timeprobe.h \ $(ACE_ROOT)/ace/Timeprobe.h \ @@ -5480,9 +5804,7 @@ realclean: $(TAO_ROOT)/tao/GIOP_Message_Acceptors.h \ $(TAO_ROOT)/tao/GIOP_Message_Accept_State.h \ $(TAO_ROOT)/tao/GIOP_Message_Accept_State.i \ - $(TAO_ROOT)/tao/GIOP_Message_Acceptors.i \ - $(TAO_ROOT)/tao/GIOP_Message_Connectors.h \ - $(TAO_ROOT)/tao/GIOP_Message_Connectors.i + $(TAO_ROOT)/tao/GIOP_Message_Acceptors.i .obj/UIOP_Factory.o .obj/UIOP_Factory.so .shobj/UIOP_Factory.o .shobj/UIOP_Factory.so: UIOP_Factory.cpp \ $(TAO_ROOT)/tao/UIOP_Factory.h \ @@ -5640,6 +5962,7 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ $(ACE_ROOT)/ace/Acceptor.h \ @@ -5687,6 +6010,297 @@ realclean: $(ACE_ROOT)/ace/LSOCK_Acceptor.i \ $(TAO_ROOT)/tao/UIOP_Connect.h \ $(TAO_ROOT)/tao/UIOP_Transport.h \ + $(TAO_ROOT)/tao/UIOP_Transport.i \ + $(TAO_ROOT)/tao/Wait_Strategy.h \ + $(TAO_ROOT)/tao/UIOP_Connect.i \ + $(TAO_ROOT)/tao/Acceptor_Impl.h \ + $(TAO_ROOT)/tao/Acceptor_Impl.i \ + $(TAO_ROOT)/tao/Acceptor_Impl.cpp \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/IOR_LookupTable.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/Services.i \ + $(TAO_ROOT)/tao/IORManipulation.h \ + $(TAO_ROOT)/tao/IORS.h \ + $(TAO_ROOT)/tao/IORC.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/IORC.i \ + $(TAO_ROOT)/tao/Servant_Base.h \ + $(TAO_ROOT)/tao/POAC.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/POAC.i \ + $(TAO_ROOT)/tao/Servant_Base.i \ + $(TAO_ROOT)/tao/IORS.i \ + $(TAO_ROOT)/tao/Interceptor.h \ + $(TAO_ROOT)/tao/InterceptorS.h \ + $(TAO_ROOT)/tao/InterceptorC.h \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/InterceptorC.i \ + $(TAO_ROOT)/tao/Interceptor.i \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/POA_CORBA.h \ + $(TAO_ROOT)/tao/DynAnyC.h \ + $(TAO_ROOT)/tao/DynAnyC.i \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/DomainC.i \ + $(TAO_ROOT)/tao/Policy_Manager.i \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(ACE_ROOT)/ace/Dynamic_Service.h \ + $(ACE_ROOT)/ace/Dynamic_Service.cpp \ + $(TAO_ROOT)/tao/Server_Strategy_Factory.h \ + $(TAO_ROOT)/tao/Connector_Registry.h \ + $(TAO_ROOT)/tao/Connector_Registry.i \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/UIOP_Connector.h \ + $(ACE_ROOT)/ace/Connector.h \ + $(ACE_ROOT)/ace/Connector.i \ + $(ACE_ROOT)/ace/Connector.cpp \ + $(ACE_ROOT)/ace/LSOCK_Connector.h \ + $(ACE_ROOT)/ace/SOCK_Connector.h \ + $(ACE_ROOT)/ace/SOCK_Connector.i \ + $(ACE_ROOT)/ace/LSOCK_Connector.i \ + $(ACE_ROOT)/ace/Cached_Connect_Strategy_T.h \ + $(ACE_ROOT)/ace/Hash_Cache_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Cache_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Pair_T.h \ + $(ACE_ROOT)/ace/Pair.h \ + $(ACE_ROOT)/ace/Pair.i \ + $(ACE_ROOT)/ace/Pair_T.i \ + $(ACE_ROOT)/ace/Pair_T.cpp \ + $(ACE_ROOT)/ace/Cache_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Cache_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Hash_Cache_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Hash_Cache_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Caching_Strategies_T.h \ + $(ACE_ROOT)/ace/Caching_Utility_T.h \ + $(ACE_ROOT)/ace/Cleanup_Strategies_T.h \ + $(ACE_ROOT)/ace/Cleanup_Strategies_T.i \ + $(ACE_ROOT)/ace/Cleanup_Strategies_T.cpp \ + $(ACE_ROOT)/ace/Caching_Utility_T.i \ + $(ACE_ROOT)/ace/Caching_Utility_T.cpp \ + $(ACE_ROOT)/ace/Caching_Strategies_T.i \ + $(ACE_ROOT)/ace/Caching_Strategies_T.cpp \ + $(ACE_ROOT)/ace/Cached_Connect_Strategy_T.i \ + $(ACE_ROOT)/ace/Cached_Connect_Strategy_T.cpp + +.obj/UIOP_Lite_Factory.o .obj/UIOP_Lite_Factory.so .shobj/UIOP_Lite_Factory.o .shobj/UIOP_Lite_Factory.so: UIOP_Lite_Factory.cpp \ + $(TAO_ROOT)/tao/UIOP_Lite_Factory.h \ + $(TAO_ROOT)/tao/Protocol_Factory.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.6.h \ + $(ACE_ROOT)/ace/config-sunos5.5.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies.i \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/SString.i \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Synch_Options.i \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor.i \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Strategies_T.i \ + $(ACE_ROOT)/ace/Strategies_T.cpp \ + $(ACE_ROOT)/ace/Service_Repository.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/Service_Repository.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.i \ + $(TAO_ROOT)/tao/Pluggable.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/try_macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/varout.h \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/varout.i \ + $(TAO_ROOT)/tao/varout.cpp \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/Pluggable.i \ + $(TAO_ROOT)/tao/UIOP_Acceptor.h \ + $(TAO_ROOT)/tao/GIOP_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging.h \ + $(TAO_ROOT)/tao/target_identifier.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/target_identifier.i \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ + $(TAO_ROOT)/tao/Pluggable_Messaging.i \ + $(TAO_ROOT)/tao/GIOP_Utils.i \ + $(ACE_ROOT)/ace/Acceptor.h \ + $(ACE_ROOT)/ace/Svc_Handler.h \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Task.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Task_T.i \ + $(ACE_ROOT)/ace/Task_T.cpp \ + $(ACE_ROOT)/ace/Module.h \ + $(ACE_ROOT)/ace/Module.i \ + $(ACE_ROOT)/ace/Module.cpp \ + $(ACE_ROOT)/ace/Stream_Modules.h \ + $(ACE_ROOT)/ace/Stream_Modules.i \ + $(ACE_ROOT)/ace/Stream_Modules.cpp \ + $(ACE_ROOT)/ace/Svc_Handler.i \ + $(ACE_ROOT)/ace/Svc_Handler.cpp \ + $(ACE_ROOT)/ace/Dynamic.h \ + $(ACE_ROOT)/ace/Dynamic.i \ + $(ACE_ROOT)/ace/Acceptor.i \ + $(ACE_ROOT)/ace/Acceptor.cpp \ + $(ACE_ROOT)/ace/LSOCK_Acceptor.h \ + $(ACE_ROOT)/ace/SOCK_Acceptor.h \ + $(ACE_ROOT)/ace/SOCK_Stream.h \ + $(ACE_ROOT)/ace/SOCK_IO.h \ + $(ACE_ROOT)/ace/SOCK.h \ + $(ACE_ROOT)/ace/Addr.h \ + $(ACE_ROOT)/ace/Addr.i \ + $(ACE_ROOT)/ace/IPC_SAP.h \ + $(ACE_ROOT)/ace/IPC_SAP.i \ + $(ACE_ROOT)/ace/QoS_Session.h \ + $(ACE_ROOT)/ace/INET_Addr.h \ + $(ACE_ROOT)/ace/INET_Addr.i \ + $(ACE_ROOT)/ace/SOCK.i \ + $(ACE_ROOT)/ace/SOCK_IO.i \ + $(ACE_ROOT)/ace/SOCK_Stream.i \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/SOCK_Acceptor.i \ + $(ACE_ROOT)/ace/UNIX_Addr.h \ + $(ACE_ROOT)/ace/UNIX_Addr.i \ + $(ACE_ROOT)/ace/LSOCK_Stream.h \ + $(ACE_ROOT)/ace/LSOCK.h \ + $(ACE_ROOT)/ace/LSOCK.i \ + $(ACE_ROOT)/ace/LSOCK_Stream.i \ + $(ACE_ROOT)/ace/LSOCK_Acceptor.i \ + $(TAO_ROOT)/tao/UIOP_Connect.h \ + $(TAO_ROOT)/tao/UIOP_Transport.h \ + $(TAO_ROOT)/tao/UIOP_Transport.i \ $(TAO_ROOT)/tao/Wait_Strategy.h \ $(TAO_ROOT)/tao/UIOP_Connect.i \ $(TAO_ROOT)/tao/Acceptor_Impl.h \ @@ -5934,8 +6548,10 @@ realclean: $(TAO_ROOT)/tao/target_identifier.h \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ + $(TAO_ROOT)/tao/UIOP_Transport.i \ $(ACE_ROOT)/ace/Acceptor.h \ $(ACE_ROOT)/ace/Svc_Handler.h \ $(ACE_ROOT)/ace/Task.h \ @@ -6240,8 +6856,10 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ + $(TAO_ROOT)/tao/UIOP_Transport.i \ $(TAO_ROOT)/tao/UIOP_Connect.h \ $(ACE_ROOT)/ace/Acceptor.h \ $(ACE_ROOT)/ace/Svc_Handler.h \ @@ -6304,11 +6922,11 @@ realclean: $(TAO_ROOT)/tao/PolicyC.h \ $(TAO_ROOT)/tao/CurrentC.h \ $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/PolicyC.i \ $(TAO_ROOT)/tao/TimeBaseC.h \ $(TAO_ROOT)/tao/Any.h \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Any.i \ $(TAO_ROOT)/tao/TimeBaseC.i \ $(TAO_ROOT)/tao/TAOC.i \ @@ -6354,7 +6972,24 @@ realclean: $(TAO_ROOT)/tao/ORB_Core.i \ $(ACE_ROOT)/ace/Dynamic_Service.h \ $(ACE_ROOT)/ace/Dynamic_Service.cpp \ - $(TAO_ROOT)/tao/debug.h + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/GIOP_Message_Connectors.h \ + $(TAO_ROOT)/tao/GIOP_Message_Base.h \ + $(TAO_ROOT)/tao/GIOP_Message_Base.i \ + $(TAO_ROOT)/tao/GIOP_Message_Connectors.i \ + $(TAO_ROOT)/tao/GIOP_Message_Lite.h \ + $(TAO_ROOT)/tao/GIOP_Server_Request.h \ + $(TAO_ROOT)/tao/Server_Request.h \ + $(TAO_ROOT)/tao/Server_Request.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/GIOP_Server_Request.i \ + $(TAO_ROOT)/tao/GIOP_Assorted_Headers.h \ + $(TAO_ROOT)/tao/GIOPC.h \ + $(TAO_ROOT)/tao/Union.h \ + $(TAO_ROOT)/tao/GIOPC.i \ + $(TAO_ROOT)/tao/GIOP_Assorted_Headers.i \ + $(TAO_ROOT)/tao/GIOP_Message_Lite.i .obj/UIOP_Connector.o .obj/UIOP_Connector.so .shobj/UIOP_Connector.o .shobj/UIOP_Connector.so: UIOP_Connector.cpp \ $(TAO_ROOT)/tao/UIOP_Connector.h \ @@ -6558,8 +7193,10 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ + $(TAO_ROOT)/tao/UIOP_Transport.i \ $(ACE_ROOT)/ace/Acceptor.h \ $(ACE_ROOT)/ace/Acceptor.i \ $(ACE_ROOT)/ace/Acceptor.cpp \ @@ -6801,6 +7438,7 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ $(ACE_ROOT)/ace/Acceptor.h \ @@ -6848,6 +7486,7 @@ realclean: $(ACE_ROOT)/ace/LSOCK_Acceptor.i \ $(TAO_ROOT)/tao/UIOP_Connect.h \ $(TAO_ROOT)/tao/UIOP_Transport.h \ + $(TAO_ROOT)/tao/UIOP_Transport.i \ $(TAO_ROOT)/tao/Wait_Strategy.h \ $(TAO_ROOT)/tao/UIOP_Connect.i \ $(TAO_ROOT)/tao/Acceptor_Impl.h \ @@ -7068,8 +7707,10 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ + $(TAO_ROOT)/tao/UIOP_Transport.i \ $(ACE_ROOT)/ace/Acceptor.h \ $(ACE_ROOT)/ace/Svc_Handler.h \ $(ACE_ROOT)/ace/Task.h \ @@ -7177,10 +7818,11 @@ realclean: $(TAO_ROOT)/tao/MessagingC.i \ $(TAO_ROOT)/tao/MessagingS.i \ $(TAO_ROOT)/tao/Messaging_Policy_i.i \ - $(TAO_ROOT)/tao/GIOP_Message_Lite.h \ - $(TAO_ROOT)/tao/GIOP_Server_Request.h \ + $(TAO_ROOT)/tao/GIOP_Message_Acceptors.h \ $(TAO_ROOT)/tao/GIOP_Message_Base.h \ $(TAO_ROOT)/tao/GIOP_Message_Base.i \ + $(TAO_ROOT)/tao/GIOP_Message_Accept_State.h \ + $(TAO_ROOT)/tao/GIOP_Server_Request.h \ $(TAO_ROOT)/tao/Server_Request.h \ $(TAO_ROOT)/tao/Server_Request.i \ $(TAO_ROOT)/tao/Principal.h \ @@ -7191,13 +7833,10 @@ realclean: $(TAO_ROOT)/tao/Union.h \ $(TAO_ROOT)/tao/GIOPC.i \ $(TAO_ROOT)/tao/GIOP_Assorted_Headers.i \ - $(TAO_ROOT)/tao/GIOP_Message_Lite.i \ - $(TAO_ROOT)/tao/GIOP_Message_Acceptors.h \ - $(TAO_ROOT)/tao/GIOP_Message_Accept_State.h \ $(TAO_ROOT)/tao/GIOP_Message_Accept_State.i \ $(TAO_ROOT)/tao/GIOP_Message_Acceptors.i \ - $(TAO_ROOT)/tao/GIOP_Message_Connectors.h \ - $(TAO_ROOT)/tao/GIOP_Message_Connectors.i + $(TAO_ROOT)/tao/GIOP_Message_Lite.h \ + $(TAO_ROOT)/tao/GIOP_Message_Lite.i .obj/SHMIOP_Factory.o .obj/SHMIOP_Factory.so .shobj/SHMIOP_Factory.o .shobj/SHMIOP_Factory.so: SHMIOP_Factory.cpp \ $(TAO_ROOT)/tao/SHMIOP_Factory.h \ @@ -7396,6 +8035,17 @@ realclean: $(ACE_ROOT)/ace/MEM_Acceptor.i \ $(TAO_ROOT)/tao/Wait_Strategy.h \ $(TAO_ROOT)/tao/SHMIOP_Transport.h \ + $(TAO_ROOT)/tao/GIOP_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging.h \ + $(TAO_ROOT)/tao/target_identifier.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/target_identifier.i \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ + $(TAO_ROOT)/tao/Pluggable_Messaging.i \ + $(TAO_ROOT)/tao/GIOP_Utils.i \ + $(TAO_ROOT)/tao/SHMIOP_Transport.i \ $(TAO_ROOT)/tao/SHMIOP_Connect.i \ $(TAO_ROOT)/tao/Acceptor_Impl.h \ $(TAO_ROOT)/tao/Acceptor_Impl.i \ @@ -7640,23 +8290,9 @@ realclean: $(TAO_ROOT)/tao/ORB.i \ $(TAO_ROOT)/tao/Object_KeyC.h \ $(TAO_ROOT)/tao/Object_KeyC.i \ - $(ACE_ROOT)/ace/MEM_Addr.h \ - $(ACE_ROOT)/ace/INET_Addr.h \ - $(ACE_ROOT)/ace/Addr.h \ - $(ACE_ROOT)/ace/Addr.i \ - $(ACE_ROOT)/ace/INET_Addr.i \ - $(ACE_ROOT)/ace/MEM_Addr.i \ - $(TAO_ROOT)/tao/SHMIOP_Profile.i \ - $(TAO_ROOT)/tao/SHMIOP_Connect.h \ - $(ACE_ROOT)/ace/Acceptor.h \ - $(ACE_ROOT)/ace/Svc_Handler.h \ - $(ACE_ROOT)/ace/Synch_Options.h \ - $(ACE_ROOT)/ace/Synch_Options.i \ - $(ACE_ROOT)/ace/Task.h \ - $(ACE_ROOT)/ace/Thread_Manager.h \ - $(ACE_ROOT)/ace/Thread_Manager.i \ - $(ACE_ROOT)/ace/Task.i \ - $(ACE_ROOT)/ace/Task_T.h \ + $(TAO_ROOT)/tao/GIOP_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging.h \ + $(TAO_ROOT)/tao/Pluggable.h \ $(ACE_ROOT)/ace/Message_Queue.h \ $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ $(ACE_ROOT)/ace/Message_Queue_T.h \ @@ -7664,6 +8300,10 @@ realclean: $(ACE_ROOT)/ace/Message_Queue_T.cpp \ $(ACE_ROOT)/ace/Strategies.h \ $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Synch_Options.i \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Thread_Manager.i \ $(ACE_ROOT)/ace/Strategies_T.i \ $(ACE_ROOT)/ace/Strategies_T.cpp \ $(ACE_ROOT)/ace/Service_Repository.h \ @@ -7674,6 +8314,26 @@ realclean: $(ACE_ROOT)/ace/WFMO_Reactor.i \ $(ACE_ROOT)/ace/Strategies.i \ $(ACE_ROOT)/ace/Message_Queue.i \ + $(TAO_ROOT)/tao/Pluggable.i \ + $(TAO_ROOT)/tao/target_identifier.h \ + $(TAO_ROOT)/tao/target_identifier.i \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ + $(TAO_ROOT)/tao/Pluggable_Messaging.i \ + $(TAO_ROOT)/tao/GIOP_Utils.i \ + $(ACE_ROOT)/ace/MEM_Addr.h \ + $(ACE_ROOT)/ace/INET_Addr.h \ + $(ACE_ROOT)/ace/Addr.h \ + $(ACE_ROOT)/ace/Addr.i \ + $(ACE_ROOT)/ace/INET_Addr.i \ + $(ACE_ROOT)/ace/MEM_Addr.i \ + $(TAO_ROOT)/tao/SHMIOP_Profile.i \ + $(TAO_ROOT)/tao/SHMIOP_Connect.h \ + $(ACE_ROOT)/ace/Acceptor.h \ + $(ACE_ROOT)/ace/Svc_Handler.h \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Task.i \ + $(ACE_ROOT)/ace/Task_T.h \ $(ACE_ROOT)/ace/Task_T.i \ $(ACE_ROOT)/ace/Task_T.cpp \ $(ACE_ROOT)/ace/Module.h \ @@ -7710,8 +8370,7 @@ realclean: $(ACE_ROOT)/ace/MEM_Acceptor.i \ $(TAO_ROOT)/tao/Wait_Strategy.h \ $(TAO_ROOT)/tao/SHMIOP_Transport.h \ - $(TAO_ROOT)/tao/Pluggable.h \ - $(TAO_ROOT)/tao/Pluggable.i \ + $(TAO_ROOT)/tao/SHMIOP_Transport.i \ $(TAO_ROOT)/tao/SHMIOP_Connect.i \ $(TAO_ROOT)/tao/ORB_Core.h \ $(TAO_ROOT)/tao/Policy_Manager.h \ @@ -7780,13 +8439,6 @@ realclean: $(TAO_ROOT)/tao/PollableC.h \ $(TAO_ROOT)/tao/MessagingC.i \ $(TAO_ROOT)/tao/Request.i \ - $(TAO_ROOT)/tao/GIOP_Utils.h \ - $(TAO_ROOT)/tao/Pluggable_Messaging.h \ - $(TAO_ROOT)/tao/target_identifier.h \ - $(TAO_ROOT)/tao/target_identifier.i \ - $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ - $(TAO_ROOT)/tao/Pluggable_Messaging.i \ - $(TAO_ROOT)/tao/GIOP_Utils.i \ $(TAO_ROOT)/tao/Reply_Dispatcher.i \ $(TAO_ROOT)/tao/TAOC.h \ $(TAO_ROOT)/tao/TAOC.i \ @@ -7944,6 +8596,17 @@ realclean: $(TAO_ROOT)/tao/CDR.i \ $(TAO_ROOT)/tao/IOPC.i \ $(TAO_ROOT)/tao/Pluggable.i \ + $(TAO_ROOT)/tao/GIOP_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging.h \ + $(TAO_ROOT)/tao/target_identifier.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/target_identifier.i \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ + $(TAO_ROOT)/tao/Pluggable_Messaging.i \ + $(TAO_ROOT)/tao/GIOP_Utils.i \ + $(TAO_ROOT)/tao/SHMIOP_Transport.i \ $(TAO_ROOT)/tao/SHMIOP_Connect.h \ $(ACE_ROOT)/ace/Acceptor.h \ $(ACE_ROOT)/ace/Svc_Handler.h \ @@ -8026,19 +8689,10 @@ realclean: $(TAO_ROOT)/tao/InterceptorC.i \ $(TAO_ROOT)/tao/Interceptor.i \ $(TAO_ROOT)/tao/ORB.i \ - $(TAO_ROOT)/tao/Object_KeyC.h \ - $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/SHMIOP_Profile.i \ $(TAO_ROOT)/tao/Timeprobe.h \ $(ACE_ROOT)/ace/Timeprobe.h \ $(TAO_ROOT)/tao/Transport_Mux_Strategy.h \ - $(TAO_ROOT)/tao/GIOP_Utils.h \ - $(TAO_ROOT)/tao/Pluggable_Messaging.h \ - $(TAO_ROOT)/tao/target_identifier.h \ - $(TAO_ROOT)/tao/target_identifier.i \ - $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ - $(TAO_ROOT)/tao/Pluggable_Messaging.i \ - $(TAO_ROOT)/tao/GIOP_Utils.i \ $(TAO_ROOT)/tao/Sync_Strategies.h \ $(TAO_ROOT)/tao/TAOC.h \ $(TAO_ROOT)/tao/TimeBaseC.h \ @@ -8067,7 +8721,24 @@ realclean: $(TAO_ROOT)/tao/ORB_Core.i \ $(ACE_ROOT)/ace/Dynamic_Service.h \ $(ACE_ROOT)/ace/Dynamic_Service.cpp \ - $(TAO_ROOT)/tao/debug.h + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/GIOP_Message_Lite.h \ + $(TAO_ROOT)/tao/GIOP_Server_Request.h \ + $(TAO_ROOT)/tao/GIOP_Message_Base.h \ + $(TAO_ROOT)/tao/GIOP_Message_Base.i \ + $(TAO_ROOT)/tao/Server_Request.h \ + $(TAO_ROOT)/tao/Server_Request.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/GIOP_Server_Request.i \ + $(TAO_ROOT)/tao/GIOP_Assorted_Headers.h \ + $(TAO_ROOT)/tao/GIOPC.h \ + $(TAO_ROOT)/tao/Union.h \ + $(TAO_ROOT)/tao/GIOPC.i \ + $(TAO_ROOT)/tao/GIOP_Assorted_Headers.i \ + $(TAO_ROOT)/tao/GIOP_Message_Lite.i \ + $(TAO_ROOT)/tao/GIOP_Message_Connectors.h \ + $(TAO_ROOT)/tao/GIOP_Message_Connectors.i .obj/SHMIOP_Connector.o .obj/SHMIOP_Connector.so .shobj/SHMIOP_Connector.o .shobj/SHMIOP_Connector.so: SHMIOP_Connector.cpp \ $(TAO_ROOT)/tao/SHMIOP_Connector.h \ @@ -8274,6 +8945,17 @@ realclean: $(ACE_ROOT)/ace/MEM_Acceptor.i \ $(TAO_ROOT)/tao/Wait_Strategy.h \ $(TAO_ROOT)/tao/SHMIOP_Transport.h \ + $(TAO_ROOT)/tao/GIOP_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging.h \ + $(TAO_ROOT)/tao/target_identifier.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/target_identifier.i \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ + $(TAO_ROOT)/tao/Pluggable_Messaging.i \ + $(TAO_ROOT)/tao/GIOP_Utils.i \ + $(TAO_ROOT)/tao/SHMIOP_Transport.i \ $(TAO_ROOT)/tao/SHMIOP_Connect.i \ $(TAO_ROOT)/tao/Resource_Factory.h \ $(TAO_ROOT)/tao/Protocol_Factory.h \ @@ -8334,8 +9016,6 @@ realclean: $(TAO_ROOT)/tao/InterceptorC.i \ $(TAO_ROOT)/tao/Interceptor.i \ $(TAO_ROOT)/tao/ORB.i \ - $(TAO_ROOT)/tao/Object_KeyC.h \ - $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/SHMIOP_Profile.i \ $(TAO_ROOT)/tao/debug.h \ $(TAO_ROOT)/tao/ORB_Core.h \ @@ -8551,6 +9231,17 @@ realclean: $(ACE_ROOT)/ace/MEM_Acceptor.i \ $(TAO_ROOT)/tao/Wait_Strategy.h \ $(TAO_ROOT)/tao/SHMIOP_Transport.h \ + $(TAO_ROOT)/tao/GIOP_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging.h \ + $(TAO_ROOT)/tao/target_identifier.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/target_identifier.i \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ + $(TAO_ROOT)/tao/Pluggable_Messaging.i \ + $(TAO_ROOT)/tao/GIOP_Utils.i \ + $(TAO_ROOT)/tao/SHMIOP_Transport.i \ $(TAO_ROOT)/tao/SHMIOP_Connect.i \ $(TAO_ROOT)/tao/Acceptor_Impl.h \ $(TAO_ROOT)/tao/Acceptor_Impl.i \ @@ -8612,8 +9303,6 @@ realclean: $(TAO_ROOT)/tao/CONV_FRAMEC.i \ $(TAO_ROOT)/tao/Tagged_Components.i \ $(TAO_ROOT)/tao/Profile.i \ - $(TAO_ROOT)/tao/Object_KeyC.h \ - $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/SHMIOP_Profile.i \ $(TAO_ROOT)/tao/MProfile.h \ $(TAO_ROOT)/tao/MProfile.i @@ -8812,6 +9501,17 @@ realclean: $(TAO_ROOT)/tao/CDR.i \ $(TAO_ROOT)/tao/IOPC.i \ $(TAO_ROOT)/tao/Pluggable.i \ + $(TAO_ROOT)/tao/GIOP_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging.h \ + $(TAO_ROOT)/tao/target_identifier.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/target_identifier.i \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ + $(TAO_ROOT)/tao/Pluggable_Messaging.i \ + $(TAO_ROOT)/tao/GIOP_Utils.i \ + $(TAO_ROOT)/tao/SHMIOP_Transport.i \ $(TAO_ROOT)/tao/SHMIOP_Connect.i \ $(TAO_ROOT)/tao/Timeprobe.h \ $(ACE_ROOT)/ace/Timeprobe.h \ @@ -8860,7 +9560,26 @@ realclean: $(ACE_ROOT)/ace/Map_Manager.cpp \ $(TAO_ROOT)/tao/ORB_Core.i \ $(ACE_ROOT)/ace/Dynamic_Service.h \ - $(ACE_ROOT)/ace/Dynamic_Service.cpp + $(ACE_ROOT)/ace/Dynamic_Service.cpp \ + $(TAO_ROOT)/tao/GIOP_Message_Acceptors.h \ + $(TAO_ROOT)/tao/GIOP_Message_Base.h \ + $(TAO_ROOT)/tao/GIOP_Message_Base.i \ + $(TAO_ROOT)/tao/GIOP_Message_Accept_State.h \ + $(TAO_ROOT)/tao/GIOP_Server_Request.h \ + $(TAO_ROOT)/tao/Server_Request.h \ + $(TAO_ROOT)/tao/Server_Request.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/GIOP_Server_Request.i \ + $(TAO_ROOT)/tao/GIOP_Assorted_Headers.h \ + $(TAO_ROOT)/tao/GIOPC.h \ + $(TAO_ROOT)/tao/Union.h \ + $(TAO_ROOT)/tao/GIOPC.i \ + $(TAO_ROOT)/tao/GIOP_Assorted_Headers.i \ + $(TAO_ROOT)/tao/GIOP_Message_Accept_State.i \ + $(TAO_ROOT)/tao/GIOP_Message_Acceptors.i \ + $(TAO_ROOT)/tao/GIOP_Message_Lite.h \ + $(TAO_ROOT)/tao/GIOP_Message_Lite.i .obj/IORC.o .obj/IORC.so .shobj/IORC.o .shobj/IORC.so: IORC.cpp $(TAO_ROOT)/tao/IORC.h \ $(ACE_ROOT)/ace/OS.h \ @@ -9082,6 +9801,7 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ $(TAO_ROOT)/tao/Reply_Dispatcher.i \ @@ -9590,6 +10310,7 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i @@ -10025,7 +10746,10 @@ realclean: $(ACE_ROOT)/ace/Msg_WFMO_Reactor.i \ $(ACE_ROOT)/ace/TP_Reactor.h \ $(ACE_ROOT)/ace/TP_Reactor.i \ - $(ACE_ROOT)/ace/Arg_Shifter.h + $(ACE_ROOT)/ace/Arg_Shifter.h \ + $(ACE_ROOT)/ace/Auto_Ptr.h \ + $(ACE_ROOT)/ace/Auto_Ptr.i \ + $(ACE_ROOT)/ace/Auto_Ptr.cpp .obj/xt_resource.o .obj/xt_resource.so .shobj/xt_resource.o .shobj/xt_resource.so: xt_resource.cpp \ $(TAO_ROOT)/tao/xt_resource.h \ @@ -10177,23 +10901,7 @@ realclean: $(TAO_ROOT)/tao/IOPC.i \ $(TAO_ROOT)/tao/Pluggable.i \ $(TAO_ROOT)/tao/Protocol_Factory.h \ - $(TAO_ROOT)/tao/default_resource.i \ - $(ACE_ROOT)/ace/XtReactor.h \ - $(ACE_ROOT)/ace/Select_Reactor.h \ - $(ACE_ROOT)/ace/Select_Reactor_T.h \ - $(ACE_ROOT)/ace/Select_Reactor_Base.h \ - $(ACE_ROOT)/ace/Token.h \ - $(ACE_ROOT)/ace/Token.i \ - $(ACE_ROOT)/ace/Pipe.h \ - $(ACE_ROOT)/ace/Pipe.i \ - $(ACE_ROOT)/ace/Select_Reactor_Base.i \ - $(ACE_ROOT)/ace/Select_Reactor_T.cpp \ - $(ACE_ROOT)/ace/Timer_Heap.h \ - $(ACE_ROOT)/ace/Timer_Heap_T.h \ - $(ACE_ROOT)/ace/Timer_Heap_T.cpp \ - $(ACE_ROOT)/ace/Select_Reactor_T.i \ - $(ACE_ROOT)/ace/Select_Reactor.i \ - $(TAO_ROOT)/tao/xt_resource.i + $(TAO_ROOT)/tao/default_resource.i .obj/qt_resource.o .obj/qt_resource.so .shobj/qt_resource.o .shobj/qt_resource.so: qt_resource.cpp \ $(TAO_ROOT)/tao/qt_resource.h \ @@ -12081,7 +12789,8 @@ realclean: $(TAO_ROOT)/tao/ORB_Core.i \ $(ACE_ROOT)/ace/Dynamic_Service.h \ $(ACE_ROOT)/ace/Dynamic_Service.cpp \ - $(TAO_ROOT)/tao/singletons.h + $(TAO_ROOT)/tao/singletons.h \ + $(TAO_ROOT)/tao/debug.h .obj/CurrentC.o .obj/CurrentC.so .shobj/CurrentC.o .shobj/CurrentC.so: CurrentC.cpp \ $(TAO_ROOT)/tao/CurrentC.h \ @@ -12388,6 +13097,8 @@ realclean: $(TAO_ROOT)/tao/Exception.i \ $(TAO_ROOT)/tao/Typecode.i \ $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Sequence.h \ $(TAO_ROOT)/tao/Managed_Types.h \ $(TAO_ROOT)/tao/Managed_Types.i \ @@ -12401,8 +13112,6 @@ realclean: $(TAO_ROOT)/tao/PolicyC.i \ $(TAO_ROOT)/tao/DynAnyC.h \ $(TAO_ROOT)/tao/Any.h \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Any.i \ $(TAO_ROOT)/tao/DynAnyC.i \ $(TAO_ROOT)/tao/DomainC.h \ @@ -12587,7 +13296,13 @@ realclean: $(ACE_ROOT)/ace/CORBA_macros.h \ $(TAO_ROOT)/tao/corbafwd.i \ $(TAO_ROOT)/tao/Exception.h \ - $(TAO_ROOT)/tao/Exception.i + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/CDR.h \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/CDR.i .obj/Environment.o .obj/Environment.so .shobj/Environment.o .shobj/Environment.so: Environment.cpp \ $(TAO_ROOT)/tao/Environment.h \ @@ -12916,6 +13631,8 @@ realclean: $(TAO_ROOT)/tao/Exception.i \ $(TAO_ROOT)/tao/Typecode.i \ $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Sequence.h \ $(TAO_ROOT)/tao/Managed_Types.h \ $(TAO_ROOT)/tao/Managed_Types.i \ @@ -12927,8 +13644,6 @@ realclean: $(TAO_ROOT)/tao/varout.i \ $(TAO_ROOT)/tao/varout.cpp \ $(TAO_ROOT)/tao/PolicyC.i \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/POAC.i \ $(TAO_ROOT)/tao/Key_Adapters.i \ $(TAO_ROOT)/tao/Server_Strategy_Factory.h \ @@ -13027,6 +13742,7 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ $(TAO_ROOT)/tao/Reply_Dispatcher.i \ @@ -13485,6 +14201,7 @@ realclean: $(TAO_ROOT)/tao/target_identifier.h \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ $(TAO_ROOT)/tao/Reply_Dispatcher.i \ @@ -13682,6 +14399,8 @@ realclean: $(TAO_ROOT)/tao/Exception.i \ $(TAO_ROOT)/tao/Typecode.i \ $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Sequence.h \ $(TAO_ROOT)/tao/Managed_Types.h \ $(TAO_ROOT)/tao/Managed_Types.i \ @@ -13760,8 +14479,6 @@ realclean: $(TAO_ROOT)/tao/IORManipulation.h \ $(TAO_ROOT)/tao/IORS.h \ $(TAO_ROOT)/tao/IORC.h \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/IORC.i \ $(TAO_ROOT)/tao/Servant_Base.h \ $(TAO_ROOT)/tao/POAC.h \ @@ -13815,6 +14532,7 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ $(TAO_ROOT)/tao/Reply_Dispatcher.i \ @@ -13912,6 +14630,8 @@ realclean: $(TAO_ROOT)/tao/Exception.i \ $(TAO_ROOT)/tao/Typecode.i \ $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Sequence.h \ $(TAO_ROOT)/tao/Managed_Types.h \ $(TAO_ROOT)/tao/Managed_Types.i \ @@ -13959,8 +14679,6 @@ realclean: $(TAO_ROOT)/tao/POA_CORBA.h \ $(TAO_ROOT)/tao/DynAnyC.h \ $(TAO_ROOT)/tao/Any.h \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Any.i \ $(TAO_ROOT)/tao/DynAnyC.i \ $(TAO_ROOT)/tao/DomainC.h \ @@ -14074,6 +14792,8 @@ realclean: $(TAO_ROOT)/tao/Exception.i \ $(TAO_ROOT)/tao/Typecode.i \ $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Sequence.h \ $(TAO_ROOT)/tao/Managed_Types.h \ $(TAO_ROOT)/tao/Managed_Types.i \ @@ -14085,8 +14805,6 @@ realclean: $(TAO_ROOT)/tao/varout.i \ $(TAO_ROOT)/tao/varout.cpp \ $(TAO_ROOT)/tao/PolicyC.i \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Any.h \ $(TAO_ROOT)/tao/Any.i \ $(TAO_ROOT)/tao/DomainC.i \ @@ -14206,6 +14924,7 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ $(TAO_ROOT)/tao/Reply_Dispatcher.i \ @@ -14303,6 +15022,8 @@ realclean: $(TAO_ROOT)/tao/Exception.i \ $(TAO_ROOT)/tao/Typecode.i \ $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Sequence.h \ $(TAO_ROOT)/tao/Managed_Types.h \ $(TAO_ROOT)/tao/Managed_Types.i \ @@ -14314,8 +15035,6 @@ realclean: $(TAO_ROOT)/tao/varout.i \ $(TAO_ROOT)/tao/varout.cpp \ $(TAO_ROOT)/tao/PolicyC.i \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Any.h \ $(TAO_ROOT)/tao/Any.i \ $(TAO_ROOT)/tao/DomainC.i \ @@ -14863,9 +15582,9 @@ realclean: $(TAO_ROOT)/tao/PolicyC.h \ $(TAO_ROOT)/tao/CurrentC.h \ $(TAO_ROOT)/tao/CurrentC.i \ - $(TAO_ROOT)/tao/PolicyC.i \ $(TAO_ROOT)/tao/Environment.h \ $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/PolicyC.i \ $(TAO_ROOT)/tao/POAC.i \ $(TAO_ROOT)/tao/NVList.h \ $(TAO_ROOT)/tao/Any.h \ @@ -15337,6 +16056,7 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ $(TAO_ROOT)/tao/Reply_Dispatcher.i \ @@ -16628,6 +17348,7 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ $(TAO_ROOT)/tao/Reply_Dispatcher.i \ @@ -16672,6 +17393,106 @@ realclean: $(TAO_ROOT)/tao/TAOS.i \ $(TAO_ROOT)/tao/Client_Priority_Policy.i +.obj/operation_details.o .obj/operation_details.so .shobj/operation_details.o .shobj/operation_details.so: operation_details.cpp \ + $(TAO_ROOT)/tao/operation_details.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.6.h \ + $(ACE_ROOT)/ace/config-sunos5.5.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/SString.i \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/try_macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/varout.h \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/varout.i \ + $(TAO_ROOT)/tao/varout.cpp \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/operation_details.i + .obj/Interceptor.o .obj/Interceptor.so .shobj/Interceptor.o .shobj/Interceptor.so: Interceptor.cpp \ $(TAO_ROOT)/tao/corbafwd.h \ $(ACE_ROOT)/ace/CDR_Stream.h \ @@ -17225,6 +18046,7 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ $(TAO_ROOT)/tao/Reply_Dispatcher.i \ @@ -17528,6 +18350,7 @@ realclean: $(TAO_ROOT)/tao/target_identifier.h \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ $(TAO_ROOT)/tao/Reply_Dispatcher.i \ @@ -18757,11 +19580,11 @@ realclean: $(TAO_ROOT)/tao/PolicyC.h \ $(TAO_ROOT)/tao/CurrentC.h \ $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/PolicyC.i \ $(TAO_ROOT)/tao/TimeBaseC.h \ $(TAO_ROOT)/tao/Any.h \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Any.i \ $(TAO_ROOT)/tao/TimeBaseC.i \ $(TAO_ROOT)/tao/TAOC.i \ @@ -19358,6 +20181,8 @@ realclean: $(TAO_ROOT)/tao/Exception.i \ $(TAO_ROOT)/tao/Typecode.i \ $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Sequence.h \ $(TAO_ROOT)/tao/Managed_Types.h \ $(TAO_ROOT)/tao/Managed_Types.i \ @@ -19369,8 +20194,6 @@ realclean: $(TAO_ROOT)/tao/varout.i \ $(TAO_ROOT)/tao/varout.cpp \ $(TAO_ROOT)/tao/PolicyC.i \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/POAC.i \ $(TAO_ROOT)/tao/ORB.h \ $(TAO_ROOT)/tao/IOR_LookupTable.h \ @@ -19770,6 +20593,7 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ $(TAO_ROOT)/tao/Reply_Dispatcher.h \ @@ -20006,6 +20830,7 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ $(TAO_ROOT)/tao/Reply_Dispatcher.i \ @@ -20904,11 +21729,11 @@ realclean: $(TAO_ROOT)/tao/Exception.i \ $(TAO_ROOT)/tao/Typecode.i \ $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/PolicyC.i \ $(TAO_ROOT)/tao/TimeBaseC.h \ $(TAO_ROOT)/tao/Any.h \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Any.i \ $(TAO_ROOT)/tao/TimeBaseC.i \ $(TAO_ROOT)/tao/TAOC.i \ @@ -21026,11 +21851,11 @@ realclean: $(TAO_ROOT)/tao/Exception.i \ $(TAO_ROOT)/tao/Typecode.i \ $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/PolicyC.i \ $(TAO_ROOT)/tao/TimeBaseC.h \ $(TAO_ROOT)/tao/Any.h \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Any.i \ $(TAO_ROOT)/tao/TimeBaseC.i \ $(TAO_ROOT)/tao/TAOC.i \ @@ -21364,8 +22189,7 @@ realclean: $(TAO_ROOT)/tao/PollableC.h \ $(TAO_ROOT)/tao/MessagingC.i \ $(TAO_ROOT)/tao/Request.i \ - $(TAO_ROOT)/tao/GIOP_Utils.h \ - $(TAO_ROOT)/tao/Pluggable_Messaging.h \ + $(TAO_ROOT)/tao/Stub.h \ $(TAO_ROOT)/tao/Pluggable.h \ $(ACE_ROOT)/ace/Message_Queue.h \ $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ @@ -21389,14 +22213,6 @@ realclean: $(ACE_ROOT)/ace/Strategies.i \ $(ACE_ROOT)/ace/Message_Queue.i \ $(TAO_ROOT)/tao/Pluggable.i \ - $(TAO_ROOT)/tao/target_identifier.h \ - $(TAO_ROOT)/tao/Object_KeyC.h \ - $(TAO_ROOT)/tao/Object_KeyC.i \ - $(TAO_ROOT)/tao/target_identifier.i \ - $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ - $(TAO_ROOT)/tao/Pluggable_Messaging.i \ - $(TAO_ROOT)/tao/GIOP_Utils.i \ - $(TAO_ROOT)/tao/Stub.h \ $(TAO_ROOT)/tao/MProfile.h \ $(TAO_ROOT)/tao/Profile.h \ $(TAO_ROOT)/tao/Tagged_Components.h \ @@ -21405,7 +22221,9 @@ realclean: $(TAO_ROOT)/tao/Tagged_Components.i \ $(TAO_ROOT)/tao/Profile.i \ $(TAO_ROOT)/tao/MProfile.i \ - $(TAO_ROOT)/tao/Stub.i + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i .obj/Services.o .obj/Services.so .shobj/Services.o .shobj/Services.so: Services.cpp \ $(TAO_ROOT)/tao/Services.h \ @@ -21894,6 +22712,7 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ $(TAO_ROOT)/tao/Reply_Dispatcher.i \ @@ -22237,6 +23056,8 @@ realclean: $(TAO_ROOT)/tao/Exception.i \ $(TAO_ROOT)/tao/Typecode.i \ $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Sequence.h \ $(TAO_ROOT)/tao/Managed_Types.h \ $(TAO_ROOT)/tao/Managed_Types.i \ @@ -22250,8 +23071,6 @@ realclean: $(TAO_ROOT)/tao/PolicyC.i \ $(TAO_ROOT)/tao/DynAnyC.h \ $(TAO_ROOT)/tao/Any.h \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Any.i \ $(TAO_ROOT)/tao/DynAnyC.i \ $(TAO_ROOT)/tao/DomainC.h \ @@ -22595,11 +23414,11 @@ realclean: $(TAO_ROOT)/tao/Exception.i \ $(TAO_ROOT)/tao/Typecode.i \ $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/PolicyC.i \ $(TAO_ROOT)/tao/TimeBaseC.h \ $(TAO_ROOT)/tao/Any.h \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Any.i \ $(TAO_ROOT)/tao/TimeBaseC.i \ $(TAO_ROOT)/tao/TAOC.i \ @@ -22719,11 +23538,11 @@ realclean: $(TAO_ROOT)/tao/Exception.i \ $(TAO_ROOT)/tao/Typecode.i \ $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/PolicyC.i \ $(TAO_ROOT)/tao/TimeBaseC.h \ $(TAO_ROOT)/tao/Any.h \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Any.i \ $(TAO_ROOT)/tao/TimeBaseC.i \ $(TAO_ROOT)/tao/TAOC.i \ @@ -23892,6 +24711,8 @@ realclean: $(TAO_ROOT)/tao/Exception.i \ $(TAO_ROOT)/tao/Typecode.i \ $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Sequence.h \ $(TAO_ROOT)/tao/Managed_Types.h \ $(TAO_ROOT)/tao/Managed_Types.i \ @@ -23905,8 +24726,6 @@ realclean: $(TAO_ROOT)/tao/PolicyC.i \ $(TAO_ROOT)/tao/DynAnyC.h \ $(TAO_ROOT)/tao/Any.h \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Any.i \ $(TAO_ROOT)/tao/DynAnyC.i \ $(TAO_ROOT)/tao/DomainC.h \ @@ -24017,6 +24836,8 @@ realclean: $(TAO_ROOT)/tao/Exception.i \ $(TAO_ROOT)/tao/Typecode.i \ $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Sequence.h \ $(TAO_ROOT)/tao/Managed_Types.h \ $(TAO_ROOT)/tao/Managed_Types.i \ @@ -24030,8 +24851,6 @@ realclean: $(TAO_ROOT)/tao/PolicyC.i \ $(TAO_ROOT)/tao/DynAnyC.h \ $(TAO_ROOT)/tao/Any.h \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Any.i \ $(TAO_ROOT)/tao/DynAnyC.i \ $(TAO_ROOT)/tao/DomainC.h \ @@ -24133,6 +24952,8 @@ realclean: $(TAO_ROOT)/tao/Exception.i \ $(TAO_ROOT)/tao/Typecode.i \ $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Sequence.h \ $(TAO_ROOT)/tao/Managed_Types.h \ $(TAO_ROOT)/tao/Managed_Types.i \ @@ -24146,8 +24967,6 @@ realclean: $(TAO_ROOT)/tao/PolicyC.i \ $(TAO_ROOT)/tao/DynAnyC.h \ $(TAO_ROOT)/tao/Any.h \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Any.i \ $(TAO_ROOT)/tao/DynAnyC.i \ $(TAO_ROOT)/tao/DomainC.h \ @@ -24249,6 +25068,8 @@ realclean: $(TAO_ROOT)/tao/Exception.i \ $(TAO_ROOT)/tao/Typecode.i \ $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Sequence.h \ $(TAO_ROOT)/tao/Managed_Types.h \ $(TAO_ROOT)/tao/Managed_Types.i \ @@ -24262,8 +25083,6 @@ realclean: $(TAO_ROOT)/tao/PolicyC.i \ $(TAO_ROOT)/tao/DynAnyC.h \ $(TAO_ROOT)/tao/Any.h \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Any.i \ $(TAO_ROOT)/tao/DynAnyC.i \ $(TAO_ROOT)/tao/DomainC.h \ @@ -24365,6 +25184,8 @@ realclean: $(TAO_ROOT)/tao/Exception.i \ $(TAO_ROOT)/tao/Typecode.i \ $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Sequence.h \ $(TAO_ROOT)/tao/Managed_Types.h \ $(TAO_ROOT)/tao/Managed_Types.i \ @@ -24378,8 +25199,6 @@ realclean: $(TAO_ROOT)/tao/PolicyC.i \ $(TAO_ROOT)/tao/DynAnyC.h \ $(TAO_ROOT)/tao/Any.h \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Any.i \ $(TAO_ROOT)/tao/DynAnyC.i \ $(TAO_ROOT)/tao/DomainC.h \ @@ -24524,6 +25343,8 @@ realclean: $(TAO_ROOT)/tao/Exception.i \ $(TAO_ROOT)/tao/Typecode.i \ $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Sequence.h \ $(TAO_ROOT)/tao/Managed_Types.h \ $(TAO_ROOT)/tao/Managed_Types.i \ @@ -24537,8 +25358,6 @@ realclean: $(TAO_ROOT)/tao/PolicyC.i \ $(TAO_ROOT)/tao/DynAnyC.h \ $(TAO_ROOT)/tao/Any.h \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Any.i \ $(TAO_ROOT)/tao/DynAnyC.i \ $(TAO_ROOT)/tao/DomainC.h \ @@ -24926,6 +25745,7 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ $(TAO_ROOT)/tao/Reply_Dispatcher.i \ @@ -25087,6 +25907,7 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/debug.h @@ -25243,11 +26064,12 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.h \ $(TAO_ROOT)/tao/GIOP_Utils.i \ - $(TAO_ROOT)/tao/GIOP_Message_Base.i \ $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/GIOP_Message_Base.i \ $(TAO_ROOT)/tao/operation_details.h \ $(TAO_ROOT)/tao/operation_details.i @@ -25405,16 +26227,17 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.h \ $(TAO_ROOT)/tao/GIOP_Utils.i \ + $(TAO_ROOT)/tao/debug.h \ $(TAO_ROOT)/tao/GIOP_Message_Base.i \ $(TAO_ROOT)/tao/GIOP_Message_Connectors.i \ $(TAO_ROOT)/tao/Any.h \ $(TAO_ROOT)/tao/Environment.h \ $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Any.i \ - $(TAO_ROOT)/tao/debug.h \ $(TAO_ROOT)/tao/Principal.h \ $(TAO_ROOT)/tao/Principal.i \ $(TAO_ROOT)/tao/TAOC.h \ @@ -25582,9 +26405,11 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.h \ $(TAO_ROOT)/tao/GIOP_Utils.i \ + $(TAO_ROOT)/tao/debug.h \ $(TAO_ROOT)/tao/GIOP_Message_Base.i \ $(TAO_ROOT)/tao/GIOP_Message_Accept_State.h \ $(TAO_ROOT)/tao/GIOP_Server_Request.h \ @@ -25626,7 +26451,6 @@ realclean: $(TAO_ROOT)/tao/GIOPC.i \ $(TAO_ROOT)/tao/GIOP_Assorted_Headers.i \ $(TAO_ROOT)/tao/GIOP_Message_Accept_State.i \ - $(TAO_ROOT)/tao/GIOP_Message_Acceptors.i \ $(TAO_ROOT)/tao/ORB_Core.h \ $(TAO_ROOT)/tao/Policy_Manager.h \ $(TAO_ROOT)/tao/POA_CORBA.h \ @@ -25645,7 +26469,7 @@ realclean: $(TAO_ROOT)/tao/ORB_Core.i \ $(ACE_ROOT)/ace/Dynamic_Service.h \ $(ACE_ROOT)/ace/Dynamic_Service.cpp \ - $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/GIOP_Message_Acceptors.i \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -25863,9 +26687,11 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.h \ $(TAO_ROOT)/tao/GIOP_Utils.i \ + $(TAO_ROOT)/tao/debug.h \ $(TAO_ROOT)/tao/GIOP_Message_Base.i \ $(TAO_ROOT)/tao/Server_Request.h \ $(TAO_ROOT)/tao/Server_Request.i \ @@ -25904,8 +26730,7 @@ realclean: $(TAO_ROOT)/tao/Union.h \ $(TAO_ROOT)/tao/GIOPC.i \ $(TAO_ROOT)/tao/GIOP_Assorted_Headers.i \ - $(TAO_ROOT)/tao/GIOP_Message_Accept_State.i \ - $(TAO_ROOT)/tao/debug.h + $(TAO_ROOT)/tao/GIOP_Message_Accept_State.i .obj/GIOP_Utils.o .obj/GIOP_Utils.so .shobj/GIOP_Utils.o .shobj/GIOP_Utils.so: GIOP_Utils.cpp \ $(TAO_ROOT)/tao/debug.h \ @@ -26061,6 +26886,7 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.i \ $(TAO_ROOT)/tao/ORB_Core.h \ @@ -26470,9 +27296,11 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.h \ $(TAO_ROOT)/tao/GIOP_Utils.i \ + $(TAO_ROOT)/tao/debug.h \ $(TAO_ROOT)/tao/GIOP_Message_Base.i \ $(TAO_ROOT)/tao/Server_Request.h \ $(TAO_ROOT)/tao/Server_Request.i \ @@ -26527,8 +27355,7 @@ realclean: $(ACE_ROOT)/ace/Dynamic_Service.h \ $(ACE_ROOT)/ace/Dynamic_Service.cpp \ $(TAO_ROOT)/tao/Timeprobe.h \ - $(ACE_ROOT)/ace/Timeprobe.h \ - $(TAO_ROOT)/tao/debug.h + $(ACE_ROOT)/ace/Timeprobe.h .obj/GIOP_Message_Lite.o .obj/GIOP_Message_Lite.so .shobj/GIOP_Message_Lite.o .shobj/GIOP_Message_Lite.so: GIOP_Message_Lite.cpp \ $(TAO_ROOT)/tao/GIOP_Message_Lite.h \ @@ -26685,9 +27512,11 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/target_identifier.i \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ $(TAO_ROOT)/tao/Pluggable_Messaging.i \ $(TAO_ROOT)/tao/GIOP_Utils.h \ $(TAO_ROOT)/tao/GIOP_Utils.i \ + $(TAO_ROOT)/tao/debug.h \ $(TAO_ROOT)/tao/GIOP_Message_Base.i \ $(TAO_ROOT)/tao/Server_Request.h \ $(TAO_ROOT)/tao/Server_Request.i \ diff --git a/TAO/tao/MessagingC.cpp b/TAO/tao/MessagingC.cpp index 9882d51e961..4528f4238c8 100644 --- a/TAO/tao/MessagingC.cpp +++ b/TAO/tao/MessagingC.cpp @@ -1,7 +1,6 @@ /* -*- C++ -*- */ // $Id$ - // ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* // TAO and the TAO IDL Compiler have been developed by the Center for // Distributed Object Computing at Washington University, St. Louis. @@ -24,7 +23,6 @@ ACE_RCSID(tao, MessagingC, "$Id$") - static const CORBA::Long _oc_Messaging_RebindMode[] = { TAO_ENCAP_BYTE_ORDER, // byte order @@ -2075,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 @@ -2096,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; } @@ -2108,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; } @@ -2146,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 @@ -2165,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; } @@ -2177,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; @@ -2213,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 @@ -2234,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; } @@ -2246,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; @@ -2292,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 { @@ -2306,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; } @@ -2318,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 ()) { @@ -2328,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; @@ -2367,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 { @@ -2380,38 +3792,53 @@ 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 */ +#endif /* TAO_HAS_AMI_CALLBACK == 1 || TAO_HAS_AMI_POLLER */ // **************************************************************** @@ -2424,8 +3851,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 { @@ -2437,36 +3879,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 c2101d87a8a..17da530eed0 100644 --- a/TAO/tao/MessagingC.h +++ b/TAO/tao/MessagingC.h @@ -1,7 +1,6 @@ /* -*- C++ -*- */ // // $Id$ - // // ================================================================ // @@ -2100,28 +2099,72 @@ 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) ( CORBA::Object_ptr obj); + // 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 *&); #endif /* TAO_HAS_AMI_CALLBACK == 1 */ #if (TAO_HAS_AMI_POLLER == 1) @@ -2132,10 +2175,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 f2c2bc2fdc4..7a10f63abde 100644 --- a/TAO/tao/MessagingC.i +++ b/TAO/tao/MessagingC.i @@ -1,7 +1,6 @@ /* -*- C++ -*- */ // $Id$ - // ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* // TAO and the TAO IDL Compiler have been developed by the Center for // Distributed Object Computing at Washington University, St. Louis. @@ -3775,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) && @@ -3789,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) && @@ -3801,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) && @@ -3815,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) && @@ -3827,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<< ( @@ -3888,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) && @@ -3900,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) && @@ -3914,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 ) @@ -3930,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) @@ -3946,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/MessagingS.cpp b/TAO/tao/MessagingS.cpp index 442fe4105b3..b177dca761f 100644 --- a/TAO/tao/MessagingS.cpp +++ b/TAO/tao/MessagingS.cpp @@ -1,8 +1,6 @@ /* -*- C++ -*- */ // $Id$ - - // ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* // TAO and the TAO IDL Compiler have been developed by the Center for // Distributed Object Computing at Washington University, St. Louis. @@ -28,7 +26,6 @@ ACE_RCSID(tao, MessagingS, "$Id$") - POA_Messaging::RebindPolicy::RebindPolicy (void) { } diff --git a/TAO/tao/MessagingS.h b/TAO/tao/MessagingS.h index f988054c379..c99da0a5e34 100644 --- a/TAO/tao/MessagingS.h +++ b/TAO/tao/MessagingS.h @@ -1,7 +1,6 @@ /* -*- C++ -*- */ // $Id$ - // ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* // TAO and the TAO IDL Compiler have been developed by the Center for // Distributed Object Computing at Washington University, St. Louis. diff --git a/TAO/tao/MessagingS.i b/TAO/tao/MessagingS.i index 7c2d08ea338..cb169078791 100644 --- a/TAO/tao/MessagingS.i +++ b/TAO/tao/MessagingS.i @@ -1,7 +1,6 @@ /* -*- C++ -*- */ // $Id$ - // ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* // TAO and the TAO IDL Compiler have been developed by the Center for // Distributed Object Computing at Washington University, St. Louis. diff --git a/TAO/tao/MessagingS_T.cpp b/TAO/tao/MessagingS_T.cpp index 73bda811ed7..71addde084d 100644 --- a/TAO/tao/MessagingS_T.cpp +++ b/TAO/tao/MessagingS_T.cpp @@ -1,7 +1,6 @@ /* -*- C++ -*- */ // $Id$ - // ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* // TAO and the TAO IDL Compiler have been developed by the Center for // Distributed Object Computing at Washington University, St. Louis. diff --git a/TAO/tao/MessagingS_T.i b/TAO/tao/MessagingS_T.i index fb78d665235..00d92c671cb 100644 --- a/TAO/tao/MessagingS_T.i +++ b/TAO/tao/MessagingS_T.i @@ -1,7 +1,6 @@ /* -*- C++ -*- */ // $Id$ - // ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* // TAO and the TAO IDL Compiler have been developed by the Center for // Distributed Object Computing at Washington University, St. Louis. diff --git a/TAO/tao/Messaging_Policy_i.cpp b/TAO/tao/Messaging_Policy_i.cpp index e1547516d16..67a0a0f32cb 100644 --- a/TAO/tao/Messaging_Policy_i.cpp +++ b/TAO/tao/Messaging_Policy_i.cpp @@ -1,7 +1,5 @@ // $Id$ - - #include "tao/Messaging_Policy_i.h" #if (TAO_HAS_CORBA_MESSAGING == 1) @@ -14,7 +12,6 @@ ACE_RCSID(TAO, Messaging_Policy_i, "$Id$") - TAO_RelativeRoundtripTimeoutPolicy::TAO_RelativeRoundtripTimeoutPolicy (PortableServer::POA_ptr poa, const TimeBase::TimeT& relative_expiry) : poa_ (PortableServer::POA::_duplicate (poa)), diff --git a/TAO/tao/Messaging_Policy_i.h b/TAO/tao/Messaging_Policy_i.h index 828e9910931..9b5cf34fc05 100644 --- a/TAO/tao/Messaging_Policy_i.h +++ b/TAO/tao/Messaging_Policy_i.h @@ -1,6 +1,5 @@ /* -*- C++ -*- */ // $Id$ - // // ============================================================================ // diff --git a/TAO/tao/Messaging_Policy_i.i b/TAO/tao/Messaging_Policy_i.i index 907a5bd4dec..dc9fb6240c0 100644 --- a/TAO/tao/Messaging_Policy_i.i +++ b/TAO/tao/Messaging_Policy_i.i @@ -11,4 +11,3 @@ TAO_Sync_Scope_Policy::synchronization (void) { return this->synchronization_; } - diff --git a/TAO/tao/NVList.cpp b/TAO/tao/NVList.cpp index 182513c3245..90baedd7f5b 100644 --- a/TAO/tao/NVList.cpp +++ b/TAO/tao/NVList.cpp @@ -1,6 +1,5 @@ // $Id$ - // Implementation of Named Value List and NamedValue classes #include "tao/NVList.h" @@ -19,7 +18,6 @@ ACE_RCSID(tao, NVList, "$Id$") - // Reference counting for DII Request object CORBA::ULong diff --git a/TAO/tao/ORB.cpp b/TAO/tao/ORB.cpp index e55d8a7e73d..7e634fc5fe1 100644 --- a/TAO/tao/ORB.cpp +++ b/TAO/tao/ORB.cpp @@ -1,6 +1,5 @@ // $Id$ - #include "tao/ORB.h" #include "tao/Acceptor_Registry.h" #include "tao/Connector_Registry.h" @@ -66,8 +65,8 @@ using std::set_unexpected; # include "tao/ORB.i" #endif /* ! __ACE_INLINE__ */ -ACE_RCSID(tao, ORB, "$Id$") +ACE_RCSID(tao, ORB, "$Id$") static const char ior_prefix [] = "IOR:"; static const char file_prefix[] = "file://"; @@ -88,18 +87,10 @@ operator<< (TAO_OutputCDR &strm, return 0; } -CORBA::Boolean operator>> (TAO_InputCDR &strm, - CORBA::ORB::InvalidName &_tao_aggregate) +CORBA::Boolean operator>> (TAO_InputCDR &, + CORBA::ORB::InvalidName &) { - // retrieve RepoID and verify if we are of that type - char *_tao_repoID; - if ((strm >> _tao_repoID) && - (_tao_aggregate._is_a (_tao_repoID))) - { - return 1; - } - else - return 0; + return 1; } CORBA_ORB::InvalidName::InvalidName (void) @@ -134,16 +125,36 @@ CORBA_ORB::InvalidName::_narrow (CORBA_Exception *ex) return 0; } -void -CORBA_ORB::InvalidName::_raise (void) +void CORBA_ORB::InvalidName::_raise (void) { TAO_RAISE(*this); } +void CORBA_ORB::InvalidName::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void CORBA_ORB::InvalidName::_tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + // TAO extension - the _alloc method -CORBA::Exception *CORBA::ORB::InvalidName::_alloc (void) +CORBA::Exception * +CORBA::ORB::InvalidName::_alloc (void) { - return new CORBA::ORB::InvalidName; + CORBA::ORB::InvalidName *retval = 0; + ACE_NEW_RETURN (retval, + CORBA::ORB::InvalidName, + 0); + return retval; } CORBA_ORB::CORBA_ORB (TAO_ORB_Core *orb_core) @@ -304,7 +315,12 @@ CORBA_ORB::create_list (CORBA::Long count, for (CORBA::Long i=0; i < count; i++) { - CORBA::NamedValue_ptr nv = new CORBA::NamedValue; + CORBA::NamedValue_ptr nv = 0; + ACE_NEW_THROW_EX (nv, + CORBA::NamedValue, + CORBA::NO_MEMORY ()); + ACE_CHECK; + new_list->values_.enqueue_tail (nv); } } diff --git a/TAO/tao/ORB.h b/TAO/tao/ORB.h index 55e3aee76ca..fd6f82687f1 100644 --- a/TAO/tao/ORB.h +++ b/TAO/tao/ORB.h @@ -2,7 +2,6 @@ // $Id$ - // ============================================================================ // // = LIBRARY @@ -315,6 +314,12 @@ public: InvalidName &operator= (const InvalidName &); virtual void _raise (void); + + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static InvalidName* _narrow (CORBA_Exception *ex); // = TAO extension static CORBA::Exception *_alloc (void); diff --git a/TAO/tao/ORB_Core.cpp b/TAO/tao/ORB_Core.cpp index e09f874d776..0ec21043bf6 100644 --- a/TAO/tao/ORB_Core.cpp +++ b/TAO/tao/ORB_Core.cpp @@ -1,8 +1,6 @@ // $Id$ - - #include "tao/ORB_Core.h" #include "ace/Env_Value_T.h" @@ -42,10 +40,8 @@ # include "tao/ORB_Core.i" #endif /* ! __ACE_INLINE__ */ - ACE_RCSID(tao, ORB_Core, "$Id$") - // **************************************************************** CORBA::Environment & @@ -67,7 +63,7 @@ TAO_ORB_Core::TAO_ORB_Core (const char *orbid) root_poa_ (0), root_poa_reference_ (), orb_params_ (), - orbid_ (ACE_OS::strdup (orbid?orbid:"")), + orbid_ (ACE_OS::strdup (orbid ? orbid : "")), resource_factory_ (0), resource_factory_from_service_config_ (0), // @@ This is not needed since the default resource factory, fredk @@ -345,7 +341,6 @@ TAO_ORB_Core::init (int &argc, char *argv[], CORBA::Environment &ACE_TRY_ENV) // warning this turns on a daemon ACE::debug (1); TAO_orbdebug = 1; - arg_shifter.consume_arg (); } @@ -1268,12 +1263,14 @@ TAO_ORB_Core::fini (void) // is statically added to the service configurator, fredk if (!this->resource_factory_from_service_config_) delete resource_factory_; + // @@ This is not needed since the default client factory // is statically added to the service configurator, fredk if (!this->client_factory_from_service_config_) delete client_factory_; + // @@ This is not needed since the default server factory // is statically added to the service configurator, fredk if (!this->server_factory_from_service_config_) @@ -1286,6 +1283,7 @@ TAO_ORB_Core::fini (void) } delete this->reactor_registry_; + #if (TAO_HAS_RT_CORBA == 1) delete this->priority_mapping_; #endif /* TAO_HAS_RT_CORBA == 1 */ diff --git a/TAO/tao/ORB_Core.h b/TAO/tao/ORB_Core.h index b4ef0128361..27b7a7036ab 100644 --- a/TAO/tao/ORB_Core.h +++ b/TAO/tao/ORB_Core.h @@ -1,8 +1,6 @@ // This may look like C, but it's really -*- C++ -*- // $Id$ - - // ============================================================================ // // = LIBRARY diff --git a/TAO/tao/Object.cpp b/TAO/tao/Object.cpp index c1066ecbba9..a4bbfc1fd80 100644 --- a/TAO/tao/Object.cpp +++ b/TAO/tao/Object.cpp @@ -1,5 +1,4 @@ // @(#) $Id$ - // // Copyright 1994-1995 by Sun Microsystems Inc. // All Rights Reserved @@ -30,7 +29,6 @@ ACE_RCSID(tao, Object, "$Id$") - CORBA_Object::~CORBA_Object (void) { if (this->protocol_proxy_) @@ -253,41 +251,42 @@ CORBA::Object::_use_locate_requests (CORBA::Boolean use_it) CORBA::Boolean CORBA_Object::_non_existent (CORBA::Environment &ACE_TRY_ENV) { - // If the object is collocated then try locally.... - if (this->is_collocated_) + CORBA::Boolean _tao_retval = 0; + + ACE_TRY { - // Which collocation strategy should we use? - if (this->protocol_proxy_ != 0 && - this->protocol_proxy_->servant_orb_var ()->orb_core () - ->get_collocation_strategy () == TAO_ORB_Core::THRU_POA) + // If the object is collocated then try locally.... + if (this->is_collocated_) { - TAO_Object_Adapter::Servant_Upcall servant_upcall - (*this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()); - servant_upcall.prepare_for_upcall (this->_object_key (), - "_non_existent", - ACE_TRY_ENV); - ACE_CHECK_RETURN (0); - return servant_upcall.servant ()->_non_existent (ACE_TRY_ENV); - } + // Which collocation strategy should we use? + if (this->protocol_proxy_ != 0 && + this->protocol_proxy_->servant_orb_var ()->orb_core () + ->get_collocation_strategy () == TAO_ORB_Core::THRU_POA) + { + TAO_Object_Adapter::Servant_Upcall servant_upcall + (*this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()); + servant_upcall.prepare_for_upcall (this->_object_key (), + "_non_existent", + ACE_TRY_ENV); + ACE_TRY_CHECK; + return servant_upcall.servant ()->_non_existent (ACE_TRY_ENV); + } - // Direct collocation strategy is used. - if (this->servant_ != 0) - return this->servant_->_non_existent (ACE_TRY_ENV); - } + // Direct collocation strategy is used. + if (this->servant_ != 0) + return this->servant_->_non_existent (ACE_TRY_ENV); + } - CORBA::Boolean _tao_retval = 0; - // Must catch exceptions, if the server raises a - // CORBA::OBJECT_NOT_EXIST then we must return 1, instead of - // propagating the exception. - ACE_TRY - { + // Must catch exceptions, if the server raises a + // CORBA::OBJECT_NOT_EXIST then we must return 1, instead of + // propagating the exception. TAO_Stub *istub = this->_stubobj (); if (istub == 0) ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval); TAO_GIOP_Twoway_Invocation _tao_call ( - istub, + istub, "_non_existent", 13, istub->orb_core () diff --git a/TAO/tao/Object.h b/TAO/tao/Object.h index be14063a7a9..2d2576a724e 100644 --- a/TAO/tao/Object.h +++ b/TAO/tao/Object.h @@ -2,7 +2,6 @@ // $Id$ - // ============================================================================ // // = LIBRARY @@ -51,6 +50,9 @@ public: static CORBA_Object_ptr _narrow (CORBA_Object_ptr obj, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); + static CORBA_Object_ptr _unchecked_narrow (CORBA_Object_ptr obj, + CORBA_Environment &ACE_TRY_ENV = + TAO_default_environment ()); // no-op it is just here to simplify some templates. // These calls correspond to over-the-wire operations, or at least diff --git a/TAO/tao/Object.i b/TAO/tao/Object.i index ba601235b64..232315bddfc 100644 --- a/TAO/tao/Object.i +++ b/TAO/tao/Object.i @@ -45,6 +45,12 @@ CORBA_Object::_narrow (CORBA_Object_ptr obj, CORBA::Environment&) return CORBA_Object::_duplicate (obj); } +ACE_INLINE CORBA_Object_ptr +CORBA_Object::_unchecked_narrow (CORBA_Object_ptr obj, CORBA::Environment&) +{ + return CORBA_Object::_duplicate (obj); +} + ACE_INLINE TAO_Stub * CORBA_Object::_stubobj (void) const { diff --git a/TAO/tao/ObjectIDList.h b/TAO/tao/ObjectIDList.h index 5c3b871af7f..514fdcba836 100644 --- a/TAO/tao/ObjectIDList.h +++ b/TAO/tao/ObjectIDList.h @@ -1,6 +1,5 @@ /* -*- C++ -*- */ // $Id$ - // ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* // TAO and the TAO IDL Compiler have been developed by the Center for // Distributed Object Computing at Washington University, St. Louis. diff --git a/TAO/tao/Object_Adapter.cpp b/TAO/tao/Object_Adapter.cpp index d2e23419a08..b46c990226f 100644 --- a/TAO/tao/Object_Adapter.cpp +++ b/TAO/tao/Object_Adapter.cpp @@ -1,6 +1,5 @@ // $Id$ - #include "tao/Object_Adapter.h" #include "tao/POA.h" #include "tao/ORB.h" @@ -12,10 +11,8 @@ # include "tao/Object_Adapter.i" #endif /* __ACE_INLINE__ */ - ACE_RCSID(tao, Object_Adapter, "$Id$") - // Timeprobes class #include "tao/Timeprobe.h" @@ -1098,8 +1095,13 @@ TAO_POA_Current_Impl::get_POA (CORBA::Environment &ACE_TRY_ENV) PortableServer::ObjectId * TAO_POA_Current_Impl::get_object_id (CORBA::Environment &) { + PortableServer::ObjectId *objid = 0; + // Create a new one and pass it back - return new PortableServer::ObjectId (this->object_id_); + ACE_NEW_RETURN (objid, + PortableServer::ObjectId (this->object_id_), + 0); + return objid; } TAO_ORB_Core & diff --git a/TAO/tao/Object_Adapter.h b/TAO/tao/Object_Adapter.h index 832498ffecd..145f2e7a45b 100644 --- a/TAO/tao/Object_Adapter.h +++ b/TAO/tao/Object_Adapter.h @@ -1,7 +1,6 @@ /* -*- C++ -*- */ // $Id$ - // ============================================================================ // // = LIBRARY diff --git a/TAO/tao/Object_Adapter.i b/TAO/tao/Object_Adapter.i index 80658bbf819..1fdd4613a0d 100644 --- a/TAO/tao/Object_Adapter.i +++ b/TAO/tao/Object_Adapter.i @@ -1,7 +1,6 @@ // $Id$ - ACE_INLINE TAO_POA_Current::TAO_POA_Current (void) { diff --git a/TAO/tao/Operation_Table.cpp b/TAO/tao/Operation_Table.cpp index 06037d9dd66..d5992812b44 100644 --- a/TAO/tao/Operation_Table.cpp +++ b/TAO/tao/Operation_Table.cpp @@ -6,7 +6,6 @@ ACE_RCSID(tao, Operation_Table, "$Id$") - #if defined (ACE_ENABLE_TIMEPROBES) static const char *TAO_Operation_Table_Timeprobe_Description[] = diff --git a/TAO/tao/POA.cpp b/TAO/tao/POA.cpp index f3b0af9fed9..4817ca2033c 100644 --- a/TAO/tao/POA.cpp +++ b/TAO/tao/POA.cpp @@ -1,6 +1,5 @@ // @(#) $Id$ - // auto_ptr class #include "ace/Auto_Ptr.h" @@ -80,7 +79,6 @@ private: ACE_RCSID(tao, POA, "$Id$") - #if !defined (TAO_NO_IOR_TABLE) // This is the TAO_Object_key-prefix that is appended to all TAO Object keys. // It's an array of octets representing ^t^a^o/0 in octal. @@ -1251,7 +1249,13 @@ TAO_POA::create_reference_i (const char *intf, { // Otherwise, it is the NON_RETAIN policy. Therefore, any ol' // object id will do (even an empty one). - system_id = new PortableServer::ObjectId; + PortableServer::ObjectId *sys_id; + ACE_NEW_THROW_EX (sys_id, + PortableServer::ObjectId, + CORBA::NO_MEMORY ()); + ACE_CHECK_RETURN (CORBA::Object::_nil ()); + + system_id = sys_id; } // Create object key. @@ -1311,14 +1315,20 @@ TAO_POA::create_reference_with_id_i (const PortableServer::ObjectId &user_id, system_id.out ()) != 0) { ACE_THROW_RETURN (CORBA::OBJ_ADAPTER (), - CORBA::Object::_nil ()); + CORBA::Object::_nil ()); } } else { // Otherwise, it is the NON_RETAIN policy. Therefore, user id // is the same as system id. - system_id = new PortableServer::ObjectId (user_id); + PortableServer::ObjectId *sys_id; + ACE_NEW_THROW_EX (sys_id, + PortableServer::ObjectId (user_id), + CORBA::NO_MEMORY ()); + ACE_CHECK_RETURN (CORBA::Object::_nil ()); + + system_id = sys_id; } // Create object key. @@ -3678,7 +3688,7 @@ void TAO_POA::imr_notify_startup (CORBA_Environment &ACE_TRY_ENV) { if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, "Notifing IMR of Startup\n")); + ACE_DEBUG ((LM_DEBUG, "Notifying IMR of startup\n")); CORBA::Object_var imr = this->orb_core ().implrepo_service (); diff --git a/TAO/tao/POA.h b/TAO/tao/POA.h index bf48a65db3e..80992ac85c5 100644 --- a/TAO/tao/POA.h +++ b/TAO/tao/POA.h @@ -1,7 +1,6 @@ // -*- C++ -*- // $Id$ - // ============================================================================ // // = LIBRARY diff --git a/TAO/tao/POA.i b/TAO/tao/POA.i index 2d64e984f8f..58f279abb31 100644 --- a/TAO/tao/POA.i +++ b/TAO/tao/POA.i @@ -1,6 +1,5 @@ // $Id$ - // Exception macros #include "tao/poa_macros.h" #include "tao/Environment.h" diff --git a/TAO/tao/POAC.cpp b/TAO/tao/POAC.cpp index ce8b486efa2..8f7c0a234fc 100644 --- a/TAO/tao/POAC.cpp +++ b/TAO/tao/POAC.cpp @@ -1,5 +1,4 @@ // $Id$ - // // ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* // TAO ORB and the TAO IDL Compiler have been developed by Washington @@ -24,10 +23,8 @@ #include "tao/POAC.i" #endif // !defined INLINE - ACE_RCSID(tao, POAC, "$Id$") - #if !defined (_PORTABLESERVER__TAO_SEQ_OCTET_CS_) #define _PORTABLESERVER__TAO_SEQ_OCTET_CS_ @@ -110,6 +107,22 @@ void PortableServer::ForwardRequest::_raise (void) TAO_RAISE(*this); } +void PortableServer::ForwardRequest::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void PortableServer::ForwardRequest::_tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + // narrow PortableServer::ForwardRequest_ptr PortableServer::ForwardRequest::_narrow (CORBA::Exception *exc) @@ -135,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; } @@ -154,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; } @@ -166,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 ()) { @@ -176,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; @@ -1414,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 @@ -1479,6 +1590,22 @@ void PortableServer::POAManager::AdapterInactive::_raise (void) TAO_RAISE(*this); } +void PortableServer::POAManager::AdapterInactive::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void PortableServer::POAManager::AdapterInactive::_tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + // narrow PortableServer::POAManager::AdapterInactive_ptr PortableServer::POAManager::AdapterInactive::_narrow (CORBA::Exception *exc) @@ -1501,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 @@ -1983,6 +2042,22 @@ void PortableServer::POA::AdapterAlreadyExists::_raise (void) TAO_RAISE(*this); } +void PortableServer::POA::AdapterAlreadyExists::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void PortableServer::POA::AdapterAlreadyExists::_tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + // narrow PortableServer::POA::AdapterAlreadyExists_ptr PortableServer::POA::AdapterAlreadyExists::_narrow (CORBA::Exception *exc) @@ -2005,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 @@ -2118,6 +2125,22 @@ void PortableServer::POA::AdapterInactive::_raise (void) TAO_RAISE(*this); } +void PortableServer::POA::AdapterInactive::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void PortableServer::POA::AdapterInactive::_tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + // narrow PortableServer::POA::AdapterInactive_ptr PortableServer::POA::AdapterInactive::_narrow (CORBA::Exception *exc) @@ -2140,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 @@ -2253,6 +2208,22 @@ void PortableServer::POA::AdapterNonExistent::_raise (void) TAO_RAISE(*this); } +void PortableServer::POA::AdapterNonExistent::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void PortableServer::POA::AdapterNonExistent::_tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + // narrow PortableServer::POA::AdapterNonExistent_ptr PortableServer::POA::AdapterNonExistent::_narrow (CORBA::Exception *exc) @@ -2275,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 @@ -2395,6 +2298,22 @@ void PortableServer::POA::InvalidPolicy::_raise (void) TAO_RAISE(*this); } +void PortableServer::POA::InvalidPolicy::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void PortableServer::POA::InvalidPolicy::_tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + // narrow PortableServer::POA::InvalidPolicy_ptr PortableServer::POA::InvalidPolicy::_narrow (CORBA::Exception *exc) @@ -2417,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 @@ -2533,6 +2384,22 @@ void PortableServer::POA::NoServant::_raise (void) TAO_RAISE(*this); } +void PortableServer::POA::NoServant::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void PortableServer::POA::NoServant::_tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + // narrow PortableServer::POA::NoServant_ptr PortableServer::POA::NoServant::_narrow (CORBA::Exception *exc) @@ -2555,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 @@ -2670,6 +2469,22 @@ void PortableServer::POA::ObjectAlreadyActive::_raise (void) TAO_RAISE(*this); } +void PortableServer::POA::ObjectAlreadyActive::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void PortableServer::POA::ObjectAlreadyActive::_tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + // narrow PortableServer::POA::ObjectAlreadyActive_ptr PortableServer::POA::ObjectAlreadyActive::_narrow (CORBA::Exception *exc) @@ -2692,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 @@ -2803,6 +2550,22 @@ void PortableServer::POA::ObjectNotActive::_raise (void) TAO_RAISE(*this); } +void PortableServer::POA::ObjectNotActive::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void PortableServer::POA::ObjectNotActive::_tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + // narrow PortableServer::POA::ObjectNotActive_ptr PortableServer::POA::ObjectNotActive::_narrow (CORBA::Exception *exc) @@ -2825,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 @@ -2936,6 +2631,22 @@ void PortableServer::POA::ServantAlreadyActive::_raise (void) TAO_RAISE(*this); } +void PortableServer::POA::ServantAlreadyActive::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void PortableServer::POA::ServantAlreadyActive::_tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + // narrow PortableServer::POA::ServantAlreadyActive_ptr PortableServer::POA::ServantAlreadyActive::_narrow (CORBA::Exception *exc) @@ -2958,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 @@ -3069,6 +2712,22 @@ void PortableServer::POA::ServantNotActive::_raise (void) TAO_RAISE(*this); } +void PortableServer::POA::ServantNotActive::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void PortableServer::POA::ServantNotActive::_tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + // narrow PortableServer::POA::ServantNotActive_ptr PortableServer::POA::ServantNotActive::_narrow (CORBA::Exception *exc) @@ -3091,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 @@ -3202,6 +2793,22 @@ void PortableServer::POA::WrongAdapter::_raise (void) TAO_RAISE(*this); } +void PortableServer::POA::WrongAdapter::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void PortableServer::POA::WrongAdapter::_tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + // narrow PortableServer::POA::WrongAdapter_ptr PortableServer::POA::WrongAdapter::_narrow (CORBA::Exception *exc) @@ -3224,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 @@ -3335,6 +2874,22 @@ void PortableServer::POA::WrongPolicy::_raise (void) TAO_RAISE(*this); } +void PortableServer::POA::WrongPolicy::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void PortableServer::POA::WrongPolicy::_tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + // narrow PortableServer::POA::WrongPolicy_ptr PortableServer::POA::WrongPolicy::_narrow (CORBA::Exception *exc) @@ -3357,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 @@ -3541,6 +3028,22 @@ void PortableServer::Current::NoContext::_raise (void) TAO_RAISE(*this); } +void PortableServer::Current::NoContext::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void PortableServer::Current::NoContext::_tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + // narrow PortableServer::Current::NoContext_ptr PortableServer::Current::NoContext::_narrow (CORBA::Exception *exc) @@ -3563,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 @@ -3760,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 b96ec311aa8..e3d592ce9a7 100644 --- a/TAO/tao/POAC.h +++ b/TAO/tao/POAC.h @@ -1,5 +1,4 @@ // $Id$ - // // ============================================================================ // @@ -224,8 +223,14 @@ TAO_NAMESPACE PortableServer{ ForwardRequest (const ForwardRequest &); // copy ctor ~ForwardRequest (void); // dtor ForwardRequest &operator= (const ForwardRequest &); + virtual void _raise (void); + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static ForwardRequest *_narrow (CORBA::Exception *); ForwardRequest( @@ -1124,6 +1129,7 @@ TAO_NAMESPACE PortableServer{ DISCARDING, INACTIVE }; + static CORBA::TypeCode_ptr _tc_State; // the static operations static POAManager_ptr _duplicate (POAManager_ptr obj); @@ -1150,6 +1156,12 @@ TAO_NAMESPACE PortableServer{ ~AdapterInactive (void); // dtor AdapterInactive &operator= (const AdapterInactive &); virtual void _raise (void); + + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static AdapterInactive *_narrow (CORBA::Exception *); // = TAO extension @@ -1652,7 +1664,7 @@ TAO_NAMESPACE PortableServer{ #if !defined (_PORTABLESERVER_POA_CH_) #define _PORTABLESERVER_POA_CH_ - class TAO_Export POA: public virtual ACE_CORBA_1 (Object) + class TAO_Export POA : public virtual ACE_CORBA_1 (Object) { public: #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8 @@ -1685,6 +1697,12 @@ TAO_NAMESPACE PortableServer{ ~AdapterAlreadyExists (void); // dtor AdapterAlreadyExists &operator= (const AdapterAlreadyExists &); virtual void _raise (void); + + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static AdapterAlreadyExists *_narrow (CORBA::Exception *); // = TAO extension @@ -1719,6 +1737,12 @@ TAO_NAMESPACE PortableServer{ ~AdapterInactive (void); // dtor AdapterInactive &operator= (const AdapterInactive &); virtual void _raise (void); + + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static AdapterInactive *_narrow (CORBA::Exception *); // = TAO extension @@ -1758,6 +1782,12 @@ TAO_NAMESPACE PortableServer{ ~AdapterNonExistent (void); // dtor AdapterNonExistent &operator= (const AdapterNonExistent &); virtual void _raise (void); + + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static AdapterNonExistent *_narrow (CORBA::Exception *); // = TAO extension @@ -1795,6 +1825,12 @@ TAO_NAMESPACE PortableServer{ ~InvalidPolicy (void); // dtor InvalidPolicy &operator= (const InvalidPolicy &); virtual void _raise (void); + + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static InvalidPolicy *_narrow (CORBA::Exception *); InvalidPolicy( @@ -1840,6 +1876,12 @@ TAO_NAMESPACE PortableServer{ ~NoServant (void); // dtor NoServant &operator= (const NoServant &); virtual void _raise (void); + + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static NoServant *_narrow (CORBA::Exception *); // = TAO extension @@ -1879,6 +1921,12 @@ TAO_NAMESPACE PortableServer{ ~ObjectAlreadyActive (void); // dtor ObjectAlreadyActive &operator= (const ObjectAlreadyActive &); virtual void _raise (void); + + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static ObjectAlreadyActive *_narrow (CORBA::Exception *); // = TAO extension @@ -1916,6 +1964,12 @@ TAO_NAMESPACE PortableServer{ ~ObjectNotActive (void); // dtor ObjectNotActive &operator= (const ObjectNotActive &); virtual void _raise (void); + + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static ObjectNotActive *_narrow (CORBA::Exception *); // = TAO extension @@ -1953,6 +2007,12 @@ TAO_NAMESPACE PortableServer{ ~ServantAlreadyActive (void); // dtor ServantAlreadyActive &operator= (const ServantAlreadyActive &); virtual void _raise (void); + + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static ServantAlreadyActive *_narrow (CORBA::Exception *); // = TAO extension @@ -1990,6 +2050,12 @@ TAO_NAMESPACE PortableServer{ ~ServantNotActive (void); // dtor ServantNotActive &operator= (const ServantNotActive &); virtual void _raise (void); + + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static ServantNotActive *_narrow (CORBA::Exception *); // = TAO extension @@ -2027,6 +2093,12 @@ TAO_NAMESPACE PortableServer{ ~WrongAdapter (void); // dtor WrongAdapter &operator= (const WrongAdapter &); virtual void _raise (void); + + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static WrongAdapter *_narrow (CORBA::Exception *); // = TAO extension @@ -2064,6 +2136,12 @@ TAO_NAMESPACE PortableServer{ ~WrongPolicy (void); // dtor WrongPolicy &operator= (const WrongPolicy &); virtual void _raise (void); + + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static WrongPolicy *_narrow (CORBA::Exception *); // = TAO extension @@ -2246,6 +2324,12 @@ TAO_NAMESPACE PortableServer{ ~NoContext (void); // dtor NoContext &operator= (const NoContext &); virtual void _raise (void); + + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static NoContext *_narrow (CORBA::Exception *); // = TAO extension @@ -2293,119 +2377,252 @@ TAO_NAMESPACE PortableServer{ } TAO_NAMESPACE_CLOSE -#if defined (__ACE_INLINE__) -#include "tao/POAC.i" -#else +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 *&); -// POA's policies. +#if !defined (TAO_HAS_MINIMUM_CORBA) + +TAO_Export void operator<<= (CORBA::Any &, const PortableServer::ForwardRequest &); // copying version +TAO_Export void operator<<= (CORBA::Any &, PortableServer::ForwardRequest*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::ForwardRequest *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const PortableServer::ForwardRequest *&); + +#endif /* TAO_HAS_MINIMUM_CORBA */ #if (TAO_HAS_MINIMUM_POA == 0) -TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ThreadPolicyValue &); // -TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::ThreadPolicyValue &); -TAO_Export CORBA::Boolean -operator<< (TAO_OutputCDR &, const PortableServer::ThreadPolicy_ptr ); -TAO_Export CORBA::Boolean -operator>> (TAO_InputCDR &, PortableServer::ThreadPolicy_ptr &); +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 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::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::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 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 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::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::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 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 */ -// 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>>= (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 *&); +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 *&); +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 *&); +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 *&); +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 *&); +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 *&); +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 *&); +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 *&); +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 *&); +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 *&); +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 + +// POA's policies. + +#if (TAO_HAS_MINIMUM_POA == 0) + +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ThreadPolicyValue &); // +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::ThreadPolicyValue &); +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::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::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 &); + +#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::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::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 &); + +#endif /* TAO_HAS_MINIMUM_POA == 0 */ + +// POA's exceptions. +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::POA::AdapterAlreadyExists &_tao_aggregate); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::POA::AdapterAlreadyExists &); + +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 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 CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::POA::ObjectAlreadyActive &); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::POA::ObjectAlreadyActive &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::POA::ObjectNotActive &); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::POA::ObjectNotActive &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::POA::ServantAlreadyActive &); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::POA::ServantAlreadyActive &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::POA::ServantNotActive &); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::POA::ServantNotActive &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::POA::WrongAdapter &); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::POA::WrongAdapter &); +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. -TAO_Export CORBA::Boolean -operator<< (TAO_OutputCDR &, const PortableServer::Current_ptr ); -TAO_Export CORBA::Boolean -operator>> (TAO_InputCDR &, PortableServer::Current_ptr &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::Current_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::Current_ptr &); 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::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::POA_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::POA_ptr &); + #endif /* defined INLINE */ #if defined(_MSC_VER) && (_MSC_VER >= 1200) diff --git a/TAO/tao/POAC.i b/TAO/tao/POAC.i index 318766a207d..3c154586aab 100644 --- a/TAO/tao/POAC.i +++ b/TAO/tao/POAC.i @@ -1,5 +1,4 @@ // $Id$ - // // ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* // TAO ORB and the TAO IDL Compiler have been developed by Washington @@ -3090,6 +3089,58 @@ PortableServer::Current_out::operator-> (void) return this->ptr_; } +#endif // end #if !defined + +// **************************************************************** + +#if (TAO_HAS_MINIMUM_POA == 0) + +ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::ForwardRequest &_tao_aggregate) +{ + // first marshal the repository ID + if (strm << _tao_aggregate._id ()) + { + // now marshal the members (if any) + if ( + (strm << _tao_aggregate.forward_reference.in ()) + ) + return 1; + else + return 0; + } + else + return 0; +} + +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm,PortableServer::ForwardRequest &_tao_aggregate) +{ + // now marshal the members + if ( + (strm >> _tao_aggregate.forward_reference.out ()) + ) + return 1; + else + return 0; +} + +#endif /* TAO_HAS_MINIMUM_POA == 0 */ + +ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::POAManager::AdapterInactive &_tao_aggregate) +{ + // first marshal the repository ID + if (strm << _tao_aggregate._id ()) + return 1; + else + return 0; +} + +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &,PortableServer::POAManager::AdapterInactive &) +{ + return 1; +} + +// **************************************************************** + ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::ThreadPolicyValue &_tao_enumval) { return strm.write_ulong ((CORBA::ULong) _tao_enumval); @@ -3570,17 +3621,9 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer: return 0; } -ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::POA::AdapterAlreadyExists &_tao_aggregate) +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::POA::AdapterAlreadyExists &) { - // retrieve RepoID and verify if we are of that type - char *_tao_repoID; - if ((strm >> _tao_repoID) && - (_tao_aggregate._is_a (_tao_repoID))) - { - return 1; - } - else - return 0; + return 1; } #if (TAO_HAS_MINIMUM_POA == 0) @@ -3594,17 +3637,9 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer: return 0; } -ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::POA::AdapterInactive &_tao_aggregate) +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::POA::AdapterInactive &) { - // retrieve RepoID and verify if we are of that type - char *_tao_repoID; - if ((strm >> _tao_repoID) && - (_tao_aggregate._is_a (_tao_repoID))) - { - return 1; - } - else - return 0; + return 1; } #endif /* TAO_HAS_MINIMUM_POA == 0 */ @@ -3618,17 +3653,9 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer: return 0; } -ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::POA::AdapterNonExistent &_tao_aggregate) +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::POA::AdapterNonExistent &) { - // retrieve RepoID and verify if we are of that type - char *_tao_repoID; - if ((strm >> _tao_repoID) && - (_tao_aggregate._is_a (_tao_repoID))) - { - return 1; - } - else - return 0; + return 1; } ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::POA::InvalidPolicy &_tao_aggregate) @@ -3648,19 +3675,10 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer: ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::POA::InvalidPolicy &_tao_aggregate) { - // retrieve RepoID and verify if we are of that type - char *_tao_repoID; - if ((strm >> _tao_repoID) && - (_tao_aggregate._is_a (_tao_repoID))) - { - // now marshal the members - if ((strm >> _tao_aggregate.index)) - return 1; - else - return 0; - } - else - return 0; + // now marshal the members + if ((strm >> _tao_aggregate.index)) + return 1; + return 0; } #if (TAO_HAS_MINIMUM_POA == 0) @@ -3674,17 +3692,9 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer: return 0; } -ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::POA::NoServant &_tao_aggregate) +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::POA::NoServant &) { - // retrieve RepoID and verify if we are of that type - char *_tao_repoID; - if ((strm >> _tao_repoID) && - (_tao_aggregate._is_a (_tao_repoID))) - { - return 1; - } - else - return 0; + return 1; } #endif /* TAO_HAS_MINIMUM_POA == 0 */ @@ -3698,17 +3708,9 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer: return 0; } -ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::POA::ObjectAlreadyActive &_tao_aggregate) +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::POA::ObjectAlreadyActive &) { - // retrieve RepoID and verify if we are of that type - char *_tao_repoID; - if ((strm >> _tao_repoID) && - (_tao_aggregate._is_a (_tao_repoID))) - { - return 1; - } - else - return 0; + return 1; } ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::POA::ObjectNotActive &_tao_aggregate) @@ -3720,17 +3722,9 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer: return 0; } -ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::POA::ObjectNotActive &_tao_aggregate) +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::POA::ObjectNotActive &) { - // retrieve RepoID and verify if we are of that type - char *_tao_repoID; - if ((strm >> _tao_repoID) && - (_tao_aggregate._is_a (_tao_repoID))) - { - return 1; - } - else - return 0; + return 1; } ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::POA::ServantAlreadyActive &_tao_aggregate) @@ -3742,17 +3736,9 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer: return 0; } -ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::POA::ServantAlreadyActive &_tao_aggregate) +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::POA::ServantAlreadyActive &) { - // retrieve RepoID and verify if we are of that type - char *_tao_repoID; - if ((strm >> _tao_repoID) && - (_tao_aggregate._is_a (_tao_repoID))) - { - return 1; - } - else - return 0; + return 1; } ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::POA::ServantNotActive &_tao_aggregate) @@ -3764,17 +3750,9 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer: return 0; } -ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::POA::ServantNotActive &_tao_aggregate) +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::POA::ServantNotActive &) { - // retrieve RepoID and verify if we are of that type - char *_tao_repoID; - if ((strm >> _tao_repoID) && - (_tao_aggregate._is_a (_tao_repoID))) - { - return 1; - } - else - return 0; + return 1; } ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::POA::WrongAdapter &_tao_aggregate) @@ -3786,17 +3764,9 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer: return 0; } -ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::POA::WrongAdapter &_tao_aggregate) +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::POA::WrongAdapter &) { - // retrieve RepoID and verify if we are of that type - char *_tao_repoID; - if ((strm >> _tao_repoID) && - (_tao_aggregate._is_a (_tao_repoID))) - { - return 1; - } - else - return 0; + return 1; } ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer::POA::WrongPolicy &_tao_aggregate) @@ -3808,17 +3778,9 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer: return 0; } -ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::POA::WrongPolicy &_tao_aggregate) +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::POA::WrongPolicy &) { - // retrieve RepoID and verify if we are of that type - char *_tao_repoID; - if ((strm >> _tao_repoID) && - (_tao_aggregate._is_a (_tao_repoID))) - { - return 1; - } - else - return 0; + return 1; } @@ -3842,23 +3804,110 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const PortableServer: return 0; } -ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, PortableServer::Current::NoContext &_tao_aggregate) +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::Current::NoContext &) +{ + return 1; +} + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const PortableServer::Current_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::Current_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::Current::_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_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) { - // retrieve RepoID and verify if we are of that type - char *_tao_repoID; - if ((strm >> _tao_repoID) && - (_tao_aggregate._is_a (_tao_repoID))) + 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::Current_ptr _tao_objref + const PortableServer::AdapterActivator_ptr _tao_objref ) { CORBA::Object_ptr _tao_corba_obj = _tao_objref; @@ -3868,7 +3917,7 @@ operator<< ( ACE_INLINE CORBA::Boolean operator>> ( TAO_InputCDR &strm, - PortableServer::Current_ptr &_tao_objref + PortableServer::AdapterActivator_ptr &_tao_objref ) { ACE_TRY_NEW_ENV @@ -3878,7 +3927,7 @@ operator>> ( return 0; // narrow to the right type _tao_objref = - PortableServer::Current::_narrow ( + PortableServer::AdapterActivator::_narrow ( obj.in (), ACE_TRY_ENV ); @@ -3892,4 +3941,191 @@ operator>> ( ACE_ENDTRY; return 0; } -#endif // end #if !defined + +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/POAManager.cpp b/TAO/tao/POAManager.cpp index a90cbbcea59..8c86e550a06 100644 --- a/TAO/tao/POAManager.cpp +++ b/TAO/tao/POAManager.cpp @@ -1,6 +1,5 @@ // $Id$ - #include "tao/POAManager.h" #include "tao/POA.h" #include "tao/Server_Strategy_Factory.h" diff --git a/TAO/tao/POAManager.h b/TAO/tao/POAManager.h index 6193be9c459..2a15d65d946 100644 --- a/TAO/tao/POAManager.h +++ b/TAO/tao/POAManager.h @@ -1,7 +1,6 @@ // -*- C++ -*- // $Id$ - // ============================================================================ // // = LIBRARY diff --git a/TAO/tao/POAManager.i b/TAO/tao/POAManager.i index 3d2eeb154ba..b953dfd69b3 100644 --- a/TAO/tao/POAManager.i +++ b/TAO/tao/POAManager.i @@ -1,6 +1,5 @@ // $Id$ - #include "tao/Environment.h" ACE_INLINE ACE_Lock & diff --git a/TAO/tao/POAS.cpp b/TAO/tao/POAS.cpp index 2f486e2932a..0fcd784cdac 100644 --- a/TAO/tao/POAS.cpp +++ b/TAO/tao/POAS.cpp @@ -1,6 +1,5 @@ // $Id$ - // ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* // TAO ORB and the TAO IDL Compiler have been developed by Washington // University Computer Science's Distributed Object Computing Group. @@ -20,7 +19,6 @@ ACE_RCSID(tao, POAS, "$Id$") - #if (TAO_HAS_MINIMUM_POA == 0) #if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES) diff --git a/TAO/tao/POAS.h b/TAO/tao/POAS.h index 64926f26fa8..bb23b1fd692 100644 --- a/TAO/tao/POAS.h +++ b/TAO/tao/POAS.h @@ -1,5 +1,4 @@ // $Id$ - // // ============================================================================ // diff --git a/TAO/tao/POAS.i b/TAO/tao/POAS.i index 9806b9d3937..ba9c7e0c1ff 100644 --- a/TAO/tao/POAS.i +++ b/TAO/tao/POAS.i @@ -1,5 +1,4 @@ // $Id$ - // // ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* // TAO ORB and the TAO IDL Compiler have been developed by Washington diff --git a/TAO/tao/POA_CORBA.h b/TAO/tao/POA_CORBA.h index 25013083e0d..a1b9f1ba5f3 100644 --- a/TAO/tao/POA_CORBA.h +++ b/TAO/tao/POA_CORBA.h @@ -1,8 +1,6 @@ /* -*- C++ -*- */ // $Id$ - - // ============================================================================ // // = LIBRARY diff --git a/TAO/tao/Pluggable.cpp b/TAO/tao/Pluggable.cpp index 46f0c5959a4..e3ec12bc2b6 100644 --- a/TAO/tao/Pluggable.cpp +++ b/TAO/tao/Pluggable.cpp @@ -1,8 +1,6 @@ // This may look like C, but it's really -*- C++ -*- // $Id$ - - #include "tao/Pluggable.h" #include "tao/Stub.h" #include "tao/Environment.h" @@ -23,7 +21,6 @@ ACE_RCSID(tao, Pluggable, "$Id$") - // **************************************************************** // Constructor. diff --git a/TAO/tao/Pluggable.h b/TAO/tao/Pluggable.h index 37afa051970..699ee8b8021 100644 --- a/TAO/tao/Pluggable.h +++ b/TAO/tao/Pluggable.h @@ -1,8 +1,6 @@ // This may look like C, but it's really -*- C++ -*- // $Id$ - - // ============================================================================ // // = LIBRARY diff --git a/TAO/tao/Pluggable_Messaging.cpp b/TAO/tao/Pluggable_Messaging.cpp index 68dba64c85a..5a3f79b2411 100644 --- a/TAO/tao/Pluggable_Messaging.cpp +++ b/TAO/tao/Pluggable_Messaging.cpp @@ -42,7 +42,7 @@ TAO_Pluggable_Messaging_Interface:: ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("TAO: (%P|%t|%N|%l) closing conn %d after fault %p\n"), transport->handle (), - ASYS_TEXT ("GIOP_Message_Base::send_message ()"))); + ASYS_TEXT ("transport_message ()\n"))); return -1; } @@ -52,7 +52,7 @@ TAO_Pluggable_Messaging_Interface:: { if (TAO_orbdebug) ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("TAO: (%P|%t|%N|%l) send_message () ") + ASYS_TEXT ("TAO: (%P|%t|%N|%l) send_message () \n") ASYS_TEXT ("EOF, closing conn %d\n"), transport->handle())); return -1; diff --git a/TAO/tao/Pluggable_Messaging.h b/TAO/tao/Pluggable_Messaging.h index c29f2e736af..fd3bc96a384 100644 --- a/TAO/tao/Pluggable_Messaging.h +++ b/TAO/tao/Pluggable_Messaging.h @@ -16,8 +16,8 @@ // Balachandran Natarajan <bala@cs.wustl.edu> // // ============================================================================ -#ifndef _TAO_PLUGGABLE_MESSAGE_H_ -#define _TAO_PLUGGABLE_MESSAGE_H_ +#ifndef TAO_PLUGGABLE_MESSAGE_H +#define TAO_PLUGGABLE_MESSAGE_H #include "tao/corbafwd.h" #include "tao/Pluggable.h" @@ -77,8 +77,7 @@ public: virtual int parse_reply (TAO_Message_State_Factory &state, - TAO_Pluggable_Connector_Params ¶ms, - CORBA::ULong &reply_status) = 0; + TAO_Pluggable_Connector_Params ¶ms) = 0; // Parse the reply.. virtual int process_connector_messages (TAO_Transport *transport, @@ -134,4 +133,4 @@ public: # include "tao/Pluggable_Messaging.i" #endif /* __ACE_INLINE__ */ -#endif /*_TAO_PLUGGABLE_MESSAGE_H_*/ +#endif /*TAO_PLUGGABLE_MESSAGE_H*/ diff --git a/TAO/tao/Pluggable_Messaging_Utils.cpp b/TAO/tao/Pluggable_Messaging_Utils.cpp new file mode 100644 index 00000000000..35878ff4dec --- /dev/null +++ b/TAO/tao/Pluggable_Messaging_Utils.cpp @@ -0,0 +1,7 @@ +//$Id$ +#include "tao/Pluggable_Messaging_Utils.h" + +#if !defined (__ACE_INLINE__) +#include "tao/Pluggable_Messaging_Utils.i" +#endif /* __ACE_INLINE__ */ + diff --git a/TAO/tao/Pluggable_Messaging_Utils.h b/TAO/tao/Pluggable_Messaging_Utils.h index 22838e85c17..f40d0158e94 100644 --- a/TAO/tao/Pluggable_Messaging_Utils.h +++ b/TAO/tao/Pluggable_Messaging_Utils.h @@ -16,25 +16,29 @@ // Balachandran Natarajan <bala@cs.wustl.edu> // // ============================================================================ -#ifndef _TAO_PLUGGABLE_MESSAGING_UTILS_H_ -#define _TAO_PLUGGABLE_MESSAGING_UTILS_H_ +#ifndef TAO_PLUGGABLE_MESSAGING_UTILS_H +#define TAO_PLUGGABLE_MESSAGING_UTILS_H class TAO_Export TAO_Pluggable_Connector_Params { // = TITLE - // + // TAO_Pluggable_Connector_Params // // = DESCRIPTION - // + // This represents a set of data that would be received by the + // connector from the acceptor. public: - IOP::ServiceContextList svc_ctx; - - CORBA::ULong request_id; + TAO_Pluggable_Connector_Params (void); + // Ctor - CORBA::Octet response_flags; + IOP::ServiceContextList svc_ctx_; + // The IOP service context list - const char *operation_name; + CORBA::ULong request_id_; + // The request id for which the reply we (connector) has received + CORBA::ULong reply_status_; + // The reply status }; typedef enum HeaderType @@ -66,4 +70,35 @@ typedef enum MessageType TAO_PLUGGABLE_MESSAGE_FRAGMENT = 7 }TAO_Pluggable_Message_Type; +typedef enum Exception_Types +{ + // = DESCRIPTION + // Provide an external interface for the users of this pluggable + // messaging framework to denote existing Exception types. This has + // an inspiration from GIOP. So if anybody wants to add more message + // types you are welcome but please do not change the numbering + // scheme as this would affect GIOP. + TAO_PLUGGABLE_MESSAGE_NO_EXCEPTION = 0, + // Request completed successfully + + TAO_PLUGGABLE_MESSAGE_USER_EXCEPTION, + // Request terminated with user exception + + TAO_PLUGGABLE_MESSAGE_SYSTEM_EXCEPTION, + // Request terminated with system exception + + TAO_PLUGGABLE_MESSAGE_LOCATION_FORWARD, + // Reply is a location forward type + + TAO_PLUGGABLE_MESSAGE_LOCATION_FORWARD_PERM, + // PLUGGABLE_MESSAGE 1.2, Reply is a location forward perm type.. + + TAO_PLUGABLE_MESSAGE_NEEDS_ADDRESSING_MODE + // GIOP1.2, +}TAO_Pluggable_Message_Exception_Type; + +#if defined (__ACE_INLINE__) +#include "tao/Pluggable_Messaging_Utils.i" +#endif /* __ACE_INLINE__ */ + #endif /*_TAO_PLUGGABLE_MESSAGING_UTILS_H_ */ diff --git a/TAO/tao/Pluggable_Messaging_Utils.i b/TAO/tao/Pluggable_Messaging_Utils.i new file mode 100644 index 00000000000..4672e66902b --- /dev/null +++ b/TAO/tao/Pluggable_Messaging_Utils.i @@ -0,0 +1,11 @@ +// -*- C++ -*- +//$Id$ + +ACE_INLINE +TAO_Pluggable_Connector_Params::TAO_Pluggable_Connector_Params (void) + :svc_ctx_ (0), + request_id_ (0), + reply_status_ (0) +{ + //no-op +} diff --git a/TAO/tao/PolicyC.cpp b/TAO/tao/PolicyC.cpp index b3008817e40..8454e32b9ef 100644 --- a/TAO/tao/PolicyC.cpp +++ b/TAO/tao/PolicyC.cpp @@ -1,6 +1,5 @@ // $Id$ - /* -*- C++ -*- */ // ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* @@ -22,7 +21,6 @@ ACE_RCSID(tao, PolicyC, "$Id$") - // **************************************************************** TAO_NAMESPACE_TYPE (const CORBA::PolicyErrorCode) @@ -86,11 +84,27 @@ CORBA_PolicyError::_narrow (CORBA::Exception *exc) return 0; } -void CORBA_PolicyError::_raise () +void CORBA_PolicyError::_raise (void) { TAO_RAISE(*this); } +void CORBA_PolicyError::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void CORBA_PolicyError::_tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + // TAO extension - the _alloc method CORBA::Exception *CORBA_PolicyError::_alloc (void) { @@ -150,11 +164,27 @@ CORBA_InvalidPolicies::_narrow (CORBA::Exception *exc) return 0; } -void CORBA_InvalidPolicies::_raise () +void CORBA_InvalidPolicies::_raise (void) { TAO_RAISE(*this); } +void CORBA_InvalidPolicies::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void CORBA_InvalidPolicies::_tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + // TAO extension - the _alloc method CORBA::Exception *CORBA_InvalidPolicies::_alloc (void) { @@ -578,151 +608,337 @@ const char* CORBA_PolicyCurrent::_interface_repository_id (void) const // **************************************************************** -void operator<<= (CORBA::Any &_tao_any, const CORBA_PolicyError &_tao_elem) // copying +void operator<<= (CORBA::Any &_tao_any, const CORBA::PolicyError &_tao_elem) // copying { - CORBA_PolicyError *_tao_any_val = 0; - ACE_NEW (_tao_any_val, - CORBA_PolicyError (_tao_elem)); + CORBA::PolicyError *_tao_any_val = 0; + ACE_NEW (_tao_any_val, CORBA::PolicyError (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_PolicyError, _tao_any_val, 1, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_any_val; + _tao_any._tao_replace ( + CORBA::_tc_PolicyError, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } - ACE_CATCHANY + ACE_CATCHANY { delete _tao_any_val; } ACE_ENDTRY; } -void operator<<= (CORBA::Any &_tao_any, CORBA_PolicyError *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::PolicyError *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_PolicyError, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_PolicyError, + 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; } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PolicyError *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PolicyError *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_PolicyError, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_PolicyError, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_PolicyError *)_tao_any.value (); + _tao_elem = (CORBA::PolicyError *)_tao_any.value (); return 1; } else { - ACE_NEW_RETURN (_tao_elem, CORBA_PolicyError, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_PolicyError, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::PolicyError, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA::Any *)&_tao_any)->replace (CORBA::_tc_PolicyError, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_PolicyError, + 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; } -void operator<<= (CORBA::Any &_tao_any, const CORBA_InvalidPolicies &_tao_elem) // copying +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::PolicyError *&_tao_elem) { - CORBA_InvalidPolicies *_tao_any_val = 0; - ACE_NEW (_tao_any_val, - CORBA_InvalidPolicies (_tao_elem)); - if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_InvalidPolicies, _tao_any_val, 1, ACE_TRY_ENV); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_PolicyError, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::PolicyError *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::PolicyError, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::PolicyError *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_PolicyError, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::PolicyError *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::PolicyError *&, _tao_elem); + _tao_elem = 0; + } + } } ACE_CATCHANY { + delete ACE_const_cast (CORBA::PolicyError *&, _tao_elem); + _tao_elem = 0; + return 0; + } + ACE_ENDTRY; + return 0; +} + +void operator<<= (CORBA::Any &_tao_any, const CORBA::InvalidPolicies &_tao_elem) // copying +{ + CORBA::InvalidPolicies *_tao_any_val = 0; + ACE_NEW (_tao_any_val, CORBA::InvalidPolicies (_tao_elem)); + if (!_tao_any_val) return; + ACE_TRY_NEW_ENV + { + TAO_OutputCDR stream; + stream << *_tao_any_val; + _tao_any._tao_replace ( + CORBA::_tc_InvalidPolicies, + 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, CORBA_InvalidPolicies *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::InvalidPolicies *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_InvalidPolicies, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_InvalidPolicies, + 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; } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_InvalidPolicies *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InvalidPolicies *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_InvalidPolicies, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_InvalidPolicies, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_InvalidPolicies *)_tao_any.value (); + _tao_elem = (CORBA::InvalidPolicies *)_tao_any.value (); return 1; } else { - ACE_NEW_RETURN (_tao_elem, CORBA_InvalidPolicies, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_InvalidPolicies, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::InvalidPolicies, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA::Any *)&_tao_any)->replace (CORBA::_tc_InvalidPolicies, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_InvalidPolicies, + 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; } -void operator<<= (CORBA::Any &_tao_any, CORBA_Policy_ptr _tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::InvalidPolicies *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_InvalidPolicies, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::InvalidPolicies *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::InvalidPolicies, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::InvalidPolicies *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_InvalidPolicies, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::InvalidPolicies *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::InvalidPolicies *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::InvalidPolicies *&, _tao_elem); + _tao_elem = 0; + return 0; + } + ACE_ENDTRY; + return 0; +} + +CORBA::Policy_ptr (*_TAO_collocation_CORBA_Policy_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj + ) = 0; +void operator<<= (CORBA::Any &_tao_any, CORBA::Policy_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_Policy::_duplicate (_tao_elem); - _tao_any.replace (CORBA::_tc_Policy, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + *_tao_obj_ptr = CORBA::Policy::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_Policy, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -731,37 +947,52 @@ void operator<<= (CORBA::Any &_tao_any, CORBA_Policy_ptr _tao_elem) ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_Policy_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Policy_ptr &_tao_elem) { CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { - _tao_elem = CORBA_Policy::_nil (); + _tao_elem = CORBA::Policy::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_Policy, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_Policy, 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 (CORBA::_tc_Policy, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + if (stream >> _tao_obj_var.out ()) { - _tao_elem = CORBA_Policy::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); + _tao_elem = CORBA::Policy::_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 (CORBA::_tc_Policy, tmp, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_Policy, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = CORBA::Policy::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = CORBA::Policy::_nil (); return 0; } @@ -769,16 +1000,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_Policy_ptr &_tao_e void operator<<= ( CORBA::Any &_tao_any, - const CORBA_PolicyList &_tao_elem + const CORBA::PolicyList &_tao_elem ) // copying { - CORBA_PolicyList *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA_PolicyList (_tao_elem)); + CORBA::PolicyList *_tao_any_val; + ACE_NEW (_tao_any_val, CORBA::PolicyList (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_PolicyList, _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 ( + CORBA::_tc_PolicyList, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_any_val; + } } ACE_CATCHANY { @@ -787,51 +1033,127 @@ void operator<<= ( ACE_ENDTRY; } -void operator<<= (CORBA::Any &_tao_any, CORBA_PolicyList *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::PolicyList *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_PolicyList, _tao_elem, 0, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_PolicyList, + 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; } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PolicyList *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PolicyList *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_PolicyList, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_PolicyList, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_PolicyList *)_tao_any.value (); + _tao_elem = (CORBA::PolicyList *)_tao_any.value (); return 1; } else { - ACE_NEW_RETURN (_tao_elem, CORBA_PolicyList, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_PolicyList, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::PolicyList, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA::Any *)&_tao_any)->replace (CORBA::_tc_PolicyList, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_PolicyList, + 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 CORBA::PolicyList *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_PolicyList, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::PolicyList *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::PolicyList, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::PolicyList *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_PolicyList, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::PolicyList *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::PolicyList *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::PolicyList *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; @@ -839,16 +1161,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PolicyList *&_tao_ void operator<<= ( CORBA::Any &_tao_any, - const CORBA_PolicyTypeSeq &_tao_elem + const CORBA::PolicyTypeSeq &_tao_elem ) // copying { - CORBA_PolicyTypeSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA_PolicyTypeSeq (_tao_elem)); + CORBA::PolicyTypeSeq *_tao_any_val; + ACE_NEW (_tao_any_val, CORBA::PolicyTypeSeq (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_PolicyTypeSeq, _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 ( + CORBA::_tc_PolicyTypeSeq, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_any_val; + } } ACE_CATCHANY { @@ -857,51 +1194,127 @@ void operator<<= ( ACE_ENDTRY; } -void operator<<= (CORBA::Any &_tao_any, CORBA_PolicyTypeSeq *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::PolicyTypeSeq *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_PolicyTypeSeq, _tao_elem, 0, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_PolicyTypeSeq, + 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; } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PolicyTypeSeq *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PolicyTypeSeq *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_PolicyTypeSeq, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_PolicyTypeSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_PolicyTypeSeq *)_tao_any.value (); + _tao_elem = (CORBA::PolicyTypeSeq *)_tao_any.value (); return 1; } else { - ACE_NEW_RETURN (_tao_elem, CORBA_PolicyTypeSeq, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_PolicyTypeSeq, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::PolicyTypeSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA::Any *)&_tao_any)->replace (CORBA::_tc_PolicyTypeSeq, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_PolicyTypeSeq, + 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 CORBA::PolicyTypeSeq *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_PolicyTypeSeq, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::PolicyTypeSeq *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::PolicyTypeSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::PolicyTypeSeq *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_PolicyTypeSeq, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::PolicyTypeSeq *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::PolicyTypeSeq *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::PolicyTypeSeq *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; @@ -909,18 +1322,27 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PolicyTypeSeq *&_t void operator<<= (CORBA::Any &_tao_any, CORBA::SetOverrideType _tao_elem) { - CORBA::SetOverrideType *_any_val; - ACE_NEW (_any_val, CORBA::SetOverrideType (_tao_elem)); - if (!_any_val) return; + CORBA::SetOverrideType *_tao_any_val; + ACE_NEW (_tao_any_val, CORBA::SetOverrideType (_tao_elem)); + if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_SetOverrideType, _any_val, 1, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_any_val; + _tao_any._tao_replace ( + CORBA::_tc_SetOverrideType, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY { // free allocated storage - delete _any_val; + delete _tao_any_val; } ACE_ENDTRY; } @@ -930,14 +1352,19 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::SetOverrideType & ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_SetOverrideType, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_SetOverrideType, 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.decode (CORBA::_tc_SetOverrideType, &_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) + { return 1; - ACE_TRY_CHECK; + } } ACE_CATCHANY { @@ -987,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 f8a322082d8..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 @@ -32,6 +33,11 @@ public: virtual void _raise (void); + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static CORBA_PolicyError *_narrow (CORBA::Exception *); CORBA_PolicyError( @@ -75,6 +81,11 @@ public: virtual void _raise (void); + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static CORBA_InvalidPolicies *_narrow (CORBA::Exception *); CORBA_InvalidPolicies( @@ -512,15 +523,20 @@ private: TAO_Export void operator<<= (CORBA::Any &, const CORBA::PolicyError &); -TAO_Export void operator<<= (CORBA::Any &, CORBA::PolicyError*); +TAO_Export void operator<<= (CORBA::Any &, + CORBA::PolicyError*); TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::PolicyError *&); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::PolicyError *&); TAO_Export void operator<<= (CORBA::Any &, const CORBA::InvalidPolicies &); TAO_Export void operator<<= (CORBA::Any &, CORBA::InvalidPolicies*); TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::InvalidPolicies *&); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::InvalidPolicies *&); // Any operators for interface CORBA::Policy TAO_Export void operator<<= (CORBA::Any &, @@ -533,51 +549,54 @@ TAO_Export void operator<<= (CORBA::Any &, CORBA::PolicyList*); TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::PolicyList *&); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::PolicyList *&); TAO_Export void operator<<= (CORBA::Any &, const CORBA::PolicyTypeSeq &); TAO_Export void operator<<= (CORBA::Any &, CORBA::PolicyTypeSeq*); TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::PolicyTypeSeq *&); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::PolicyTypeSeq *&); TAO_Export void operator<<= (CORBA::Any &, CORBA::SetOverrideType); 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 07a2a9a2a93..63793eb792a 100644 --- a/TAO/tao/PolicyC.i +++ b/TAO/tao/PolicyC.i @@ -269,7 +269,7 @@ CORBA_PolicyList_var::operator= (const CORBA_PolicyList_var &p) // deep copy delete this->ptr_; ACE_NEW_RETURN (this->ptr_, CORBA_PolicyList (*p.ptr_), - *this); + *this); } return *this; } @@ -453,7 +453,7 @@ CORBA_PolicyTypeSeq_var::operator= (const CORBA_PolicyTypeSeq_var &p) // deep co delete this->ptr_; ACE_NEW_RETURN (this->ptr_, CORBA_PolicyTypeSeq (*p.ptr_), - *this); + *this); } return *this; } @@ -990,21 +990,12 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_PolicyErr ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_PolicyError &_tao_aggregate) { - // retrieve RepoID and verify if we are of that type - char *_tao_repoID; - if ((strm >> _tao_repoID) && - (_tao_aggregate._is_a (_tao_repoID))) - { - // now marshal the members - if ( + // now marshal the members + if ( (strm >> _tao_aggregate.reason) - ) - return 1; - else - return 0; - } - else - return 0; + ) + return 1; + return 0; } ACE_INLINE CORBA::Boolean operator<< ( @@ -1052,21 +1043,12 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_InvalidPo ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_InvalidPolicies &_tao_aggregate) { - // retrieve RepoID and verify if we are of that type - char *_tao_repoID; - if ((strm >> _tao_repoID) && - (_tao_aggregate._is_a (_tao_repoID))) - { - // now marshal the members - if ( + // now marshal the members + if ( (strm >> _tao_aggregate.indices) - ) - return 1; - else - return 0; - } - else - return 0; + ) + return 1; + return 0; } CORBA::Boolean TAO_Export @@ -1155,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; +} + diff --git a/TAO/tao/Policy_Manager.cpp b/TAO/tao/Policy_Manager.cpp index 171ef36dec8..57abe6b64d9 100644 --- a/TAO/tao/Policy_Manager.cpp +++ b/TAO/tao/Policy_Manager.cpp @@ -1,7 +1,5 @@ // $Id$ - - #include "tao/Policy_Manager.h" #if (TAO_HAS_CORBA_MESSAGING == 1) @@ -17,10 +15,8 @@ # include "tao/Policy_Manager.i" #endif /* ! __ACE_INLINE__ */ - ACE_RCSID(tao, Policy_Manager, "$Id$") - TAO_Policy_Manager_Impl::~TAO_Policy_Manager_Impl (void) { ACE_DECLARE_NEW_CORBA_ENV; @@ -309,8 +305,16 @@ TAO_Policy_Manager_Impl::get_policy_overrides ( if (slots == 0) slots = this->count_; - CORBA::PolicyList_var policy_list = - new CORBA::PolicyList (slots); + + CORBA::PolicyList *policy_list_ptr; + + ACE_NEW_THROW_EX (policy_list_ptr, + CORBA::PolicyList (slots), + CORBA::NO_MEMORY ()); + ACE_CHECK_RETURN (0); + + CORBA::PolicyList_var policy_list (policy_list_ptr); + policy_list->length (slots); CORBA::ULong n = 0; diff --git a/TAO/tao/Policy_Manager.h b/TAO/tao/Policy_Manager.h index 418b6bec652..569dd978c87 100644 --- a/TAO/tao/Policy_Manager.h +++ b/TAO/tao/Policy_Manager.h @@ -1,8 +1,6 @@ // -*- C++ -*- // $Id$ - - // ============================================================================ // // = LIBRARY diff --git a/TAO/tao/Policy_Manager.i b/TAO/tao/Policy_Manager.i index 214fef5a663..d43444083a2 100644 --- a/TAO/tao/Policy_Manager.i +++ b/TAO/tao/Policy_Manager.i @@ -1,6 +1,5 @@ // $Id$ - ACE_INLINE TAO_Policy_Manager_Impl::TAO_Policy_Manager_Impl (void) : relative_roundtrip_timeout_ (0), diff --git a/TAO/tao/PollableC.cpp b/TAO/tao/PollableC.cpp index ca88b25a126..c7bc2e24b5a 100644 --- a/TAO/tao/PollableC.cpp +++ b/TAO/tao/PollableC.cpp @@ -1,7 +1,6 @@ /* -*- C++ -*- */ // // $Id$ - // // ================================================================ // @@ -31,11 +30,7 @@ #include "tao/PollableC.i" #endif /* !defined INLINE */ -<<<<<<< PollableC.cpp -ACE_RCSID(tao, PollableC, "$Id$") -======= ACE_RCSID(tao, PollableC, "$Id$") ->>>>>>> 1.14.2.3 CORBA_Pollable_ptr CORBA_Pollable::_narrow ( CORBA::Object_ptr obj, @@ -462,11 +457,27 @@ CORBA_PollableSet::NoPossiblePollable::_narrow (CORBA::Exception *exc) } -void CORBA_PollableSet::NoPossiblePollable::_raise () +void CORBA_PollableSet::NoPossiblePollable::_raise (void) { TAO_RAISE(*this); } +void CORBA_PollableSet::NoPossiblePollable::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void CORBA_PollableSet::NoPossiblePollable::_tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + // TAO extension - the _alloc method CORBA::Exception *CORBA_PollableSet::NoPossiblePollable::_alloc (void) { @@ -526,11 +537,27 @@ CORBA_PollableSet::UnknownPollable::_narrow (CORBA::Exception *exc) } -void CORBA_PollableSet::UnknownPollable::_raise () +void CORBA_PollableSet::UnknownPollable::_raise (void) { TAO_RAISE(*this); } +void CORBA_PollableSet::UnknownPollable::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void CORBA_PollableSet::UnknownPollable::_tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + // TAO extension - the _alloc method CORBA::Exception *CORBA_PollableSet::UnknownPollable::_alloc (void) { @@ -862,15 +889,30 @@ const char* CORBA_PollableSet::_interface_repository_id (void) const return "IDL:omg.org/CORBA/PollableSet:1.0"; } -void operator<<= (CORBA::Any &_tao_any, CORBA_Pollable_ptr _tao_elem) +void operator<<= (CORBA::Any &_tao_any, CORBA::Pollable_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_Pollable::_duplicate (_tao_elem); - _tao_any.replace (CORBA::_tc_Pollable, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + *_tao_obj_ptr = CORBA::Pollable::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_Pollable, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -879,48 +921,67 @@ void operator<<= (CORBA::Any &_tao_any, CORBA_Pollable_ptr _tao_elem) ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_Pollable_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Pollable_ptr &_tao_elem) { CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { - _tao_elem = CORBA_Pollable::_nil (); + _tao_elem = CORBA::Pollable::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_Pollable, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_Pollable, 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 (CORBA::_tc_Pollable, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + if (stream >> _tao_obj_var.out ()) { - _tao_elem = CORBA_Pollable::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); + _tao_elem = CORBA::Pollable::_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 (CORBA::_tc_Pollable, tmp, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_Pollable, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = CORBA::Pollable::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = CORBA::Pollable::_nil (); return 0; } -#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) - template class TAO_Object_Field_T<CORBA_Pollable,CORBA_Pollable_var>; - template class TAO_Object_Manager<CORBA_Pollable,CORBA_Pollable_var>; +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Field_T<CORBA::Pollable,CORBA::Pollable_var>; + template class TAO_Object_Manager<CORBA::Pollable,CORBA::Pollable_var>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) -# pragma instantiate TAO_Object_Field_T<CORBA_Pollable,CORBA_Pollable_var> -# pragma instantiate TAO_Object_Manager<CORBA_Pollable,CORBA_Pollable_var> +# pragma instantiate TAO_Object_Field_T<CORBA::Pollable,CORBA::Pollable_var> +# pragma instantiate TAO_Object_Manager<CORBA::Pollable,CORBA::Pollable_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ +CORBA::DIIPollable_ptr (*_TAO_collocation_CORBA_DIIPollable_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj + ) = 0; void operator<<= (CORBA::Any &_tao_any, CORBA::DIIPollable_ptr _tao_elem) { CORBA::Object_ptr *_tao_obj_ptr = 0; @@ -928,8 +989,23 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::DIIPollable_ptr _tao_elem) { ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); *_tao_obj_ptr = CORBA::DIIPollable::_duplicate (_tao_elem); - _tao_any.replace (CORBA::_tc_DIIPollable, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_DIIPollable, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -941,54 +1017,88 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::DIIPollable_ptr _tao_elem) CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::DIIPollable_ptr &_tao_elem) { CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = CORBA::DIIPollable::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_DIIPollable, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_DIIPollable, 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 (CORBA::_tc_DIIPollable, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + if (stream >> _tao_obj_var.out ()) { _tao_elem = CORBA::DIIPollable::_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 (CORBA::_tc_DIIPollable, tmp, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_DIIPollable, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = CORBA::DIIPollable::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = CORBA::DIIPollable::_nil (); return 0; } -#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) - template class TAO_Object_Field_T<CORBA::DIIPollable,CORBA::DIIPollable_var>; +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Field_T<CORBA::DIIPollable,CORBA::DIIPollable_var>; template class TAO_Object_Manager<CORBA::DIIPollable,CORBA::DIIPollable_var>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) # pragma instantiate TAO_Object_Field_T<CORBA::DIIPollable,CORBA::DIIPollable_var> # pragma instantiate TAO_Object_Manager<CORBA::DIIPollable,CORBA::DIIPollable_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ -void operator<<= (CORBA::Any &_tao_any, CORBA_PollableSet_ptr _tao_elem) +CORBA::PollableSet_ptr (*_TAO_collocation_CORBA_PollableSet_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj + ) = 0; +void operator<<= (CORBA::Any &_tao_any, CORBA::PollableSet_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_PollableSet::_duplicate (_tao_elem); - _tao_any.replace (CORBA::_tc_PollableSet, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + *_tao_obj_ptr = CORBA::PollableSet::_duplicate (_tao_elem); + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + CORBA::_tc_PollableSet, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -997,179 +1107,363 @@ void operator<<= (CORBA::Any &_tao_any, CORBA_PollableSet_ptr _tao_elem) ACE_ENDTRY; } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PollableSet_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PollableSet_ptr &_tao_elem) { CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { - _tao_elem = CORBA_PollableSet::_nil (); + _tao_elem = CORBA::PollableSet::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA::_tc_PollableSet, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::_tc_PollableSet, 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 (CORBA::_tc_PollableSet, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + if (stream >> _tao_obj_var.out ()) { - _tao_elem = CORBA_PollableSet::_narrow (_tao_obj_var.in (), ACE_TRY_ENV); + _tao_elem = CORBA::PollableSet::_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 (CORBA::_tc_PollableSet, tmp, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_PollableSet, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = CORBA::PollableSet::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = CORBA::PollableSet::_nil (); return 0; } -#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) - template class TAO_Object_Field_T<CORBA_PollableSet,CORBA_PollableSet_var>; - template class TAO_Object_Manager<CORBA_PollableSet,CORBA_PollableSet_var>; +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Field_T<CORBA::PollableSet,CORBA::PollableSet_var>; + template class TAO_Object_Manager<CORBA::PollableSet,CORBA::PollableSet_var>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) -# pragma instantiate TAO_Object_Field_T<CORBA_PollableSet,CORBA_PollableSet_var> -# pragma instantiate TAO_Object_Manager<CORBA_PollableSet,CORBA_PollableSet_var> +# pragma instantiate TAO_Object_Field_T<CORBA::PollableSet,CORBA::PollableSet_var> +# pragma instantiate TAO_Object_Manager<CORBA::PollableSet,CORBA::PollableSet_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ -void operator<<= (CORBA::Any &_tao_any, const CORBA_PollableSet::NoPossiblePollable &_tao_elem) // copying +void operator<<= (CORBA::Any &_tao_any, const CORBA::PollableSet::NoPossiblePollable &_tao_elem) // copying { - CORBA_PollableSet::NoPossiblePollable *_tao_any_val = 0; - ACE_NEW (_tao_any_val, - CORBA_PollableSet::NoPossiblePollable (_tao_elem)); + CORBA::PollableSet::NoPossiblePollable *_tao_any_val = 0; + ACE_NEW (_tao_any_val, CORBA::PollableSet::NoPossiblePollable (_tao_elem)); if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA_PollableSet::_tc_NoPossiblePollable, _tao_any_val, 1, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_any_val; + _tao_any._tao_replace ( + CORBA::PollableSet::_tc_NoPossiblePollable, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } - ACE_CATCHANY + ACE_CATCHANY { delete _tao_any_val; } ACE_ENDTRY; } -void operator<<= (CORBA::Any &_tao_any, CORBA_PollableSet::NoPossiblePollable *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::PollableSet::NoPossiblePollable *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA_PollableSet::_tc_NoPossiblePollable, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::PollableSet::_tc_NoPossiblePollable, + 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; } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PollableSet::NoPossiblePollable *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PollableSet::NoPossiblePollable *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA_PollableSet::_tc_NoPossiblePollable, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::PollableSet::_tc_NoPossiblePollable, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_PollableSet::NoPossiblePollable *)_tao_any.value (); + _tao_elem = (CORBA::PollableSet::NoPossiblePollable *)_tao_any.value (); return 1; } else { - ACE_NEW_RETURN (_tao_elem, CORBA_PollableSet::NoPossiblePollable, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA_PollableSet::_tc_NoPossiblePollable, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::PollableSet::NoPossiblePollable, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA::Any *)&_tao_any)->replace (CORBA_PollableSet::_tc_NoPossiblePollable, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::PollableSet::_tc_NoPossiblePollable, + 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; } -void operator<<= (CORBA::Any &_tao_any, const CORBA_PollableSet::UnknownPollable &_tao_elem) // copying +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::PollableSet::NoPossiblePollable *&_tao_elem) { - CORBA_PollableSet::UnknownPollable *_tao_any_val = 0; - ACE_NEW (_tao_any_val, - CORBA_PollableSet::UnknownPollable (_tao_elem)); - if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA_PollableSet::_tc_UnknownPollable, _tao_any_val, 1, ACE_TRY_ENV); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::PollableSet::_tc_NoPossiblePollable, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::PollableSet::NoPossiblePollable *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::PollableSet::NoPossiblePollable, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::PollableSet::NoPossiblePollable *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::PollableSet::_tc_NoPossiblePollable, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::PollableSet::NoPossiblePollable *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::PollableSet::NoPossiblePollable *&, _tao_elem); + _tao_elem = 0; + } + } } ACE_CATCHANY { + delete ACE_const_cast (CORBA::PollableSet::NoPossiblePollable *&, _tao_elem); + _tao_elem = 0; + return 0; + } + ACE_ENDTRY; + return 0; +} + +void operator<<= (CORBA::Any &_tao_any, const CORBA::PollableSet::UnknownPollable &_tao_elem) // copying +{ + CORBA::PollableSet::UnknownPollable *_tao_any_val = 0; + ACE_NEW (_tao_any_val, CORBA::PollableSet::UnknownPollable (_tao_elem)); + if (!_tao_any_val) return; + ACE_TRY_NEW_ENV + { + TAO_OutputCDR stream; + stream << *_tao_any_val; + _tao_any._tao_replace ( + CORBA::PollableSet::_tc_UnknownPollable, + 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, CORBA_PollableSet::UnknownPollable *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA::PollableSet::UnknownPollable *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA_PollableSet::_tc_UnknownPollable, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::PollableSet::_tc_UnknownPollable, + 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; } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PollableSet::UnknownPollable *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PollableSet::UnknownPollable *&_tao_elem) { ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (CORBA_PollableSet::_tc_UnknownPollable, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (CORBA::PollableSet::_tc_UnknownPollable, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_PollableSet::UnknownPollable *)_tao_any.value (); + _tao_elem = (CORBA::PollableSet::UnknownPollable *)_tao_any.value (); return 1; } else { - ACE_NEW_RETURN (_tao_elem, CORBA_PollableSet::UnknownPollable, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA_PollableSet::_tc_UnknownPollable, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + ACE_NEW_RETURN (_tao_elem, CORBA::PollableSet::UnknownPollable, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *_tao_elem) { - ((CORBA::Any *)&_tao_any)->replace (CORBA_PollableSet::_tc_UnknownPollable, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::PollableSet::_tc_UnknownPollable, + 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 CORBA::PollableSet::UnknownPollable *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::PollableSet::_tc_UnknownPollable, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::PollableSet::UnknownPollable *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, CORBA::PollableSet::UnknownPollable, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(CORBA::PollableSet::UnknownPollable *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::PollableSet::_tc_UnknownPollable, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::PollableSet::UnknownPollable *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (CORBA::PollableSet::UnknownPollable *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (CORBA::PollableSet::UnknownPollable *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; diff --git a/TAO/tao/PollableC.h b/TAO/tao/PollableC.h index 654cbdd3aa8..c7672c2a047 100644 --- a/TAO/tao/PollableC.h +++ b/TAO/tao/PollableC.h @@ -1,7 +1,6 @@ /* -*- C++ -*- */ // // $Id$ - // // ================================================================ // @@ -312,6 +311,11 @@ public: virtual void _raise (void); + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static NoPossiblePollable *_narrow (CORBA::Exception *); @@ -343,6 +347,11 @@ public: virtual void _raise (void); + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static UnknownPollable *_narrow (CORBA::Exception *); @@ -396,20 +405,38 @@ private: }; // Any operators for interface CORBA_Pollable -TAO_Export void operator<<= (CORBA::Any &, CORBA_Pollable_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_Pollable *&); +TAO_Export void operator<<= (CORBA::Any &, + CORBA_Pollable_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA_Pollable *&); + // Any operators for interface CORBA::DIIPollable -TAO_Export void operator<<= (CORBA::Any &, CORBA::DIIPollable_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::DIIPollable *&); +TAO_Export void operator<<= (CORBA::Any &, + CORBA::DIIPollable_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA::DIIPollable *&); + // Any operators for interface CORBA_PollableSet -TAO_Export void operator<<= (CORBA::Any &, CORBA_PollableSet_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_PollableSet *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA_PollableSet::NoPossiblePollable &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA_PollableSet::NoPossiblePollable*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_PollableSet::NoPossiblePollable *&); -TAO_Export void operator<<= (CORBA::Any &, const CORBA_PollableSet::UnknownPollable &); // copying version -TAO_Export void operator<<= (CORBA::Any &, CORBA_PollableSet::UnknownPollable*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_PollableSet::UnknownPollable *&); +TAO_Export void operator<<= (CORBA::Any &, + CORBA_PollableSet_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA_PollableSet *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA_PollableSet::NoPossiblePollable &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA_PollableSet::NoPossiblePollable*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA_PollableSet::NoPossiblePollable *&); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::PollableSet::NoPossiblePollable *&); +TAO_Export void operator<<= (CORBA::Any &, + const CORBA_PollableSet::UnknownPollable &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + CORBA_PollableSet::UnknownPollable*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + CORBA_PollableSet::UnknownPollable *&); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const CORBA::PollableSet::UnknownPollable *&); #ifndef __ACE_INLINE__ diff --git a/TAO/tao/PollableC.i b/TAO/tao/PollableC.i index 5b365ad2053..7697968b982 100644 --- a/TAO/tao/PollableC.i +++ b/TAO/tao/PollableC.i @@ -612,17 +612,9 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_PollableS return 0; } -ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_PollableSet::NoPossiblePollable &_tao_aggregate) +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &, CORBA_PollableSet::NoPossiblePollable &) { - // retrieve RepoID and verify if we are of that type - char *_tao_repoID; - if ((strm >> _tao_repoID) && - (_tao_aggregate._is_a (_tao_repoID))) - { - return 1; - } - else - return 0; + return 1; } ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_PollableSet::UnknownPollable &_tao_aggregate) @@ -634,15 +626,7 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_PollableS return 0; } -ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_PollableSet::UnknownPollable &_tao_aggregate) +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &, CORBA_PollableSet::UnknownPollable &) { - // retrieve RepoID and verify if we are of that type - char *_tao_repoID; - if ((strm >> _tao_repoID) && - (_tao_aggregate._is_a (_tao_repoID))) - { - return 1; - } - else - return 0; + return 1; } diff --git a/TAO/tao/PollableS.cpp b/TAO/tao/PollableS.cpp index 3e615df051a..482ff6114fe 100644 --- a/TAO/tao/PollableS.cpp +++ b/TAO/tao/PollableS.cpp @@ -1,7 +1,6 @@ /* -*- C++ -*- */ // // $Id$ - // // ================================================================ // @@ -31,11 +30,6 @@ ACE_RCSID(tao, PollableS, "$Id$") -<<<<<<< PollableS.cpp -ACE_RCSID(tao, PollableS, "$Id$") -======= ->>>>>>> 1.9.2.2 - class TAO_CORBA_Pollable_Perfect_Hash_OpTable : public TAO_Perfect_Hash_OpTable { private: diff --git a/TAO/tao/PollableS.h b/TAO/tao/PollableS.h index 9f465b73b64..abc0d4c079a 100644 --- a/TAO/tao/PollableS.h +++ b/TAO/tao/PollableS.h @@ -1,7 +1,6 @@ /* -*- C++ -*- */ // // $Id$ - // // ================================================================ // diff --git a/TAO/tao/Pool_Per_Endpoint.cpp b/TAO/tao/Pool_Per_Endpoint.cpp index 1cd02ae4606..e2d28d8c409 100644 --- a/TAO/tao/Pool_Per_Endpoint.cpp +++ b/TAO/tao/Pool_Per_Endpoint.cpp @@ -1,6 +1,5 @@ // $Id$ - #include "tao/Pool_Per_Endpoint.h" #include "tao/ORB.h" #include "tao/ORB_Core.h" @@ -16,8 +15,6 @@ ACE_RCSID(tao, Pool_Per_Endpoint, "$Id$") - - TAO_Pool_Per_Endpoint::TAO_Pool_Per_Endpoint (CORBA::ORB_ptr orb, int policy, int poolsize, diff --git a/TAO/tao/Pool_Per_Endpoint.h b/TAO/tao/Pool_Per_Endpoint.h index 82ffae971aa..7588b52d67e 100644 --- a/TAO/tao/Pool_Per_Endpoint.h +++ b/TAO/tao/Pool_Per_Endpoint.h @@ -1,7 +1,5 @@ // $Id$ - - // ============================================================================ // // = LIBRARY diff --git a/TAO/tao/Principal.h b/TAO/tao/Principal.h index ba3b1b5bbd4..a861fa4fbb3 100644 --- a/TAO/tao/Principal.h +++ b/TAO/tao/Principal.h @@ -1,7 +1,6 @@ // This may look like C, but it's really -*- C++ -*- // $Id$ - // ============================================================================ // // = LIBRARY diff --git a/TAO/tao/Priority_Mapping.cpp b/TAO/tao/Priority_Mapping.cpp index cf62d36a1d5..aafd60b22b4 100644 --- a/TAO/tao/Priority_Mapping.cpp +++ b/TAO/tao/Priority_Mapping.cpp @@ -1,6 +1,5 @@ // $Id$ - #include "tao/orbconf.h" #if (TAO_HAS_RT_CORBA == 1) @@ -13,7 +12,6 @@ ACE_RCSID(tao, Priority_Mapping, "$Id$") - TAO_Priority_Mapping::TAO_Priority_Mapping (void) { } diff --git a/TAO/tao/Priority_Mapping.h b/TAO/tao/Priority_Mapping.h index dc080daed0f..6aeff91fc4b 100644 --- a/TAO/tao/Priority_Mapping.h +++ b/TAO/tao/Priority_Mapping.h @@ -1,6 +1,5 @@ // $Id$ - // ============================================================================ // // = LIBRARY diff --git a/TAO/tao/Profile.cpp b/TAO/tao/Profile.cpp index e11e71b790e..1e0d585d599 100644 --- a/TAO/tao/Profile.cpp +++ b/TAO/tao/Profile.cpp @@ -1,6 +1,5 @@ // $Id$ - #include "tao/Profile.h" #include "tao/Object_KeyC.h" @@ -10,8 +9,6 @@ ACE_RCSID(tao, Profile, "$Id$") - - // **************************************************************** TAO_Profile::~TAO_Profile (void) diff --git a/TAO/tao/Profile.h b/TAO/tao/Profile.h index 70098ccf30c..7922844532f 100644 --- a/TAO/tao/Profile.h +++ b/TAO/tao/Profile.h @@ -1,7 +1,6 @@ // This may look like C, but it's really -*- C++ -*- // $Id$ - // ============================================================================ // // = LIBRARY diff --git a/TAO/tao/RT_Current.cpp b/TAO/tao/RT_Current.cpp index 5f639d47a10..f6d98af18c4 100644 --- a/TAO/tao/RT_Current.cpp +++ b/TAO/tao/RT_Current.cpp @@ -1,6 +1,5 @@ // // $Id$ - // #include "tao/RT_Current.h" @@ -19,7 +18,6 @@ ACE_RCSID(tao, RT_Current, "$Id$") - TAO_RT_Current_ptr TAO_RT_Current::_duplicate (TAO_RT_Current_ptr obj) { diff --git a/TAO/tao/RT_Current.h b/TAO/tao/RT_Current.h index 1e0b0a01191..9ed7a96aca0 100644 --- a/TAO/tao/RT_Current.h +++ b/TAO/tao/RT_Current.h @@ -1,6 +1,5 @@ // $Id$ - // ============================================================================ // // = LIBRARY diff --git a/TAO/tao/Reactor_Per_Priority.cpp b/TAO/tao/Reactor_Per_Priority.cpp index 17f70403f16..273901a85c8 100644 --- a/TAO/tao/Reactor_Per_Priority.cpp +++ b/TAO/tao/Reactor_Per_Priority.cpp @@ -1,6 +1,5 @@ // $Id$ - #include "tao/Reactor_Per_Priority.h" #include "tao/ORB_Core.h" #include "tao/Resource_Factory.h" @@ -15,7 +14,6 @@ ACE_RCSID(tao, Reactor_Per_Priority, "$Id$") - TAO_Reactor_Per_Priority::~TAO_Reactor_Per_Priority (void) { for (Map_Iterator i = this->map_.begin (); diff --git a/TAO/tao/Reply_Dispatcher.cpp b/TAO/tao/Reply_Dispatcher.cpp index 7893eeaf428..d58b09c496a 100644 --- a/TAO/tao/Reply_Dispatcher.cpp +++ b/TAO/tao/Reply_Dispatcher.cpp @@ -1,7 +1,6 @@ // $Id$ - #include "tao/Reply_Dispatcher.h" #include "tao/ORB_Core.h" #include "tao/Leader_Follower.h" @@ -55,7 +54,7 @@ TAO_Synch_Reply_Dispatcher::~TAO_Synch_Reply_Dispatcher (void) // Dispatch the reply. int TAO_Synch_Reply_Dispatcher::dispatch_reply (CORBA::ULong reply_status, - const TAO_GIOP_Version &version, + const TAO_GIOP_Version & /*version*/, IOP::ServiceContextList &reply_ctx, TAO_GIOP_Message_State *message_state) { @@ -160,12 +159,12 @@ TAO_Asynch_Reply_Dispatcher::~TAO_Asynch_Reply_Dispatcher (void) // Dispatch the reply. int TAO_Asynch_Reply_Dispatcher::dispatch_reply (CORBA::ULong reply_status, - const TAO_GIOP_Version &version, + const TAO_GIOP_Version & /*version*/, IOP::ServiceContextList &reply_ctx, TAO_GIOP_Message_State *message_state) { this->reply_status_ = reply_status; - this->version_ = version; + // this->version_ = version; this->message_state_ = message_state; // Steal the buffer, that way we don't do any unnecesary copies of @@ -185,17 +184,17 @@ TAO_Asynch_Reply_Dispatcher::dispatch_reply (CORBA::ULong reply_status, CORBA::ULong reply_error = TAO_AMI_REPLY_NOT_OK; switch (reply_status) { - case TAO_GIOP_NO_EXCEPTION: + case TAO_PLUGGABLE_MESSAGE_NO_EXCEPTION: reply_error = TAO_AMI_REPLY_OK; break; - case TAO_GIOP_USER_EXCEPTION: + case TAO_PLUGGABLE_MESSAGE_USER_EXCEPTION: reply_error = TAO_AMI_REPLY_USER_EXCEPTION; break; - case TAO_GIOP_SYSTEM_EXCEPTION: + case TAO_PLUGGABLE_MESSAGE_SYSTEM_EXCEPTION: reply_error = TAO_AMI_REPLY_SYSTEM_EXCEPTION; break; default: - case TAO_GIOP_LOCATION_FORWARD: + case TAO_PLUGGABLE_MESSAGE_LOCATION_FORWARD: // @@ Michael: Not even the spec mentions this case. // We have to think about this case. // Handle the forwarding and return so the stub restarts the @@ -260,7 +259,7 @@ TAO_DII_Deferred_Reply_Dispatcher::~TAO_DII_Deferred_Reply_Dispatcher (void) int TAO_DII_Deferred_Reply_Dispatcher::dispatch_reply ( CORBA::ULong reply_status, - const TAO_GIOP_Version &version, + const TAO_GIOP_Version & /*version*/, IOP::ServiceContextList &reply_ctx, TAO_GIOP_Message_State *message_state ) diff --git a/TAO/tao/Reply_Dispatcher.i b/TAO/tao/Reply_Dispatcher.i index 984577f6a12..7f4dd63d0d8 100644 --- a/TAO/tao/Reply_Dispatcher.i +++ b/TAO/tao/Reply_Dispatcher.i @@ -25,12 +25,13 @@ TAO_Asynch_Reply_Dispatcher::reply_status (void) const return this->reply_status_; } +#if 0 ACE_INLINE const TAO_GIOP_Version & TAO_Asynch_Reply_Dispatcher::version (void) const { return this->version_; } - +#endif /*if 0*/ ACE_INLINE void TAO_Asynch_Reply_Dispatcher::transport (TAO_Transport *t) { @@ -59,6 +60,7 @@ TAO_DII_Deferred_Reply_Dispatcher::version (void) const } #endif /*If 0 */ + ACE_INLINE void TAO_DII_Deferred_Reply_Dispatcher::transport (TAO_Transport *t) { diff --git a/TAO/tao/Request.cpp b/TAO/tao/Request.cpp index ca56420c549..dcfdb4a0c37 100644 --- a/TAO/tao/Request.cpp +++ b/TAO/tao/Request.cpp @@ -1,14 +1,13 @@ // $Id$ - - #include "tao/Request.h" -#include "tao/GIOP_Utils.h" #if !defined (TAO_HAS_MINIMUM_CORBA) #include "tao/Object.h" #include "tao/Stub.h" +#include "tao/Pluggable_Messaging_Utils.h" + #if !defined (__ACE_INLINE__) # include "tao/Request.i" @@ -16,8 +15,6 @@ ACE_RCSID(tao, Request, "$Id$") - - CORBA::ULong CORBA_Request::_incr_refcnt (void) { @@ -195,7 +192,7 @@ CORBA_Request::handle_response (TAO_InputCDR &incoming, { switch (reply_status) { - case TAO_GIOP_NO_EXCEPTION: + case TAO_PLUGGABLE_MESSAGE_NO_EXCEPTION: if (this->result_ != 0) { this->result_->value ()->_tao_decode (incoming, @@ -218,9 +215,9 @@ CORBA_Request::handle_response (TAO_InputCDR &incoming, } break; - case TAO_GIOP_USER_EXCEPTION: - case TAO_GIOP_SYSTEM_EXCEPTION: - case TAO_GIOP_LOCATION_FORWARD: + case TAO_PLUGGABLE_MESSAGE_USER_EXCEPTION: + case TAO_PLUGGABLE_MESSAGE_SYSTEM_EXCEPTION: + case TAO_PLUGGABLE_MESSAGE_LOCATION_FORWARD: default: // @@ (JP) Don't know what to do about any of these yet. ACE_ERROR ((LM_ERROR, diff --git a/TAO/tao/Resource_Factory.cpp b/TAO/tao/Resource_Factory.cpp index 25b3102c6d6..2d3a35b92ea 100644 --- a/TAO/tao/Resource_Factory.cpp +++ b/TAO/tao/Resource_Factory.cpp @@ -26,10 +26,17 @@ TAO_Cached_Connector_Lock::~TAO_Cached_Connector_Lock (void) TAO_Protocol_Item::TAO_Protocol_Item (const ACE_CString &name) : name_ (name), - factory_ (0) + factory_ (0), + factory_owner_ (0) { } +TAO_Protocol_Item::~TAO_Protocol_Item (void) +{ + if (this->factory_owner_ == 1) + delete this->factory_; +} + const ACE_CString & TAO_Protocol_Item::protocol_name (void) { @@ -43,9 +50,11 @@ TAO_Protocol_Item::factory (void) } void -TAO_Protocol_Item::factory (TAO_Protocol_Factory *factory) +TAO_Protocol_Item::factory (TAO_Protocol_Factory *factory, + int owner) { this->factory_ = factory; + this->factory_owner_ = owner; } diff --git a/TAO/tao/Resource_Factory.h b/TAO/tao/Resource_Factory.h index 3ed4f77e323..f1d8e430429 100644 --- a/TAO/tao/Resource_Factory.h +++ b/TAO/tao/Resource_Factory.h @@ -57,6 +57,10 @@ public: // creator method, the protocol name can only be set when the // object is created. + ~TAO_Protocol_Item (void); + // destructor that deallocates the factory object if the + // Protocol_Item retains ownership. + const ACE_CString &protocol_name (void); // return a reference to the character representation of the protocol // factories name. @@ -64,7 +68,7 @@ public: TAO_Protocol_Factory *factory (void); // return a pointer to the protocol factory. - void factory (TAO_Protocol_Factory *factory); + void factory (TAO_Protocol_Factory *factory, int owner = 0); // set the factory pointer's value. private: @@ -73,6 +77,9 @@ private: TAO_Protocol_Factory *factory_; // pointer to factory object. + + int factory_owner_; + // whether we own (and therefore have to delete) the factory object. }; // typedefs for containers containing the list of loaded protocol diff --git a/TAO/tao/SHMIOP_Profile.cpp b/TAO/tao/SHMIOP_Profile.cpp index 46a3ba303ae..ea53d973578 100644 --- a/TAO/tao/SHMIOP_Profile.cpp +++ b/TAO/tao/SHMIOP_Profile.cpp @@ -155,7 +155,8 @@ TAO_SHMIOP_Profile::decode (TAO_InputCDR& cdr) if (TAO_debug_level > 0) { ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("TAO (%P|%t) SHMIOP_Profile::decode - v%d.%d\n"), + ASYS_TEXT ("TAO (%P|%t) SHMIOP_Profile::decode - ") + ASYS_TEXT ("v%d.%d\n"), this->version_.major, this->version_.minor)); } @@ -174,8 +175,17 @@ TAO_SHMIOP_Profile::decode (TAO_InputCDR& cdr) return -1; } - this->object_addr_.set (this->port_, this->host_.in ()); - + if (this->object_addr_.set (this->port_, + this->host_.in ()) == -1) + { + if (TAO_debug_level > 0) + { + ACE_DEBUG ((LM_DEBUG, + ASYS_TEXT ("TAO (%P|%t) SHMIOP_Profile::decode - \n") + ASYS_TEXT ("TAO (%P|%t) ACE_INET_Addr::set () failed"))); + } + return -1; + } // ... and object key. if ((cdr >> this->object_key_) == 0) @@ -193,7 +203,8 @@ TAO_SHMIOP_Profile::decode (TAO_InputCDR& cdr) // If there is extra data in the profile we are supposed to // ignore it, but print a warning just in case... ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("%d bytes out of %d left after IIOP profile data\n"), + ASYS_TEXT ("%d bytes out of %d left after SHMIOP ") + ASYS_TEXT ("profile data\n"), cdr.length (), encap_len)); } @@ -294,7 +305,17 @@ TAO_SHMIOP_Profile::parse_string (const char *string, this->host_ = tmp._retn (); - this->object_addr_.set (this->port_, this->host_.in ()); + if (this->object_addr_.set (this->port_, + this->host_.in ()) == -1) + { + if (TAO_debug_level > 0) + { + ACE_DEBUG ((LM_DEBUG, + ASYS_TEXT ("TAO (%P|%t) SHMIOP_Profile::parse_string () - \n") + ASYS_TEXT ("TAO (%P|%t) ACE_INET_Addr::set () failed"))); + } + return -1; + } start = ++okd; // increment past the object key separator @@ -384,7 +405,7 @@ TAO_SHMIOP_Profile::operator= (const TAO_SHMIOP_Profile &src) this->object_key_ = src.object_key_; this->object_addr_.set (src.object_addr_); - + this->port_ = src.port_; this->host_ = src.host_; diff --git a/TAO/tao/SHMIOP_Transport.cpp b/TAO/tao/SHMIOP_Transport.cpp index 956f3103252..f66d228c5ee 100644 --- a/TAO/tao/SHMIOP_Transport.cpp +++ b/TAO/tao/SHMIOP_Transport.cpp @@ -248,12 +248,9 @@ TAO_SHMIOP_Client_Transport::handle_client_input (int /* block */, // OK, the complete message is here... - TAO_Pluggable_Connector_Params params; - CORBA::ULong reply_status; - result = this->client_mesg_factory_->parse_reply (*message_state, - params, - reply_status); + this->params_); + if (result == -1) { if (TAO_debug_level > 0) @@ -265,10 +262,10 @@ TAO_SHMIOP_Client_Transport::handle_client_input (int /* block */, } result = - this->tms_->dispatch_reply (params.request_id, - reply_status, + this->tms_->dispatch_reply (this->params_.request_id_, + this->params_.reply_status_, message_state->giop_version, - params.svc_ctx, + this->params_.svc_ctx_, message_state); if (result == -1) diff --git a/TAO/tao/SHMIOP_Transport.h b/TAO/tao/SHMIOP_Transport.h index 5ea7d987c9c..c6702801247 100644 --- a/TAO/tao/SHMIOP_Transport.h +++ b/TAO/tao/SHMIOP_Transport.h @@ -160,6 +160,9 @@ private: CORBA::Boolean lite_flag_; // Are we using lite? + + TAO_Pluggable_Connector_Params params_; + // The reply data that is sent back by the server }; // **************************************************************** diff --git a/TAO/tao/Sequence.cpp b/TAO/tao/Sequence.cpp index 2a232221ca2..b43ee0505d3 100644 --- a/TAO/tao/Sequence.cpp +++ b/TAO/tao/Sequence.cpp @@ -146,7 +146,11 @@ TAO_Unbounded_String_Sequence::operator[] (CORBA::ULong slot) const char* * TAO_Unbounded_String_Sequence::allocbuf (CORBA::ULong nelems) { - char* *buf = new char*[nelems]; + char **buf; + ACE_NEW_RETURN (buf, + char *[nelems], + 0); + //char* *buf = new char*[nelems]; for (CORBA::ULong i=0; i < nelems; i++) buf[i] = 0; return buf; @@ -367,7 +371,11 @@ TAO_Unbounded_WString_Sequence::operator[] (CORBA::ULong slot) const CORBA::WChar* * TAO_Unbounded_WString_Sequence::allocbuf (CORBA::ULong nelems) { - CORBA::WChar* *buf = new CORBA::WChar*[nelems]; + CORBA::WChar **buf; + ACE_NEW_RETURN (buf, + CORBA::WChar *[nelems], + 0); + // CORBA::WChar* *buf = new CORBA::WChar*[nelems]; for (CORBA::ULong i=0; i < nelems; i++) buf[i] = 0; return buf; diff --git a/TAO/tao/Sequence.h b/TAO/tao/Sequence.h index 1842066af14..33edc95bd0e 100644 --- a/TAO/tao/Sequence.h +++ b/TAO/tao/Sequence.h @@ -1,7 +1,6 @@ /* -*- C++ -*- */ // $Id$ - // ============================================================================ // // = LIBRARY diff --git a/TAO/tao/Stub.cpp b/TAO/tao/Stub.cpp index 9e9e0dc2114..71974cf51a1 100644 --- a/TAO/tao/Stub.cpp +++ b/TAO/tao/Stub.cpp @@ -1,8 +1,5 @@ // $Id$ - - - // @ (#)iiopobj.cpp 1.9 95/11/04 // Copyright 1995 by Sun Microsystems Inc. // All Rights Reserved @@ -37,8 +34,6 @@ ACE_RCSID(tao, TAO_Stub, "$Id$") - - #if defined (ACE_ENABLE_TIMEPROBES) static const char *TAO_TAO_Stub_Timeprobe_Description[] = @@ -342,7 +337,7 @@ TAO_Stub::do_static_call (CORBA::Environment &ACE_TRY_ENV, if (info->is_roundtrip) { - TAO_GIOP_Twoway_Invocation call (this, + TAO_GIOP_Twoway_Invocation call (this, info->opname, ACE_OS::strlen (info->opname), this->orb_core_); @@ -489,7 +484,7 @@ TAO_Stub::do_static_call (CORBA::Environment &ACE_TRY_ENV, } // if (two way) else { - TAO_GIOP_Oneway_Invocation call (this, + TAO_GIOP_Oneway_Invocation call (this, info->opname, ACE_OS::strlen (info->opname), this->orb_core_); diff --git a/TAO/tao/Stub.h b/TAO/tao/Stub.h index 67728abc86c..a6f55df3aca 100644 --- a/TAO/tao/Stub.h +++ b/TAO/tao/Stub.h @@ -1,7 +1,6 @@ // This may look like C, but it's really -*- C++ -*- // $Id$ - // ============================================================================ // // = LIBRARY @@ -475,7 +474,7 @@ private: // ordered list of profiles for this object. TAO_MProfile *forward_profiles_; - // The list of forwarding profiles. This is actually iimplemented as a + // The list of forwarding profiles. This is actually implemented as a // linked list of TAO_MProfile objects. TAO_Profile *profile_in_use_; diff --git a/TAO/tao/Stub.i b/TAO/tao/Stub.i index f82ea3668c4..969882d3da2 100644 --- a/TAO/tao/Stub.i +++ b/TAO/tao/Stub.i @@ -2,7 +2,6 @@ // $Id$ - ACE_INLINE TAO_Profile * TAO_Stub::set_profile_in_use_i (TAO_Profile *pfile) { diff --git a/TAO/tao/Sync_Strategies.cpp b/TAO/tao/Sync_Strategies.cpp index 11065b3b3d6..3da8c527491 100644 --- a/TAO/tao/Sync_Strategies.cpp +++ b/TAO/tao/Sync_Strategies.cpp @@ -1,9 +1,6 @@ // -*- C++ -*- // $Id$ - - - #include "tao/Sync_Strategies.h" #include "tao/Buffering_Constraint_Policy.h" diff --git a/TAO/tao/Sync_Strategies.h b/TAO/tao/Sync_Strategies.h index 3bdd0c427f8..fd303dceb00 100644 --- a/TAO/tao/Sync_Strategies.h +++ b/TAO/tao/Sync_Strategies.h @@ -1,8 +1,6 @@ // -*- C++ -*- // $Id$ - - // ============================================================================ // // = LIBRARY diff --git a/TAO/tao/TAO.cpp b/TAO/tao/TAO.cpp index e2aeb8e2539..1c58b447e47 100644 --- a/TAO/tao/TAO.cpp +++ b/TAO/tao/TAO.cpp @@ -1,6 +1,5 @@ // $Id$ - // ============================================================================ // // = LIBRARY @@ -19,7 +18,6 @@ ACE_RCSID(tao, TAO, "$Id$") - // constructor TAO_ORB_Manager::TAO_ORB_Manager (CORBA::ORB_ptr orb, PortableServer::POA_ptr poa, diff --git a/TAO/tao/TAOC.cpp b/TAO/tao/TAOC.cpp index 4aca9968af3..7b309b53287 100644 --- a/TAO/tao/TAOC.cpp +++ b/TAO/tao/TAOC.cpp @@ -1,6 +1,5 @@ /* -*- C++ -*- $Id$ */ - // ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* // TAO and the TAO IDL Compiler have been developed by the Center for // Distributed Object Computing at Washington University, St. Louis. @@ -145,12 +144,21 @@ TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ClientPriorityPolicy, &_tc_TAO_tc TAO_NAMESPACE_END void operator<<= (CORBA::Any &_tao_any, const TAO::PrioritySpecification &_tao_elem) // copying { - TAO::PrioritySpecification *_any_val; + TAO::PrioritySpecification *_any_val = 0; ACE_NEW (_any_val, TAO::PrioritySpecification (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (TAO::_tc_PrioritySpecification, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + TAO::_tc_PrioritySpecification, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -164,10 +172,23 @@ void operator<<= (CORBA::Any &_tao_any, TAO::PrioritySpecification *_tao_elem) / { ACE_TRY_NEW_ENV { - _tao_any.replace (TAO::_tc_PrioritySpecification, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + TAO::_tc_PrioritySpecification, + 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; } @@ -176,40 +197,106 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO::PrioritySpecificati ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (TAO::_tc_PrioritySpecification, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (TAO::_tc_PrioritySpecification, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (TAO::PrioritySpecification *)_tao_any.value (); return 1; - } + } else { ACE_NEW_RETURN (_tao_elem, TAO::PrioritySpecification, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (TAO::_tc_PrioritySpecification, _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 (TAO::_tc_PrioritySpecification, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + TAO::_tc_PrioritySpecification, + 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 TAO::PrioritySpecification *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (TAO::_tc_PrioritySpecification, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (TAO::PrioritySpecification *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, TAO::PrioritySpecification, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(TAO::PrioritySpecification *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + TAO::_tc_PrioritySpecification, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (TAO::PrioritySpecification *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (TAO::PrioritySpecification *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (TAO::PrioritySpecification *&, _tao_elem); + _tao_elem = 0; + return 0; + } + ACE_ENDTRY; + return 0; +} + +TAO::ClientPriorityPolicy_ptr (*_TAO_collocation_TAO_ClientPriorityPolicy_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj + ) = 0; void operator<<= (CORBA::Any &_tao_any, TAO::ClientPriorityPolicy_ptr _tao_elem) { CORBA::Object_ptr *_tao_obj_ptr = 0; @@ -217,8 +304,23 @@ void operator<<= (CORBA::Any &_tao_any, TAO::ClientPriorityPolicy_ptr _tao_elem) { ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); *_tao_obj_ptr = TAO::ClientPriorityPolicy::_duplicate (_tao_elem); - _tao_any.replace (TAO::_tc_ClientPriorityPolicy, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + TAO::_tc_ClientPriorityPolicy, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -230,34 +332,49 @@ void operator<<= (CORBA::Any &_tao_any, TAO::ClientPriorityPolicy_ptr _tao_elem) CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO::ClientPriorityPolicy_ptr &_tao_elem) { CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = TAO::ClientPriorityPolicy::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (TAO::_tc_ClientPriorityPolicy, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (TAO::_tc_ClientPriorityPolicy, 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 (TAO::_tc_ClientPriorityPolicy, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + if (stream >> _tao_obj_var.out ()) { _tao_elem = TAO::ClientPriorityPolicy::_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 (TAO::_tc_ClientPriorityPolicy, tmp, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + TAO::_tc_ClientPriorityPolicy, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = TAO::ClientPriorityPolicy::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = TAO::ClientPriorityPolicy::_nil (); return 0; } @@ -409,12 +526,21 @@ TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_BufferingConstraintPolicy, &_tc_T TAO_NAMESPACE_END void operator<<= (CORBA::Any &_tao_any, const TAO::BufferingConstraint &_tao_elem) // copying { - TAO::BufferingConstraint *_any_val; + TAO::BufferingConstraint *_any_val = 0; ACE_NEW (_any_val, TAO::BufferingConstraint (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (TAO::_tc_BufferingConstraint, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + TAO::_tc_BufferingConstraint, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -428,10 +554,23 @@ void operator<<= (CORBA::Any &_tao_any, TAO::BufferingConstraint *_tao_elem) // { ACE_TRY_NEW_ENV { - _tao_any.replace (TAO::_tc_BufferingConstraint, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + TAO::_tc_BufferingConstraint, + 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; } @@ -440,40 +579,106 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO::BufferingConstraint ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (TAO::_tc_BufferingConstraint, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (TAO::_tc_BufferingConstraint, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (TAO::BufferingConstraint *)_tao_any.value (); return 1; - } + } else { ACE_NEW_RETURN (_tao_elem, TAO::BufferingConstraint, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (TAO::_tc_BufferingConstraint, _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 (TAO::_tc_BufferingConstraint, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + TAO::_tc_BufferingConstraint, + 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 TAO::BufferingConstraint *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (TAO::_tc_BufferingConstraint, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (TAO::BufferingConstraint *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, TAO::BufferingConstraint, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(TAO::BufferingConstraint *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + TAO::_tc_BufferingConstraint, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (TAO::BufferingConstraint *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (TAO::BufferingConstraint *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (TAO::BufferingConstraint *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; } +TAO::BufferingConstraintPolicy_ptr (*_TAO_collocation_TAO_BufferingConstraintPolicy_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj + ) = 0; void operator<<= (CORBA::Any &_tao_any, TAO::BufferingConstraintPolicy_ptr _tao_elem) { CORBA::Object_ptr *_tao_obj_ptr = 0; @@ -481,8 +686,23 @@ void operator<<= (CORBA::Any &_tao_any, TAO::BufferingConstraintPolicy_ptr _tao_ { ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); *_tao_obj_ptr = TAO::BufferingConstraintPolicy::_duplicate (_tao_elem); - _tao_any.replace (TAO::_tc_BufferingConstraintPolicy, _tao_obj_ptr, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + TAO_OutputCDR stream; + if (stream << *_tao_obj_ptr) + { + _tao_any._tao_replace ( + TAO::_tc_BufferingConstraintPolicy, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_obj_ptr, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + } + else + { + delete _tao_obj_ptr; + } } ACE_CATCHANY { @@ -494,34 +714,49 @@ void operator<<= (CORBA::Any &_tao_any, TAO::BufferingConstraintPolicy_ptr _tao_ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO::BufferingConstraintPolicy_ptr &_tao_elem) { CORBA::Object_ptr *tmp = 0; + ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = TAO::BufferingConstraintPolicy::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (TAO::_tc_BufferingConstraintPolicy, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (TAO::_tc_BufferingConstraintPolicy, 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 (TAO::_tc_BufferingConstraintPolicy, &_tao_obj_var.out (), 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + if (stream >> _tao_obj_var.out ()) { _tao_elem = TAO::BufferingConstraintPolicy::_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 (TAO::_tc_BufferingConstraintPolicy, tmp, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + TAO::_tc_BufferingConstraintPolicy, + 1, + tmp, + ACE_TRY_ENV + ); ACE_TRY_CHECK; return 1; } - // failure + else // failure + { + delete tmp; + } } ACE_CATCHANY { delete tmp; + _tao_elem = TAO::BufferingConstraintPolicy::_nil (); return 0; } ACE_ENDTRY; + _tao_elem = TAO::BufferingConstraintPolicy::_nil (); return 0; } diff --git a/TAO/tao/TAOC.h b/TAO/tao/TAOC.h index 86564f10224..ee90c5bdccf 100644 --- a/TAO/tao/TAOC.h +++ b/TAO/tao/TAOC.h @@ -1,6 +1,5 @@ /* -*- C++ -*- $Id$ */ - // ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* // TAO and the TAO IDL Compiler have been developed by the Center for // Distributed Object Computing at Washington University, St. Louis. @@ -422,18 +421,34 @@ TAO_NAMESPACE_CLOSE // module TAO #if (TAO_HAS_CORBA_MESSAGING == 1) -TAO_Export void operator<<= (CORBA::Any &, const TAO::PrioritySpecification &); // copying version -TAO_Export void operator<<= (CORBA::Any &, TAO::PrioritySpecification*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, TAO::PrioritySpecification *&); +TAO_Export void operator<<= (CORBA::Any &, + const TAO::PrioritySpecification &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + TAO::PrioritySpecification*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + TAO::PrioritySpecification *&); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const TAO::PrioritySpecification *&); + // Any operators for interface TAO::ClientPriorityPolicy -TAO_Export void operator<<= (CORBA::Any &, TAO::ClientPriorityPolicy_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, TAO::ClientPriorityPolicy *&); -TAO_Export void operator<<= (CORBA::Any &, const TAO::BufferingConstraint &); // copying version -TAO_Export void operator<<= (CORBA::Any &, TAO::BufferingConstraint*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, TAO::BufferingConstraint *&); +TAO_Export void operator<<= (CORBA::Any &, + TAO::ClientPriorityPolicy_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + TAO::ClientPriorityPolicy *&); +TAO_Export void operator<<= (CORBA::Any &, + const TAO::BufferingConstraint &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + TAO::BufferingConstraint*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + TAO::BufferingConstraint *&); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const TAO::BufferingConstraint *&); + // Any operators for interface TAO::BufferingConstraintPolicy -void operator<<= (CORBA::Any &, TAO::BufferingConstraintPolicy_ptr); -CORBA::Boolean operator>>= (const CORBA::Any &, TAO::BufferingConstraintPolicy *&); +TAO_Export void operator<<= (CORBA::Any &, + TAO::BufferingConstraintPolicy_ptr); +CORBA::Boolean operator>>= (const CORBA::Any &, + TAO::BufferingConstraintPolicy *&); #endif /* TAO_HAS_CORBA_MESSAGING == 1 */ diff --git a/TAO/tao/TAOC.i b/TAO/tao/TAOC.i index 6f8a4620d54..cc0e7b01748 100644 --- a/TAO/tao/TAOC.i +++ b/TAO/tao/TAOC.i @@ -1,6 +1,5 @@ /* -*- C++ -*- $Id$ */ - // ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* // TAO and the TAO IDL Compiler have been developed by the Center for // Distributed Object Computing at Washington University, St. Louis. diff --git a/TAO/tao/TAOS.cpp b/TAO/tao/TAOS.cpp index 962f15a80d2..e04923885cd 100644 --- a/TAO/tao/TAOS.cpp +++ b/TAO/tao/TAOS.cpp @@ -1,7 +1,5 @@ /* -*- C++ -*- $Id$ */ - - // ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* // TAO and the TAO IDL Compiler have been developed by the Center for // Distributed Object Computing at Washington University, St. Louis. diff --git a/TAO/tao/TAOS.h b/TAO/tao/TAOS.h index e4099dd5f00..0485ef30c6c 100644 --- a/TAO/tao/TAOS.h +++ b/TAO/tao/TAOS.h @@ -1,6 +1,5 @@ /* -*- C++ -*- $Id$ */ - // ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* // TAO and the TAO IDL Compiler have been developed by the Center for // Distributed Object Computing at Washington University, St. Louis. diff --git a/TAO/tao/TAO_Internal.cpp b/TAO/tao/TAO_Internal.cpp index a58bb6f8771..b1679af2f18 100644 --- a/TAO/tao/TAO_Internal.cpp +++ b/TAO/tao/TAO_Internal.cpp @@ -1,8 +1,5 @@ // $Id$ - - - #include "tao/TAO_Internal.h" #include "ace/Service_Config.h" #include "ace/Service_Repository.h" @@ -14,10 +11,8 @@ #include "tao/UIOP_Factory.h" #include "tao/SHMIOP_Factory.h" - ACE_RCSID(tao, TAO_Internal, "$Id$") - int TAO_Internal::service_open_count_ = 0; #if defined (TAO_PLATFORM_SVC_CONF_FILE_NOTSUP) const char *TAO_Internal::resource_factory_args_ = TAO_DEFAULT_RESOURCE_FACTORY_ARGS; @@ -78,7 +73,6 @@ TAO_Internal::open_services (int &argc, ACE_Service_Config::static_svcs ()-> insert (&ace_svc_desc_TAO_SHMIOP_Protocol_Factory); #endif /* TAO_HAS_UIOP == 1 */ - // add descriptor to list of static objects. int result = 0; diff --git a/TAO/tao/Tagged_Components.h b/TAO/tao/Tagged_Components.h index 1a76064509e..75f6ea26068 100644 --- a/TAO/tao/Tagged_Components.h +++ b/TAO/tao/Tagged_Components.h @@ -1,7 +1,6 @@ // -*- C++ -*- // $Id$ - // ============================================================================ // // = LIBRARY diff --git a/TAO/tao/Tagged_Components.i b/TAO/tao/Tagged_Components.i index 63978735314..da5b23331ba 100644 --- a/TAO/tao/Tagged_Components.i +++ b/TAO/tao/Tagged_Components.i @@ -1,6 +1,5 @@ // $Id$ - ACE_INLINE TAO_Tagged_Components::TAO_Tagged_Components (void) : orb_type_ (0), diff --git a/TAO/tao/TimeBaseC.cpp b/TAO/tao/TimeBaseC.cpp index ec2f84b51b3..2d0c76cb4b9 100644 --- a/TAO/tao/TimeBaseC.cpp +++ b/TAO/tao/TimeBaseC.cpp @@ -133,12 +133,21 @@ TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_IntervalT, &_tc_TAO_tc_TimeBase_I TAO_NAMESPACE_END void operator<<= (CORBA::Any &_tao_any, const TimeBase::UtcT &_tao_elem) // copying { - TimeBase::UtcT *_any_val; + TimeBase::UtcT *_any_val = 0; ACE_NEW (_any_val, TimeBase::UtcT (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (TimeBase::_tc_UtcT, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + TimeBase::_tc_UtcT, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -152,10 +161,23 @@ void operator<<= (CORBA::Any &_tao_any, TimeBase::UtcT *_tao_elem) // non copyin { ACE_TRY_NEW_ENV { - _tao_any.replace (TimeBase::_tc_UtcT, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + TimeBase::_tc_UtcT, + 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; } @@ -164,35 +186,98 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TimeBase::UtcT *&_tao_el ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (TimeBase::_tc_UtcT, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (TimeBase::_tc_UtcT, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (TimeBase::UtcT *)_tao_any.value (); return 1; - } + } else { ACE_NEW_RETURN (_tao_elem, TimeBase::UtcT, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (TimeBase::_tc_UtcT, _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 (TimeBase::_tc_UtcT, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + TimeBase::_tc_UtcT, + 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 TimeBase::UtcT *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (TimeBase::_tc_UtcT, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (TimeBase::UtcT *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, TimeBase::UtcT, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(TimeBase::UtcT *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + TimeBase::_tc_UtcT, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (TimeBase::UtcT *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (TimeBase::UtcT *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (TimeBase::UtcT *&, _tao_elem); + _tao_elem = 0; + return 0; } ACE_ENDTRY; return 0; @@ -200,12 +285,21 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TimeBase::UtcT *&_tao_el void operator<<= (CORBA::Any &_tao_any, const TimeBase::IntervalT &_tao_elem) // copying { - TimeBase::IntervalT *_any_val; + TimeBase::IntervalT *_any_val = 0; ACE_NEW (_any_val, TimeBase::IntervalT (_tao_elem)); if (!_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (TimeBase::_tc_IntervalT, _any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << *_any_val; + _tao_any._tao_replace ( + TimeBase::_tc_IntervalT, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV + ); ACE_TRY_CHECK; } ACE_CATCHANY @@ -219,10 +313,23 @@ void operator<<= (CORBA::Any &_tao_any, TimeBase::IntervalT *_tao_elem) // non c { ACE_TRY_NEW_ENV { - _tao_any.replace (TimeBase::_tc_IntervalT, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + TimeBase::_tc_IntervalT, + 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; } @@ -231,36 +338,100 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TimeBase::IntervalT *&_t ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equal (TimeBase::_tc_IntervalT, ACE_TRY_ENV)) return 0; // not equal + if (!type->equivalent (TimeBase::_tc_IntervalT, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { _tao_elem = (TimeBase::IntervalT *)_tao_any.value (); return 1; - } + } else { ACE_NEW_RETURN (_tao_elem, TimeBase::IntervalT, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (TimeBase::_tc_IntervalT, _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 (TimeBase::_tc_IntervalT, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + TimeBase::_tc_IntervalT, + 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 TimeBase::IntervalT *&_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (TimeBase::_tc_IntervalT, ACE_TRY_ENV)) // not equal + { + _tao_elem = 0; + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (TimeBase::IntervalT *)_tao_any.value (); + return 1; + } + else + { + ACE_NEW_RETURN (_tao_elem, TimeBase::IntervalT, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *(TimeBase::IntervalT *)_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + TimeBase::_tc_IntervalT, + 1, + ACE_reinterpret_cast (void *, ACE_const_cast (TimeBase::IntervalT *&, _tao_elem)), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + else + { + delete ACE_const_cast (TimeBase::IntervalT *&, _tao_elem); + _tao_elem = 0; + } + } + } + ACE_CATCHANY + { + delete ACE_const_cast (TimeBase::IntervalT *&, _tao_elem); + _tao_elem = 0; + return 0; + } + ACE_ENDTRY; + return 0; +} + diff --git a/TAO/tao/TimeBaseC.h b/TAO/tao/TimeBaseC.h index c05e300be1a..cc7dcb931fc 100644 --- a/TAO/tao/TimeBaseC.h +++ b/TAO/tao/TimeBaseC.h @@ -1,7 +1,6 @@ /* -*- C++ -*- */ // // $Id$ - // // ================================================================ // @@ -135,12 +134,22 @@ TAO_NAMESPACE TimeBase } TAO_NAMESPACE_CLOSE // module TimeBase -TAO_Export void operator<<= (CORBA::Any &, const TimeBase::UtcT &); // copying version -TAO_Export void operator<<= (CORBA::Any &, TimeBase::UtcT*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, TimeBase::UtcT *&); -TAO_Export void operator<<= (CORBA::Any &, const TimeBase::IntervalT &); // copying version -TAO_Export void operator<<= (CORBA::Any &, TimeBase::IntervalT*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, TimeBase::IntervalT *&); +TAO_Export void operator<<= (CORBA::Any &, + const TimeBase::UtcT &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + TimeBase::UtcT*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + TimeBase::UtcT *&); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const TimeBase::UtcT *&); +TAO_Export void operator<<= (CORBA::Any &, + const TimeBase::IntervalT &); // copying version +TAO_Export void operator<<= (CORBA::Any &, + TimeBase::IntervalT*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + TimeBase::IntervalT *&); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, + const TimeBase::IntervalT *&); #if defined (__ACE_INLINE__) #include "tao/TimeBaseC.i" diff --git a/TAO/tao/Transport_Mux_Strategy.cpp b/TAO/tao/Transport_Mux_Strategy.cpp index ef7fae8b222..c970eb78765 100644 --- a/TAO/tao/Transport_Mux_Strategy.cpp +++ b/TAO/tao/Transport_Mux_Strategy.cpp @@ -1,6 +1,5 @@ // $Id$ - #include "tao/Transport_Mux_Strategy.h" #include "tao/Reply_Dispatcher.h" #include "tao/debug.h" diff --git a/TAO/tao/Transport_Mux_Strategy.h b/TAO/tao/Transport_Mux_Strategy.h index f6d1cbd08b7..f6e59671b9e 100644 --- a/TAO/tao/Transport_Mux_Strategy.h +++ b/TAO/tao/Transport_Mux_Strategy.h @@ -2,6 +2,7 @@ // $Id$ + // ============================================================================ // // = LIBRARY diff --git a/TAO/tao/Typecode.cpp b/TAO/tao/Typecode.cpp index 919a5926c2f..03b27e5742b 100644 --- a/TAO/tao/Typecode.cpp +++ b/TAO/tao/Typecode.cpp @@ -1787,9 +1787,13 @@ CORBA_TypeCode::private_member_name (CORBA::ULong slot, else ACE_THROW_RETURN (CORBA::TypeCode::Bounds (), 0); - // the first time in. Precompute and store names of all members - // Allocate a list to hold the member names - this->private_state_->tc_member_name_list_ = new char* [mcount]; + // the first time in. Precompute and store names of all members + // Allocate a list to hold the member names + ACE_NEW_THROW_EX (this->private_state_->tc_member_name_list_, + char* [mcount], + CORBA::NO_MEMORY ()); + ACE_CHECK_RETURN (0); + // this->private_state_->tc_member_name_list_ = new char* [mcount]; if (this->private_state_->tc_member_name_list_ == 0) // no memory for the member_list @@ -1833,9 +1837,13 @@ CORBA_TypeCode::private_member_name (CORBA::ULong slot, else ACE_THROW_RETURN (CORBA::TypeCode::Bounds (), 0); - // the first time in. Precompute and store names of all members - // Allocate a list to hold the member names - this->private_state_->tc_member_name_list_ = new char* [mcount]; + // the first time in. Precompute and store names of all members + // Allocate a list to hold the member names + ACE_NEW_THROW_EX (this->private_state_->tc_member_name_list_, + char* [mcount], + CORBA::NO_MEMORY ()); + ACE_CHECK_RETURN (0); + //this->private_state_->tc_member_name_list_ = new char* [mcount]; if (this->private_state_->tc_member_name_list_ == 0) // no memory for the member_list @@ -1878,9 +1886,13 @@ CORBA_TypeCode::private_member_name (CORBA::ULong slot, else ACE_THROW_RETURN (CORBA::TypeCode::Bounds (), 0); - // the first time in. Precompute and store names of all members - // Allocate a list to hold the member names - this->private_state_->tc_member_name_list_ = new char* [mcount]; + // the first time in. Precompute and store names of all members + // Allocate a list to hold the member names + ACE_NEW_THROW_EX (this->private_state_->tc_member_name_list_, + char* [mcount], + CORBA::NO_MEMORY ()); + ACE_CHECK_RETURN (0); + // this->private_state_->tc_member_name_list_ = new char* [mcount]; if (this->private_state_->tc_member_name_list_ == 0) // no memory for the member_list diff --git a/TAO/tao/Typecode_Constants.cpp b/TAO/tao/Typecode_Constants.cpp index f319545e38d..0e350127443 100644 --- a/TAO/tao/Typecode_Constants.cpp +++ b/TAO/tao/Typecode_Constants.cpp @@ -1,8 +1,5 @@ // $Id$ - - - // ============================================================================ // // = LIBRARY @@ -31,7 +28,6 @@ #include "tao/Typecode.h" #include "tao/ORB.h" -//#include "tao/GIOP.h" #include "tao/Object.h" #include "tao/Object_KeyC.h" #include "tao/PolicyC.h" @@ -48,12 +44,8 @@ #include "tao/PollableC.h" #endif /* TAO_HAS_AMI_POLLER == 1 */ - - - ACE_RCSID(tao, Typecode_Constants, "$Id$") - // Declare all the standard typecodes owned by the ORB // Null and void diff --git a/TAO/tao/UIOP_Acceptor.cpp b/TAO/tao/UIOP_Acceptor.cpp index cc5c58d09d5..c7ea477dec9 100644 --- a/TAO/tao/UIOP_Acceptor.cpp +++ b/TAO/tao/UIOP_Acceptor.cpp @@ -1,7 +1,6 @@ // This may look like C, but it's really -*- C++ -*- // $Id$ - // ============================================================================ // // = LIBRARY @@ -28,9 +27,8 @@ #include "tao/Server_Strategy_Factory.h" #include "tao/debug.h" -ACE_RCSID(tao, UIOP_Acceptor, "$Id$") - +ACE_RCSID(tao, UIOP_Acceptor, "$Id$") #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) @@ -58,6 +56,7 @@ template class TAO_Accept_Strategy<TAO_UIOP_Server_Connection_Handler, ACE_LSOCK #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + TAO_UIOP_Acceptor::TAO_UIOP_Acceptor (CORBA::Boolean flag) : TAO_Acceptor (TAO_TAG_UIOP_PROFILE), base_acceptor_ (), diff --git a/TAO/tao/UIOP_Connect.cpp b/TAO/tao/UIOP_Connect.cpp index a7c2161b294..e159bfbd159 100644 --- a/TAO/tao/UIOP_Connect.cpp +++ b/TAO/tao/UIOP_Connect.cpp @@ -1,7 +1,6 @@ // $Id$ - #include "tao/UIOP_Connect.h" #if TAO_HAS_UIOP == 1 @@ -19,12 +18,10 @@ # include "tao/UIOP_Connect.i" #endif /* ! __ACE_INLINE__ */ -#include "tao/GIOP_Message_Acceptors.h" -#include "tao/GIOP_Message_Lite.h" - ACE_RCSID(tao, UIOP_Connect, "$Id$") - +#include "tao/GIOP_Message_Acceptors.h" +#include "tao/GIOP_Message_Lite.h" #if defined (ACE_ENABLE_TIMEPROBES) diff --git a/TAO/tao/UIOP_Connect.i b/TAO/tao/UIOP_Connect.i index faedd405292..c79da486e4d 100644 --- a/TAO/tao/UIOP_Connect.i +++ b/TAO/tao/UIOP_Connect.i @@ -1,9 +1,9 @@ // -*- C++ -*- // $Id$ - #if TAO_HAS_UIOP == 1 + ACE_INLINE TAO_Transport * TAO_UIOP_Server_Connection_Handler::transport (void) { diff --git a/TAO/tao/UIOP_Connector.cpp b/TAO/tao/UIOP_Connector.cpp index 8dcb4353926..67ead2ce0d3 100644 --- a/TAO/tao/UIOP_Connector.cpp +++ b/TAO/tao/UIOP_Connector.cpp @@ -12,10 +12,8 @@ #include "tao/Environment.h" #include "ace/Auto_Ptr.h" - ACE_RCSID(tao, UIOP_Connector, "$Id$") - #if defined (TAO_USES_ROBUST_CONNECTION_MGMT) int TAO_UIOP_Connector::purge_connections (void) diff --git a/TAO/tao/UIOP_Factory.cpp b/TAO/tao/UIOP_Factory.cpp index 5e1ae1d8b4e..09fc3875bed 100644 --- a/TAO/tao/UIOP_Factory.cpp +++ b/TAO/tao/UIOP_Factory.cpp @@ -1,7 +1,6 @@ // -*- C++ -*- // $Id$ - #include "tao/UIOP_Factory.h" #if TAO_HAS_UIOP == 1 @@ -12,7 +11,6 @@ ACE_RCSID(tao, UIOP_Factory, "$Id$") - static const char prefix_[] = "uiop"; TAO_UIOP_Protocol_Factory::TAO_UIOP_Protocol_Factory (void) diff --git a/TAO/tao/UIOP_Factory.h b/TAO/tao/UIOP_Factory.h index 28f1afea5ff..aa79e57a1af 100644 --- a/TAO/tao/UIOP_Factory.h +++ b/TAO/tao/UIOP_Factory.h @@ -1,6 +1,5 @@ // -*- C++ -*- // $Id$ - // ============================================================================ // // = LIBRARY @@ -60,7 +59,6 @@ private: int minor_; // Changing the version number can be used to provide backwards // compatibility with old clients. - }; ACE_STATIC_SVC_DECLARE (TAO_UIOP_Protocol_Factory) diff --git a/TAO/tao/UIOP_Profile.cpp b/TAO/tao/UIOP_Profile.cpp index 88ab16a5366..47747dbbb6e 100644 --- a/TAO/tao/UIOP_Profile.cpp +++ b/TAO/tao/UIOP_Profile.cpp @@ -2,7 +2,6 @@ // $Id$ - #include "tao/UIOP_Profile.h" #if TAO_HAS_UIOP == 1 @@ -326,8 +325,17 @@ TAO_UIOP_Profile::decode (TAO_InputCDR& cdr) ACE_DEBUG ((LM_DEBUG, "error decoding UIOP rendezvous_point")); return -1; } - - this->object_addr_.set (rendezvous); + + if (this->object_addr_.set (rendezvous) == -1) + { + if (TAO_debug_level > 0) + { + ACE_DEBUG ((LM_DEBUG, + ASYS_TEXT ("TAO (%P|%t) UIOP_Profile::decode - \n") + ASYS_TEXT ("TAO (%P|%t) ACE_UNIX_Addr::set () failed"))); + } + return -1; + } // Clean up delete [] rendezvous; diff --git a/TAO/tao/UIOP_Profile.h b/TAO/tao/UIOP_Profile.h index dc558260865..9a4c1749a5a 100644 --- a/TAO/tao/UIOP_Profile.h +++ b/TAO/tao/UIOP_Profile.h @@ -1,7 +1,6 @@ // This may look like C, but it's really -*- C++ -*- // $Id$ - // ============================================================================ // // = LIBRARY diff --git a/TAO/tao/UIOP_Profile.i b/TAO/tao/UIOP_Profile.i index da2ae3e7f75..04e3cb9859c 100644 --- a/TAO/tao/UIOP_Profile.i +++ b/TAO/tao/UIOP_Profile.i @@ -1,7 +1,6 @@ // -*- C++ -*- // $Id$ - # if TAO_HAS_UIOP == 1 ACE_INLINE const TAO_ObjectKey & diff --git a/TAO/tao/UIOP_Transport.cpp b/TAO/tao/UIOP_Transport.cpp index d0b0219020e..7b64fc34cf3 100644 --- a/TAO/tao/UIOP_Transport.cpp +++ b/TAO/tao/UIOP_Transport.cpp @@ -2,8 +2,6 @@ // $Id$ - - #include "tao/UIOP_Transport.h" #if TAO_HAS_UIOP == 1 @@ -262,12 +260,8 @@ TAO_UIOP_Client_Transport::handle_client_input (int /* block */, // OK, the complete message is here... - TAO_Pluggable_Connector_Params params; - CORBA::ULong reply_status; - result = this->client_mesg_factory_->parse_reply (*message_state, - params, - reply_status); + this->params_); if (result == -1) { if (TAO_debug_level > 0) @@ -279,10 +273,10 @@ TAO_UIOP_Client_Transport::handle_client_input (int /* block */, } result = - this->tms_->dispatch_reply (params.request_id, - reply_status, + this->tms_->dispatch_reply (this->params_.request_id_, + this->params_.reply_status_, message_state->giop_version, - params.svc_ctx, + this->params_.svc_ctx_, message_state); if (result == -1) @@ -462,7 +456,6 @@ TAO_UIOP_Transport::send_request (TAO_Stub *, return -1; } - CORBA::Boolean TAO_UIOP_Transport::send_request_header (TAO_Operation_Details & /*opdetails*/, TAO_Target_Specification & /*spec*/, @@ -474,3 +467,4 @@ TAO_UIOP_Transport::send_request_header (TAO_Operation_Details & /*opdetails*/, #endif /* TAO_HAS_UIOP */ + diff --git a/TAO/tao/UIOP_Transport.h b/TAO/tao/UIOP_Transport.h index f61c75f5035..32740e3bbdf 100644 --- a/TAO/tao/UIOP_Transport.h +++ b/TAO/tao/UIOP_Transport.h @@ -34,7 +34,6 @@ #endif /* ACE_LACKS_PRAGMA_ONCE */ - # if TAO_HAS_UIOP == 1 // Forward decls. @@ -172,6 +171,9 @@ private: CORBA::Boolean lite_flag_; // We using GIOP lite? + + TAO_Pluggable_Connector_Params params_; + // The reply data that is sent back by the server }; // **************************************************************** diff --git a/TAO/tao/ValueBase.cpp b/TAO/tao/ValueBase.cpp index 7eacefaecb3..6037f7bb9c3 100644 --- a/TAO/tao/ValueBase.cpp +++ b/TAO/tao/ValueBase.cpp @@ -1,6 +1,5 @@ // $Id$ - // ============================================================================ // // = LIBRARY @@ -28,7 +27,6 @@ ACE_RCSID(tao, ValueBase, "$Id$") - // destructor CORBA_ValueBase::~CORBA_ValueBase (void) { diff --git a/TAO/tao/Version.h b/TAO/tao/Version.h index 0f7bc003b47..694c310ff34 100644 --- a/TAO/tao/Version.h +++ b/TAO/tao/Version.h @@ -1,9 +1,7 @@ // $Id$ - // This is an automatically generated file. #define TAO_MAJOR_VERSION 1 #define TAO_MINOR_VERSION 0 -#define TAO_BETA_VERSION 14 -#define TAO_VERSION "1.0.14" - +#define TAO_BETA_VERSION 15 +#define TAO_VERSION "1.0.15" diff --git a/TAO/tao/Wait_Strategy.cpp b/TAO/tao/Wait_Strategy.cpp index 4f8a4116fff..f6a9eb319ff 100644 --- a/TAO/tao/Wait_Strategy.cpp +++ b/TAO/tao/Wait_Strategy.cpp @@ -1,6 +1,5 @@ // $Id$ - #include "tao/Wait_Strategy.h" #include "tao/Pluggable.h" #include "tao/ORB_Core.h" @@ -9,7 +8,6 @@ ACE_RCSID(tao, Wait_Strategy, "$Id$") - // Constructor. TAO_Wait_Strategy::TAO_Wait_Strategy (TAO_Transport *transport) : transport_ (transport) diff --git a/TAO/tao/WrongTransactionC.cpp b/TAO/tao/WrongTransactionC.cpp index 2a62ed0aedc..bbf70ea2292 100644 --- a/TAO/tao/WrongTransactionC.cpp +++ b/TAO/tao/WrongTransactionC.cpp @@ -9,6 +9,8 @@ // http://www.cs.wustl.edu/~schmidt/TAO.html #include "tao/WrongTransactionC.h" +#include "tao/Environment.h" +#include "tao/CDR.h" #if !defined (TAO_HAS_MINIMUM_CORBA) @@ -49,12 +51,27 @@ CORBA_WrongTransaction::_narrow (CORBA::Exception *exc) } -void CORBA_WrongTransaction::_raise () +void CORBA_WrongTransaction::_raise (void) { TAO_RAISE(*this); } -// TAO extension - the _alloc method +void CORBA_WrongTransaction::_tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +void CORBA_WrongTransaction::_tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + CORBA::Exception *CORBA_WrongTransaction::_alloc (void) { CORBA::Exception *retval = 0; @@ -66,4 +83,18 @@ CORBA::Exception *CORBA_WrongTransaction::_alloc (void) return retval; } +CORBA::Boolean +operator<< (TAO_OutputCDR &cdr, const CORBA_WrongTransaction &wt) +{ + if (cdr << wt._id ()) + return 1; + return 0; +} + +CORBA::Boolean +operator>> (TAO_InputCDR &, CORBA_WrongTransaction &) +{ + return 1; +} + #endif /* TAO_HAS_MINIMUM_CORBA */ diff --git a/TAO/tao/WrongTransactionC.h b/TAO/tao/WrongTransactionC.h index 97d77d6a07f..68fe14c35fa 100644 --- a/TAO/tao/WrongTransactionC.h +++ b/TAO/tao/WrongTransactionC.h @@ -63,6 +63,11 @@ public: virtual void _raise (void); + virtual void _tao_encode (TAO_OutputCDR &cdr, + CORBA::Environment &) const; + virtual void _tao_decode (TAO_InputCDR &cdr, + CORBA::Environment &); + static CORBA_WrongTransaction *_narrow (CORBA::Exception *); @@ -71,6 +76,11 @@ public: }; // exception CORBA::WrongTransaction +TAO_Export CORBA::Boolean +operator<< (TAO_OutputCDR &, const CORBA_WrongTransaction &); +TAO_Export CORBA::Boolean +operator>> (TAO_InputCDR &, CORBA_WrongTransaction &); + #if defined(_MSC_VER) && (_MSC_VER >= 1200) #pragma warning(pop) #endif /* _MSC_VER */ diff --git a/TAO/tao/append.cpp b/TAO/tao/append.cpp index 32f5a4bc665..2fdf7870a95 100644 --- a/TAO/tao/append.cpp +++ b/TAO/tao/append.cpp @@ -1,6 +1,5 @@ // $Id$ - // ============================================================================ // // = LIBRARY @@ -28,7 +27,6 @@ ACE_RCSID(tao, append, "$Id$") - // Encode instances of arbitrary data types based only on typecode. // "data" points to the data type; if it's not a primitve data type, // the TypeCode interpreter is used to recursively encode its diff --git a/TAO/tao/corbafwd.h b/TAO/tao/corbafwd.h index 11ef1dea513..8c5df57f66c 100644 --- a/TAO/tao/corbafwd.h +++ b/TAO/tao/corbafwd.h @@ -1,7 +1,6 @@ // -*- C++ -*- // $Id$ - // ============================================================================ // // = LIBRARY diff --git a/TAO/tao/deep_free.cpp b/TAO/tao/deep_free.cpp index 6bd09ce97a3..d5fcae12cb2 100644 --- a/TAO/tao/deep_free.cpp +++ b/TAO/tao/deep_free.cpp @@ -322,7 +322,7 @@ TAO_Marshal_Union::deep_free (CORBA::TypeCode_ptr tc, CORBA::Environment &ACE_TRY_ENV) { CORBA::TypeCode::traverse_status retval = CORBA::TypeCode::TRAVERSE_CONTINUE; - CORBA::TypeCode_ptr discrim_tc; + CORBA::TypeCode_var discrim_tc; CORBA::TypeCode_var member_tc; CORBA::Any_ptr member_label; const void *discrim_val; @@ -424,7 +424,7 @@ TAO_Marshal_Union::deep_free (CORBA::TypeCode_ptr tc, if (discrim_matched) { // deep_free the discriminator value - retval = DEEP_FREE (discrim_tc, + retval = DEEP_FREE (discrim_tc.in (), discrim_val, data2, ACE_TRY_ENV); @@ -446,7 +446,7 @@ TAO_Marshal_Union::deep_free (CORBA::TypeCode_ptr tc, // we are here only if there was no match // deep_free the discriminator value - retval = DEEP_FREE (discrim_tc, + retval = DEEP_FREE (discrim_tc.in (), discrim_val, data2, ACE_TRY_ENV); diff --git a/TAO/tao/default_client.cpp b/TAO/tao/default_client.cpp index 191a30f8a0f..c889dd18ab9 100644 --- a/TAO/tao/default_client.cpp +++ b/TAO/tao/default_client.cpp @@ -1,6 +1,5 @@ // $Id$ - #include "tao/default_client.h" #include "tao/ORB_Core.h" #include "tao/Wait_Strategy.h" @@ -12,7 +11,6 @@ ACE_RCSID(tao, default_client, "$Id$") - TAO_Default_Client_Strategy_Factory::TAO_Default_Client_Strategy_Factory (void) : profile_lock_type_ (TAO_THREAD_LOCK), cached_connector_lock_type_ (TAO_THREAD_LOCK) diff --git a/TAO/tao/default_resource.cpp b/TAO/tao/default_resource.cpp index c60881094f2..8e31058b01e 100644 --- a/TAO/tao/default_resource.cpp +++ b/TAO/tao/default_resource.cpp @@ -1,6 +1,5 @@ // $Id$ - #include "tao/default_resource.h" #include "tao/Client_Strategy_Factory.h" #include "tao/Server_Strategy_Factory.h" @@ -24,6 +23,7 @@ #include "ace/TP_Reactor.h" #include "ace/Dynamic_Service.h" #include "ace/Arg_Shifter.h" +#include "ace/Auto_Ptr.h" #if !defined (__ACE_INLINE__) # include "tao/default_resource.i" @@ -31,7 +31,6 @@ ACE_RCSID(tao, default_resource, "$Id$") - TAO_Default_Resource_Factory::TAO_Default_Resource_Factory (void) : use_tss_resources_ (0), use_locked_data_blocks_ (1), @@ -360,10 +359,16 @@ TAO_Default_Resource_Factory::init_protocol_factories (void) // the `/etc/ld.so.conf' file on some UNIX systems. Remember to // run "ldconfig" if you modify `/etc/ld.so.conf'. - TAO_Protocol_Factory *protocol_factory = 0; + auto_ptr<TAO_Protocol_Factory> safe_protocol_factory; + TAO_Protocol_Item *item = 0; + // If a protocol factory is obtained from the Service + // Configurator then do not transfer ownership to the + // TAO_Protocol_Item. + int transfer_ownership = 0; + protocol_factory = ACE_Dynamic_Service<TAO_Protocol_Factory>::instance ("IIOP_Factory"); @@ -371,36 +376,62 @@ TAO_Default_Resource_Factory::init_protocol_factories (void) { if (TAO_orbdebug) ACE_ERROR ((LM_WARNING, - ASYS_TEXT ("TAO (%P|%t) No %s found in Service Repository. ") - ASYS_TEXT ("Using default instance IIOP Protocol Factory.\n"), + ASYS_TEXT ("TAO (%P|%t) No %s found in ") + ASYS_TEXT ("Service Repository. ") + ASYS_TEXT ("Using default instance IIOP ") + ASYS_TEXT ("Protocol Factory.\n"), ASYS_TEXT ("IIOP Protocol Factory"))); ACE_NEW_RETURN (protocol_factory, TAO_IIOP_Protocol_Factory, -1); + + ACE_AUTO_PTR_RESET (safe_protocol_factory, + protocol_factory, + TAO_Protocol_Factory); + + transfer_ownership = 1; + } + else + { + transfer_ownership = 0; } ACE_NEW_RETURN (item, TAO_Protocol_Item ("IIOP_Factory"), -1); - item->factory (protocol_factory); + // If the TAO_Protocol_Item retains ownership of the + // TAO_Protocol_Factory then we used an auto_ptr<> above, so + // release the TAO_Protocol_Factory from it. Otherwise, we + // obtained the TAO_Protocol_Factory from the Service + // Configurator so an auto_ptr<> wasn't used since the Service + // Configurator retains ownership, hence there was no need to + // use an auto_ptr<> in this method. + item->factory ((transfer_ownership ? + safe_protocol_factory.release () : + protocol_factory), + transfer_ownership); if (this->protocol_factories_.insert (item) == -1) { + ACE_ERROR ((LM_ERROR, + ASYS_TEXT ("TAO (%P|%t) Unable to add ") + ASYS_TEXT ("<%s> to protocol factory set.\n"), + item->protocol_name ().c_str ())); + delete item; - delete protocol_factory; - ACE_ERROR_RETURN ((LM_ERROR, - ASYS_TEXT ("TAO (%P|%t) Unable to add ") - ASYS_TEXT ("<%s> to protocol factory set.\n"), - item->protocol_name ().c_str ()), - -1); + if (transfer_ownership == 0) + delete protocol_factory; + + return -1; } if (TAO_debug_level > 0) { ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("TAO (%P|%t) Loaded default protocol <IIOP_Factory>\n"))); + ASYS_TEXT ("TAO (%P|%t) Loaded default ") + ASYS_TEXT ("protocol <IIOP_Factory>\n"))); } #if TAO_HAS_UIOP == 1 @@ -418,27 +449,51 @@ TAO_Default_Resource_Factory::init_protocol_factories (void) ACE_NEW_RETURN (protocol_factory, TAO_UIOP_Protocol_Factory, -1); + + ACE_AUTO_PTR_RESET (safe_protocol_factory, + protocol_factory, + TAO_Protocol_Factory); + + transfer_ownership = 1; + } + else + { + transfer_ownership = 0; } ACE_NEW_RETURN (item, TAO_Protocol_Item ("UIOP_Factory"), -1); - item->factory (protocol_factory); + // If the TAO_Protocol_Item retains ownership of the + // TAO_Protocol_Factory then we used an auto_ptr<> above, so + // release the TAO_Protocol_Factory from it. Otherwise, we + // obtained the TAO_Protocol_Factory from the Service + // Configurator so an auto_ptr<> wasn't used since the Service + // Configurator retains ownership, hence there was no need to + // use an auto_ptr<> in this method. + item->factory ((transfer_ownership ? + safe_protocol_factory.release () : + protocol_factory), + transfer_ownership); if (this->protocol_factories_.insert (item) == -1) { + ACE_ERROR ((LM_ERROR, + ASYS_TEXT ("TAO (%P|%t) Unable to add ") + ASYS_TEXT ("<%s> to protocol factory set.\n"), + item->protocol_name ().c_str ())); + delete item; - delete protocol_factory; - ACE_ERROR_RETURN ((LM_ERROR, - "TAO (%P|%t) Unable to add " - "<%s> to protocol factory set.\n", - item->protocol_name ().c_str ()), - -1); + if (transfer_ownership == 0) + delete protocol_factory; + + return -1; } if (TAO_debug_level > 0) { ACE_DEBUG ((LM_DEBUG, - "TAO (%P|%t) Loaded default protocol <UIOP_Factory>\n")); + ASYS_TEXT ("TAO (%P|%t) Loaded default ") + ASYS_TEXT ("protocol <UIOP_Factory>\n"))); } #endif /* TAO_HAS_UIOP == 1 */ @@ -457,29 +512,54 @@ TAO_Default_Resource_Factory::init_protocol_factories (void) ACE_NEW_RETURN (protocol_factory, TAO_SHMIOP_Protocol_Factory, -1); + + ACE_AUTO_PTR_RESET (safe_protocol_factory, + protocol_factory, + TAO_Protocol_Factory); + + transfer_ownership = 1; + } + else + { + transfer_ownership = 0; } ACE_NEW_RETURN (item, TAO_Protocol_Item ("SHMIOP_Factory"), -1); - item->factory (protocol_factory); + // If the TAO_Protocol_Item retains ownership of the + // TAO_Protocol_Factory then we used an auto_ptr<> above, so + // release the TAO_Protocol_Factory from it. Otherwise, we + // obtained the TAO_Protocol_Factory from the Service + // Configurator so an auto_ptr<> wasn't used since the Service + // Configurator retains ownership, hence there was no need to + // use an auto_ptr<> in this method. + item->factory ((transfer_ownership ? + safe_protocol_factory.release () : + protocol_factory), + transfer_ownership); if (this->protocol_factories_.insert (item) == -1) { + ACE_ERROR ((LM_ERROR, + ASYS_TEXT ("TAO (%P|%t) Unable to add ") + ASYS_TEXT ("<%s> to protocol factory set.\n"), + item->protocol_name ().c_str ())); + delete item; - delete protocol_factory; - ACE_ERROR_RETURN ((LM_ERROR, - "TAO (%P|%t) Unable to add " - "<%s> to protocol factory set.\n", - item->protocol_name ().c_str ()), - -1); + if (transfer_ownership == 0) + delete protocol_factory; + + return -1; } if (TAO_debug_level > 0) { ACE_DEBUG ((LM_DEBUG, - "TAO (%P|%t) Loaded default protocol <SHMIOP_Factory>\n")); + ASYS_TEXT ("TAO (%P|%t) Loaded default ") + ASYS_TEXT ("protocol <SHMIOP_Factory>\n"))); } #endif /* TAO_HAS_SHMIOP && TAO_HAS_SHMIOP != 0 */ + return 0; } @@ -491,7 +571,8 @@ TAO_Default_Resource_Factory::init_protocol_factories (void) if ((*factory)->factory () == 0) { ACE_ERROR_RETURN ((LM_ERROR, - ASYS_TEXT ("TAO (%P|%t) Unable to load protocol <%s>, %p\n"), + ASYS_TEXT ("TAO (%P|%t) Unable to load ") + ASYS_TEXT ("protocol <%s>, %p\n"), name.c_str (), ""), -1); } @@ -503,6 +584,7 @@ TAO_Default_Resource_Factory::init_protocol_factories (void) name.c_str ())); } } + return 0; } @@ -777,10 +859,16 @@ template class ACE_Select_Reactor_Token_T<ACE_Noop_Token>; template class ACE_Lock_Adapter<ACE_Select_Reactor_Token_T<ACE_Noop_Token> >; template class ACE_Select_Reactor_T< ACE_Select_Reactor_Token_T<ACE_Noop_Token> >; +template class auto_ptr<TAO_Protocol_Factory>; +template class ACE_Auto_Basic_Ptr<TAO_Protocol_Factory>; + #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) #pragma instantiate ACE_Select_Reactor_Token_T<ACE_Noop_Token> #pragma instantiate ACE_Lock_Adapter< ACE_Select_Reactor_Token_T<ACE_Noop_Token> > #pragma instantiate ACE_Select_Reactor_T< ACE_Select_Reactor_Token_T<ACE_Noop_Token> > +#pragma instantiate auto_ptr<TAO_Protocol_Factory> +#pragma ACE_Auto_Basic_Ptr<TAO_Protocol_Factory> + #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ diff --git a/TAO/tao/default_server.cpp b/TAO/tao/default_server.cpp index 01e5b156491..bb0a10ddde2 100644 --- a/TAO/tao/default_server.cpp +++ b/TAO/tao/default_server.cpp @@ -1,6 +1,5 @@ // $Id$ - #include "tao/default_server.h" #include "tao/ORB_Core.h" @@ -10,7 +9,6 @@ ACE_RCSID(tao, default_server, "$Id$") - TAO_Default_Server_Strategy_Factory::TAO_Default_Server_Strategy_Factory (void) : activate_server_connections_ (0), thread_flags_ (THR_BOUND | THR_DETACHED), diff --git a/TAO/tao/factories.h b/TAO/tao/factories.h index 1de6cd3982a..5e9d5a0001f 100644 --- a/TAO/tao/factories.h +++ b/TAO/tao/factories.h @@ -1,5 +1,5 @@ // This may look like C, but it's really -*- C++ -*- -// $Id$ + // ============================================================================ // // = LIBRARY @@ -12,6 +12,7 @@ // Chris Cleeland // // = VERSION +// $Id$ // ============================================================================ #ifndef TAO_FACTORIES_H diff --git a/TAO/tao/orbconf.h b/TAO/tao/orbconf.h index 91348ff80ac..15dbbfe0031 100644 --- a/TAO/tao/orbconf.h +++ b/TAO/tao/orbconf.h @@ -1,7 +1,6 @@ // This may look like C, but it's really -*- C++ -*- // @ (#) $Id$ - // ============================================================================ // // = LIBRARY @@ -527,7 +526,6 @@ enum MCAST_SERVICEID # endif /* TAO_HAS_MINIMUM_CORBA */ #endif /* !TAO_HAS_REMOTE_POLICIES */ - // TAO_HAS_LOCALITY_CONSTRAINT_POLICIES is an internal macro and // should not be set by the user. #if defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES) diff --git a/TAO/tao/params.cpp b/TAO/tao/params.cpp index d67c3e46e94..409b34b65f3 100644 --- a/TAO/tao/params.cpp +++ b/TAO/tao/params.cpp @@ -7,8 +7,8 @@ # include "tao/params.i" #endif /* __ACE_INLINE__ */ -ACE_RCSID(tao, params, "$Id$") +ACE_RCSID(tao, params, "$Id$") TAO_ORB_Parameters::TAO_ORB_Parameters (void) diff --git a/TAO/tao/params.i b/TAO/tao/params.i index 262abf8eef0..5ba9334e3ae 100644 --- a/TAO/tao/params.i +++ b/TAO/tao/params.i @@ -1,7 +1,6 @@ // -*- C++ -*- // $Id$ - ACE_INLINE TAO_EndpointSet & TAO_ORB_Parameters::preconnects (void) { diff --git a/TAO/tao/rtcorbafwd.cpp b/TAO/tao/rtcorbafwd.cpp index e262c728a1a..9c2398619f2 100644 --- a/TAO/tao/rtcorbafwd.cpp +++ b/TAO/tao/rtcorbafwd.cpp @@ -1,6 +1,5 @@ // $Id$ - #include "tao/rtcorbafwd.h" #if (TAO_HAS_RT_CORBA == 1) @@ -11,7 +10,6 @@ ACE_RCSID(tao, rtcorbafwd, "$Id$") - TAO_NAMESPACE_TYPE (const RTCORBA::Priority) TAO_NAMESPACE_BEGIN (RTCORBA) TAO_NAMESPACE_DEFINE (const RTCORBA::Priority, minPriority, 0) diff --git a/TAO/tao/rtcorbafwd.h b/TAO/tao/rtcorbafwd.h index 3bcd948a7a4..8475baddb89 100644 --- a/TAO/tao/rtcorbafwd.h +++ b/TAO/tao/rtcorbafwd.h @@ -1,7 +1,6 @@ // -*- C++ -*- // $Id$ - // ============================================================================ // // = LIBRARY diff --git a/TAO/tao/skip.cpp b/TAO/tao/skip.cpp index c62af842fd9..ca67024aa07 100644 --- a/TAO/tao/skip.cpp +++ b/TAO/tao/skip.cpp @@ -1,6 +1,5 @@ // $Id$ - // ============================================================================ // // = LIBRARY @@ -28,7 +27,6 @@ ACE_RCSID(tao, skip, "$Id$") - CORBA::TypeCode::traverse_status TAO_Marshal_Primitive::skip (CORBA::TypeCode_ptr tc, void *context, |