diff options
Diffstat (limited to 'TAO/tao')
81 files changed, 6821 insertions, 18198 deletions
diff --git a/TAO/tao/Any.cpp b/TAO/tao/Any.cpp index 9c936af9a8e..91d8d2aefb7 100644 --- a/TAO/tao/Any.cpp +++ b/TAO/tao/Any.cpp @@ -65,10 +65,11 @@ CORBA_Any::value (void) const CORBA_Any::CORBA_Any (void) : type_ (CORBA::TypeCode::_duplicate (CORBA::_tc_null)), - value_ (0), byte_order_ (TAO_ENCAP_BYTE_ORDER), cdr_ (0), - any_owns_data_ (0) + any_owns_data_ (0), + value_ (0), + destructor_ (0) { } @@ -76,42 +77,64 @@ CORBA_Any::CORBA_Any (void) // and either holds or "consumes" an arbitrary data value satisfying // the normal binary interface rules. -CORBA_Any::CORBA_Any (CORBA::TypeCode_ptr tc, - void *value, - CORBA::Boolean any_owns_data) - : type_ (CORBA::TypeCode::_duplicate (tc)), - value_ (value), +#if 0 +CORBA_Any::CORBA_Any (CORBA::TypeCode_ptr, + void *, + CORBA::Environment &ACE_TRY_ENV) + : type_ (CORBA::TypeCode::_duplicate (CORBA::_tc_null)), byte_order_ (TAO_ENCAP_BYTE_ORDER), cdr_ (0), - any_owns_data_ (any_owns_data) + any_owns_data_ (0), + value_ (0), + destructor_ (0) { - ACE_DECLARE_NEW_CORBA_ENV; + ACE_THROW (CORBA::NO_IMPLEMENT ()); +} - ACE_TRY - { - if (this->value_ != 0) - { - TAO_OutputCDR stream; +CORBA_Any::CORBA_Any (CORBA::TypeCode_ptr, + void *, + CORBA::Boolean, + CORBA::Environment &ACE_TRY_ENV) + : type_ (CORBA::TypeCode::_duplicate (CORBA::_tc_null)), + byte_order_ (TAO_ENCAP_BYTE_ORDER), + cdr_ (0), + any_owns_data_ (0), + value_ (0), + destructor_ (0) +{ + ACE_THROW (CORBA::NO_IMPLEMENT ()); +} - // Encode the value. - stream.encode (this->type_, - this->value_, - 0, - ACE_TRY_ENV); - ACE_TRY_CHECK; +// All-at-once replacement of the contents of an "Any." - // Retrieve the start of the message block chain and save it. - this->byte_order_ = TAO_ENCAP_BYTE_ORDER; - ACE_NEW (this->cdr_, ACE_Message_Block); - ACE_CDR::consolidate (this->cdr_, stream.begin ()); - } - } - ACE_CATCHANY - { - // do nothing - } - ACE_ENDTRY; - ACE_CHECK; +void +CORBA_Any::replace (CORBA::TypeCode_ptr, + const void *, + CORBA::Boolean, + CORBA::Environment &ACE_TRY_ENV) +{ + ACE_THROW (CORBA::NO_IMPLEMENT ()); +} + +void +CORBA_Any::replace (CORBA::TypeCode_ptr, + const void *, + CORBA::Environment &ACE_TRY_ENV) +{ + ACE_THROW (CORBA::NO_IMPLEMENT ()); +} +#endif /* 0 */ + +CORBA_Any::CORBA_Any (CORBA::TypeCode_ptr tc, + CORBA::Environment &) + : type_ (CORBA::TypeCode::_duplicate (tc)), + byte_order_ (TAO_ENCAP_BYTE_ORDER), + cdr_ (0), + any_owns_data_ (0), + value_ (0), + destructor_ (0) +{ + // ACE_THROW (CORBA::NO_IMPLEMENT ()); } // Constructor using a message block. @@ -120,9 +143,10 @@ CORBA_Any::CORBA_Any (CORBA::TypeCode_ptr type, int byte_order, const ACE_Message_Block* mb) : type_ (CORBA::TypeCode::_duplicate (type)), - value_ (0), byte_order_ (byte_order), - any_owns_data_ (0) + any_owns_data_ (0), + value_ (0), + destructor_ (0) { ACE_NEW (this->cdr_, ACE_Message_Block); ACE_CDR::consolidate (this->cdr_, mb); @@ -130,9 +154,10 @@ CORBA_Any::CORBA_Any (CORBA::TypeCode_ptr type, // Copy constructor for "Any". CORBA_Any::CORBA_Any (const CORBA_Any &src) - : value_ (0), - cdr_ (0), - any_owns_data_ (0) + : cdr_ (0), + any_owns_data_ (0), + value_ (0), + destructor_ (0) { if (src.type_ != 0) this->type_ = @@ -155,56 +180,39 @@ CORBA_Any::CORBA_Any (const CORBA_Any &src) CORBA_Any & CORBA_Any::operator= (const CORBA_Any &src) { - ACE_DECLARE_NEW_CORBA_ENV; - - ACE_TRY - { - // check if it is a self assignment - if (this == &src) - { - return *this; - } + // check if it is a self assignment + if (this == &src) + return *this; - // Decrement the refcount on the Message_Block we hold, it does not - // matter if we own the data or not, because we always own the - // message block (i.e. it is always cloned or duplicated. - ACE_Message_Block::release ((ACE_Message_Block *) this->cdr_); - this->cdr_ = 0; - - // If we own any previous data, deallocate it. - this->free_value (ACE_TRY_ENV); - ACE_TRY_CHECK; - - if (this->type_ != 0) - { - CORBA::release (this->type_); - } + // Decrement the refcount on the Message_Block we hold, it does not + // matter if we own the data or not, because we always own the + // message block (i.e. it is always cloned or duplicated. + ACE_Message_Block::release ((ACE_Message_Block *) this->cdr_); + this->cdr_ = 0; - // Now copy the contents of the source to ourselves. - if (src.type_ != 0) - { - this->type_ = - CORBA::TypeCode::_duplicate (src.type_); - } - else - { - this->type_ = - CORBA::TypeCode::_duplicate (CORBA::_tc_null); - } + // If we own any previous data, deallocate it. + this->free_value (); - this->any_owns_data_ = 0; + if (this->type_ != 0) + { + CORBA::release (this->type_); + } - this->byte_order_ = src.byte_order_; - ACE_NEW_RETURN (this->cdr_, ACE_Message_Block, *this); - ACE_CDR::consolidate (this->cdr_, src.cdr_); - // Simply duplicate the cdr string here. We can save the decode - // operation if there's no need to extract the object. + // Now copy the contents of the source to ourselves. + if (src.type_ != 0) + { + this->type_ = + CORBA::TypeCode::_duplicate (src.type_); } - ACE_CATCHANY + else { - return *this; + this->type_ = + CORBA::TypeCode::_duplicate (CORBA::_tc_null); } - ACE_ENDTRY; + + this->byte_order_ = src.byte_order_; + ACE_NEW_RETURN (this->cdr_, ACE_Message_Block, *this); + ACE_CDR::consolidate (this->cdr_, src.cdr_); return *this; } @@ -213,84 +221,26 @@ CORBA_Any::operator= (const CORBA_Any &src) CORBA_Any::~CORBA_Any (void) { - ACE_DECLARE_NEW_CORBA_ENV; - - ACE_TRY - { - // decrement the refcount on the Message_Block we hold, it does not - // matter if we own the data or not, because we always own the - // message block (i.e. it is always cloned or duplicated. - - ACE_Message_Block::release (this->cdr_); - this->cdr_ = 0; - - this->free_value (ACE_TRY_ENV); - ACE_TRY_CHECK; - - if (this->type_) - CORBA::release (this->type_); - } - ACE_CATCHANY - { - // do nothing - } - ACE_ENDTRY; - ACE_CHECK; -} - -// All-at-once replacement of the contents of an "Any." - -void -CORBA_Any::replace (CORBA::TypeCode_ptr tc, - const void *value, - CORBA::Boolean any_owns_data, - CORBA::Environment &ACE_TRY_ENV) -{ - // Decrement the refcount on the Message_Block we hold, it does not + // decrement the refcount on the Message_Block we hold, it does not // matter if we own the data or not, because we always own the - // message block (i.e. it is always cloned or duplicated). - ACE_Message_Block::release (this->cdr_); - this->cdr_ = 0; - - this->free_value (ACE_TRY_ENV); - ACE_CHECK; - - // Duplicate tc and then release this->type_, just in case tc and - // type_ are the same thing. - CORBA::TypeCode_ptr tmp = - CORBA::TypeCode::_duplicate (tc); - CORBA::release (this->type_); - this->type_ = tmp; + // message block (i.e. it is always cloned or duplicated. - this->value_ = ACE_const_cast (void *, value); - this->any_owns_data_ = any_owns_data; + ACE_Message_Block::release (this->cdr_); this->cdr_ = 0; - if (value) - { - // @@ NW: I think an Any should alway owns the CDR stream, - // so I removed the check here. - // if the Any owns the data, we encode the "value" into a CDR stream - // and store it. We also destroy the "value" since we own it. - TAO_OutputCDR stream; - stream.encode (tc, - value, - 0, - ACE_TRY_ENV); - ACE_CHECK; + this->free_value (); - // Retrieve the start of the message block chain and duplicate it. - this->byte_order_ = TAO_ENCAP_BYTE_ORDER; - ACE_NEW (this->cdr_, ACE_Message_Block); - ACE_CDR::consolidate (this->cdr_, stream.begin ()); - } + if (this->type_) + CORBA::release (this->type_); } +// TAO proprietary methods, used in the implementation of the >>= and +// <<= operators. + void CORBA_Any::_tao_replace (CORBA::TypeCode_ptr tc, int byte_order, - const ACE_Message_Block *mb, - CORBA::Environment &ACE_TRY_ENV) + const ACE_Message_Block *mb) { // Decrement the refcount on the Message_Block we hold, it does not // matter if we own the data or not, because we always own the @@ -298,8 +248,7 @@ CORBA_Any::_tao_replace (CORBA::TypeCode_ptr tc, ACE_Message_Block::release (this->cdr_); this->cdr_ = 0; - this->free_value (ACE_TRY_ENV); - ACE_CHECK; + this->free_value (); // Duplicate tc and then release this->type_, just in case tc and // type_ are the same thing. @@ -307,8 +256,6 @@ CORBA_Any::_tao_replace (CORBA::TypeCode_ptr tc, CORBA::release (this->type_); this->type_ = tmp; - this->any_owns_data_ = 0; - this->byte_order_ = byte_order; ACE_NEW (this->cdr_, ACE_Message_Block); ACE_CDR::consolidate (this->cdr_, mb); @@ -322,7 +269,7 @@ CORBA_Any::_tao_replace (CORBA::TypeCode_ptr tc, const ACE_Message_Block *mb, CORBA::Boolean any_owns_data, void* value, - CORBA::Environment &ACE_TRY_ENV) + CORBA::Any::_tao_destructor destructor) { // Decrement the refcount on the Message_Block we hold, it does not // matter if we own the data or not, because we always own the @@ -330,9 +277,9 @@ CORBA_Any::_tao_replace (CORBA::TypeCode_ptr tc, ACE_Message_Block::release (this->cdr_); this->cdr_ = 0; - this->free_value (ACE_TRY_ENV); - ACE_CHECK; + this->free_value (); + this->any_owns_data_ = any_owns_data; this->value_ = value; // Duplicate tc and then release this->type_, just in case tc and @@ -341,24 +288,24 @@ CORBA_Any::_tao_replace (CORBA::TypeCode_ptr tc, CORBA::release (this->type_); this->type_ = tmp; - this->any_owns_data_ = any_owns_data; - this->byte_order_ = byte_order; ACE_NEW (this->cdr_, ACE_Message_Block); ACE_CDR::consolidate (this->cdr_, mb); // We can save the decode operation if there's no need to extract // the object. + + this->destructor_ = destructor; } void CORBA_Any::_tao_replace (CORBA::TypeCode_ptr tc, CORBA::Boolean any_owns_data, void* value, - CORBA::Environment &ACE_TRY_ENV) + CORBA::Any::_tao_destructor destructor) { - this->free_value (ACE_TRY_ENV); - ACE_CHECK; + this->free_value (); + this->any_owns_data_ = any_owns_data; this->value_ = value; // Duplicate tc and then release this->type_, just in case tc and @@ -367,22 +314,23 @@ CORBA_Any::_tao_replace (CORBA::TypeCode_ptr tc, CORBA::release (this->type_); this->type_ = tmp; - this->any_owns_data_ = any_owns_data; + this->destructor_ = destructor; } // Free internal data. void -CORBA_Any::free_value (CORBA::Environment &ACE_TRY_ENV) +CORBA_Any::free_value (void) { - if (this->any_owns_data_ && this->value_ != 0) + if (this->any_owns_data_ + && this->value_ != 0 + && this->destructor_ != 0) { - // This is not exception safe. - DEEP_FREE (this->type_, this->value_, 0, ACE_TRY_ENV); - ACE_CHECK; - ::operator delete (this->value_); + (*this->destructor_) (this->value_); } + this->any_owns_data_ = 0; this->value_ = 0; + this->destructor_ = 0; } void @@ -390,15 +338,9 @@ CORBA_Any::_tao_encode (TAO_OutputCDR &cdr, TAO_ORB_Core *orb_core, CORBA::Environment &ACE_TRY_ENV) { - // If the Any owns the data, then we have allocated space. - if (this->value_ != 0) - { - (void) cdr.encode (this->type_, - this->value_, - 0, - ACE_TRY_ENV); - return; - } + // Always append the CDR stream, even when the value_. + if (this->cdr_ == 0) + ACE_THROW (CORBA::NO_IMPLEMENT ()); TAO_InputCDR in (this->cdr_, this->byte_order_, @@ -412,15 +354,7 @@ void CORBA_Any::_tao_decode (TAO_InputCDR &cdr, CORBA::Environment &ACE_TRY_ENV) { - if (this->value_ != 0) - { - // @@ Should we free that value first? - cdr.decode (this->type_, - this->value_, - 0, - ACE_TRY_ENV); - return; - } + // Just read into the CDR stream... // @@ (JP) The following code depends on the fact that // TAO_InputCDR does not contain chained message blocks, @@ -454,9 +388,7 @@ CORBA_Any::_tao_decode (TAO_InputCDR &cdr, // Stick it into the Any. It gets duplicated there. this->_tao_replace (this->type_, cdr.byte_order (), - &mb, - ACE_TRY_ENV); - ACE_CHECK; + &mb); } // insertion operators @@ -464,264 +396,123 @@ CORBA_Any::_tao_decode (TAO_InputCDR &cdr, void CORBA_Any::operator<<= (CORBA::Short s) { - ACE_DECLARE_NEW_CORBA_ENV; - ACE_TRY - { - CORBA::Short *ns; - ACE_NEW (ns, - CORBA::Short (s)); - this->replace (CORBA::_tc_short, - ns, - 1, - ACE_TRY_ENV); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("Exception in CORBA::Short insertion\n"))); - } - ACE_ENDTRY; - ACE_CHECK; + TAO_OutputCDR stream; + stream << s; + this->_tao_replace (CORBA::_tc_short, + TAO_ENCAP_BYTE_ORDER, + stream.begin ()); } void CORBA_Any::operator<<= (CORBA::UShort s) { - ACE_DECLARE_NEW_CORBA_ENV; - ACE_TRY - { - CORBA::UShort *ns; - ACE_NEW (ns, - CORBA::UShort (s)); - this->replace (CORBA::_tc_ushort, - ns, - 1, - ACE_TRY_ENV); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("Exception in CORBA::UShort insertion\n"))); - } - ACE_ENDTRY; - ACE_CHECK; + TAO_OutputCDR stream; + stream << s; + this->_tao_replace (CORBA::_tc_ushort, + TAO_ENCAP_BYTE_ORDER, + stream.begin ()); } void CORBA_Any::operator<<= (CORBA::Long l) { - ACE_DECLARE_NEW_CORBA_ENV; - ACE_TRY - { - CORBA::Long *nl; - ACE_NEW (nl, - CORBA::Long (l)); - this->replace (CORBA::_tc_long, - nl, - 1, - ACE_TRY_ENV); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("Exception in CORBA::Long insertion\n"))); - } - ACE_ENDTRY; - ACE_CHECK; + TAO_OutputCDR stream; + stream << l; + this->_tao_replace (CORBA::_tc_long, + TAO_ENCAP_BYTE_ORDER, + stream.begin ()); } void CORBA_Any::operator<<= (CORBA::ULong l) { - ACE_DECLARE_NEW_CORBA_ENV; - ACE_TRY - { - CORBA::ULong *nl; - ACE_NEW (nl, - CORBA::ULong (l)); - this->replace (CORBA::_tc_ulong, - nl, - 1, - ACE_TRY_ENV); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("Exception in CORBA::ULong insertion\n"))); - } - ACE_ENDTRY; - ACE_CHECK; + TAO_OutputCDR stream; + stream << l; + this->_tao_replace (CORBA::_tc_ulong, + TAO_ENCAP_BYTE_ORDER, + stream.begin ()); } void CORBA_Any::operator<<= (CORBA::LongLong l) { - ACE_DECLARE_NEW_CORBA_ENV; - ACE_TRY - { - CORBA::LongLong *nl; - ACE_NEW (nl, - CORBA::LongLong (l)); - this->replace (CORBA::_tc_longlong, - nl, - 1, - ACE_TRY_ENV); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("Exception in CORBA::LongLong insertion\n"))); - } - ACE_ENDTRY; - ACE_CHECK; + TAO_OutputCDR stream; + stream << l; + this->_tao_replace (CORBA::_tc_longlong, + TAO_ENCAP_BYTE_ORDER, + stream.begin ()); } void CORBA_Any::operator<<= (CORBA::ULongLong l) { - ACE_DECLARE_NEW_CORBA_ENV; - ACE_TRY - { - CORBA::ULongLong *nl; - ACE_NEW (nl, - CORBA::ULongLong (l)); - this->replace (CORBA::_tc_ulonglong, - nl, - 1, - ACE_TRY_ENV); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("Exception in CORBA::ULongLong insertion\n"))); - } - ACE_ENDTRY; - ACE_CHECK; + TAO_OutputCDR stream; + stream << l; + this->_tao_replace (CORBA::_tc_ulonglong, + TAO_ENCAP_BYTE_ORDER, + stream.begin ()); } void CORBA_Any::operator<<= (CORBA::Float f) { - ACE_DECLARE_NEW_CORBA_ENV; - ACE_TRY - { - CORBA::Float *nf; - ACE_NEW (nf, - CORBA::Float (f)); - this->replace (CORBA::_tc_float, - nf, - 1, - ACE_TRY_ENV); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("Exception in CORBA::Float insertion\n"))); - } - ACE_ENDTRY; - ACE_CHECK; + TAO_OutputCDR stream; + stream << f; + this->_tao_replace (CORBA::_tc_float, + TAO_ENCAP_BYTE_ORDER, + stream.begin ()); } void CORBA_Any::operator<<= (CORBA::Double d) { - ACE_DECLARE_NEW_CORBA_ENV; - ACE_TRY - { - CORBA::Double *nd; - ACE_NEW (nd, - CORBA::Double (d)); - this->replace (CORBA::_tc_double, - nd, - 1, - ACE_TRY_ENV); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("Exception in CORBA::Double insertion\n"))); - } - ACE_ENDTRY; - ACE_CHECK; + TAO_OutputCDR stream; + stream << d; + this->_tao_replace (CORBA::_tc_double, + TAO_ENCAP_BYTE_ORDER, + stream.begin ()); } void -CORBA_Any::operator<<= (CORBA::LongDouble ld) +CORBA_Any::operator<<= (CORBA::LongDouble d) { - 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; + TAO_OutputCDR stream; + stream << d; + this->_tao_replace (CORBA::_tc_longdouble, + TAO_ENCAP_BYTE_ORDER, + stream.begin ()); } // insertion of Any - copying void CORBA_Any::operator<<= (const CORBA_Any& a) { - ACE_DECLARE_NEW_CORBA_ENV; - ACE_TRY - { - CORBA_Any_ptr na; - ACE_NEW (na, - CORBA::Any (a)); - this->replace (CORBA::_tc_any, - na, - 1, - ACE_TRY_ENV); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("Exception in CORBA::Any copying insertion\n"))); - } - ACE_ENDTRY; - ACE_CHECK; + TAO_OutputCDR stream; + stream << a; + this->_tao_replace (CORBA::_tc_any, + TAO_ENCAP_BYTE_ORDER, + stream.begin ()); } // insertion of Any - non-copying void -CORBA::Any::operator<<= (CORBA::Any_ptr anyptr) +CORBA::Any::_tao_any_destructor (void *x) { - ACE_DECLARE_NEW_CORBA_ENV; - ACE_TRY - { - this->replace (CORBA::_tc_any, - anyptr, - 1, - ACE_TRY_ENV); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("Exception in CORBA::Any non-copying insertion\n"))); - } - ACE_ENDTRY; - ACE_CHECK; + CORBA::Any *tmp = ACE_static_cast (CORBA::Any*,x); + delete tmp; +} + +void +CORBA::Any::operator<<= (CORBA::Any* a) +{ + TAO_OutputCDR stream; + stream << *a; + this->_tao_replace (CORBA::_tc_any, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + a, + CORBA::Any::_tao_any_destructor); } // implementing the special types @@ -729,125 +520,51 @@ CORBA::Any::operator<<= (CORBA::Any_ptr anyptr) void CORBA_Any::operator<<= (from_boolean b) { - ACE_DECLARE_NEW_CORBA_ENV; - ACE_TRY - { - CORBA::Boolean *nb; - ACE_NEW (nb, - CORBA::Boolean (b.val_)); - this->replace (CORBA::_tc_boolean, - nb, - 1, - ACE_TRY_ENV); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("Exception in CORBA::Boolean insertion\n"))); - } - ACE_ENDTRY; - ACE_CHECK; + TAO_OutputCDR stream; + stream << b; + this->_tao_replace (CORBA::_tc_boolean, + TAO_ENCAP_BYTE_ORDER, + stream.begin ()); } void CORBA_Any::operator<<= (from_octet o) { - ACE_DECLARE_NEW_CORBA_ENV; - ACE_TRY - { - CORBA::Octet *no; - ACE_NEW (no, - CORBA::Octet (o.val_)); - this->replace (CORBA::_tc_octet, - no, - 1, - ACE_TRY_ENV); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("Exception in CORBA::Octet insertion\n"))); - } - ACE_ENDTRY; - ACE_CHECK; + TAO_OutputCDR stream; + stream << o; + this->_tao_replace (CORBA::_tc_octet, + TAO_ENCAP_BYTE_ORDER, + stream.begin ()); } void CORBA_Any::operator<<= (from_char c) { - ACE_DECLARE_NEW_CORBA_ENV; - ACE_TRY - { - CORBA::Char *nc; - ACE_NEW (nc, - CORBA::Char (c.val_)); - this->replace (CORBA::_tc_char, - nc, - 1, - ACE_TRY_ENV); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("Exception in CORBA::Char insertion\n"))); - } - ACE_ENDTRY; - ACE_CHECK; + TAO_OutputCDR stream; + stream << c; + this->_tao_replace (CORBA::_tc_char, + TAO_ENCAP_BYTE_ORDER, + stream.begin ()); } void CORBA_Any::operator<<= (from_wchar wc) { - ACE_DECLARE_NEW_CORBA_ENV; - ACE_TRY - { - CORBA::WChar *nwc; - ACE_NEW (nwc, - CORBA::WChar (wc.val_)); - this->replace (CORBA::_tc_wchar, - nwc, - 1, - ACE_TRY_ENV); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("Exception in CORBA::WChar insertion\n"))); - } - ACE_ENDTRY; - ACE_CHECK; + TAO_OutputCDR stream; + stream << wc; + this->_tao_replace (CORBA::_tc_wchar, + TAO_ENCAP_BYTE_ORDER, + stream.begin ()); } void CORBA_Any::operator<<= (CORBA::TypeCode_ptr tc) { - ACE_DECLARE_NEW_CORBA_ENV; - - ACE_TRY - { - CORBA::TypeCode_ptr *_tao_tc; - - ACE_NEW (_tao_tc, - CORBA::TypeCode_ptr); - - *_tao_tc = CORBA::TypeCode::_duplicate (tc); - this->replace (CORBA::_tc_TypeCode, - _tao_tc, - 1, - ACE_TRY_ENV); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("Exception in CORBA::TypeCode_ptr insertion\n"))); - } - ACE_ENDTRY; - ACE_CHECK; + TAO_OutputCDR stream; + stream << tc; + this->_tao_replace (CORBA::_tc_TypeCode, + TAO_ENCAP_BYTE_ORDER, + stream.begin ()); } void @@ -863,9 +580,7 @@ CORBA_Any::operator<<= (const CORBA_Exception &exception) this->_tao_replace (exception._type (), TAO_ENCAP_BYTE_ORDER, - stream.begin (), - ACE_TRY_ENV); - ACE_TRY_CHECK; + stream.begin ()); } ACE_CATCHANY { @@ -893,29 +608,15 @@ CORBA::Any::operator<<= (const CORBA::Object_ptr obj) void CORBA::Any::operator<<= (CORBA::Object_ptr *objptr) { - ACE_DECLARE_NEW_CORBA_ENV; + if (objptr == 0) + return; // @@ Should we raise an exception? - ACE_TRY - { - CORBA::Object_ptr *_tao_object_ptr; - - ACE_NEW (_tao_object_ptr, - CORBA::Object_ptr); - - *_tao_object_ptr = *objptr; - this->replace (CORBA::_tc_Object, - _tao_object_ptr, - 1, - ACE_TRY_ENV); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("Exception in CORBA::Object_ptr insertion\n"))); - } - ACE_ENDTRY; - ACE_CHECK; + TAO_OutputCDR stream; + stream << *objptr; + delete objptr; + this->_tao_replace (CORBA::_tc_Object, + TAO_ENCAP_BYTE_ORDER, + stream.begin ()); } // Insertion of from_string. @@ -923,125 +624,105 @@ CORBA::Any::operator<<= (CORBA::Object_ptr *objptr) void CORBA_Any::operator<<= (from_string s) { - ACE_DECLARE_NEW_CORBA_ENV; - - ACE_TRY - { - // If the inserted string is bounded, we create a typecode. - static CORBA::Long _oc_string [] = - { - // CDR typecode octets - TAO_ENCAP_BYTE_ORDER, // native endian + padding; "tricky" - 0 // ... unbounded string to start with - }; + TAO_OutputCDR stream; + stream << s; - CORBA::TypeCode_ptr tc = 0; + // If the inserted string is bounded, we create a typecode. + static CORBA::Long _oc_string [] = + { + // CDR typecode octets + TAO_ENCAP_BYTE_ORDER, // native endian + padding; "tricky" + 0 // ... unbounded string to start with + }; - if (s.bound_ > 0) - { - // Bounded string. - _oc_string [1] = s.bound_; - ACE_NEW (tc, - CORBA::TypeCode (CORBA::tk_string, - sizeof _oc_string, - (char *) &_oc_string, - 1, - sizeof (CORBA::String_var))); - } - else - { - tc = CORBA::_tc_string; // unbounded. - } + CORBA::TypeCode_ptr tc = 0; - char **tmp; - // Non-copying. - if (s.nocopy_) - { - ACE_NEW (tmp, - char* (s.val_)); - } - // Copying. - else - { - ACE_NEW (tmp, - char* (CORBA::string_dup (s.val_))); - } + if (s.bound_ > 0) + { + // Bounded string. + _oc_string [1] = s.bound_; + // @@ It seems like this could be leaked! + ACE_NEW (tc, + CORBA::TypeCode (CORBA::tk_string, + sizeof _oc_string, + (char *) &_oc_string, + 1, + sizeof (CORBA::String_var))); + } + else + { + tc = CORBA::_tc_string; // unbounded. + } - this->replace (tc, - tmp, - 1, - ACE_TRY_ENV); - ACE_TRY_CHECK; + char *tmp; + // Non-copying. + if (s.nocopy_) + { + tmp = s.val_; } - ACE_CATCHANY + else { - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("Exception in bounded string insertion\n"))); + tmp = CORBA::string_dup (s.val_); } - ACE_ENDTRY; - ACE_CHECK; + + this->_tao_replace (tc, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + tmp, + CORBA::Any::_tao_any_string_destructor); } void CORBA_Any::operator<<= (from_wstring ws) { - ACE_DECLARE_NEW_CORBA_ENV; - - ACE_TRY - { - // If the inserted string is bounded, we create a typecode. - static CORBA::Long _oc_wstring [] = - { - // CDR typecode octets - TAO_ENCAP_BYTE_ORDER, // native endian + padding; "tricky" - 0 // ... unbounded string to start with - }; + TAO_OutputCDR stream; + stream << ws; - CORBA::TypeCode_ptr tc = 0; + // If the inserted string is bounded, we create a typecode. + static CORBA::Long _oc_wstring [] = + { + // CDR typecode octets + TAO_ENCAP_BYTE_ORDER, // native endian + padding; "tricky" + 0 // ... unbounded string to start with + }; - if (ws.bound_ > 0) - { - // Bounded string. - _oc_wstring [1] = ws.bound_; - ACE_NEW (tc, - CORBA::TypeCode (CORBA::tk_wstring, - sizeof _oc_wstring, - (char *) &_oc_wstring, - 1, - sizeof (CORBA::WString_var))); - } - else - { - tc = CORBA::_tc_wstring; // unbounded. - } + CORBA::TypeCode_ptr tc = 0; - CORBA::WChar **tmp; - // Non-copying. - if (ws.nocopy_) - { - ACE_NEW (tmp, - CORBA::WChar* (ws.val_)); - } - // Copying. - else - { - ACE_NEW (tmp, - CORBA::WChar* (CORBA::wstring_dup (ws.val_))); - } + if (ws.bound_ > 0) + { + // Bounded string. + _oc_wstring [1] = ws.bound_; + // @@ TODO It seems like this is leaked! + ACE_NEW (tc, + CORBA::TypeCode (CORBA::tk_wstring, + sizeof _oc_wstring, + (char *) &_oc_wstring, + 1, + sizeof (CORBA::WString_var))); + } + else + { + tc = CORBA::_tc_wstring; // unbounded. + } - this->replace (tc, - tmp, - 1, - ACE_TRY_ENV); - ACE_TRY_CHECK; + CORBA::WChar *tmp; + // Non-copying. + if (ws.nocopy_) + { + tmp = ws.val_; } - ACE_CATCHANY + else { - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("Exception in bounded wstring insertion\n"))); + tmp = CORBA::wstring_dup (ws.val_); } - ACE_ENDTRY; - ACE_CHECK; + + this->_tao_replace (tc, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + tmp, + CORBA::Any::_tao_any_wstring_destructor); } // Extraction: these are safe and hence we have to check that the @@ -1060,24 +741,12 @@ CORBA_Any::operator>>= (CORBA::Short &s) const ACE_TRY_ENV); ACE_TRY_CHECK; - if (result) - { - if (this->any_owns_data_ && this->value_) - { - s = *(CORBA::Short *) this->value_; - return 1; - } - else - { - TAO_InputCDR stream (this->cdr_, - this->byte_order_); - return stream.read_short (s); - } - } - else - { - return 0; - } + if (!result) + return 0; + + TAO_InputCDR stream (this->cdr_, + this->byte_order_); + return stream.read_short (s); } ACE_CATCHANY { @@ -1101,24 +770,12 @@ CORBA_Any::operator>>= (CORBA::UShort &s) const ACE_TRY_ENV); ACE_TRY_CHECK; - if (result) - { - if (this->any_owns_data_ && this->value_) - { - s = *(CORBA::UShort *) this->value_; - return 1; - } - else - { - TAO_InputCDR stream (this->cdr_, - this->byte_order_); - return stream.read_ushort (s); - } - } - else - { - return 0; - } + if (!result) + return 0; + + TAO_InputCDR stream (this->cdr_, + this->byte_order_); + return stream.read_ushort (s); } ACE_CATCHANY { @@ -1142,24 +799,12 @@ CORBA_Any::operator>>= (CORBA::Long &l) const ACE_TRY_ENV); ACE_TRY_CHECK; - if (result) - { - if (this->any_owns_data_ && this->value_) - { - l = *(CORBA::Long *) this->value_; - return 1; - } - else - { - TAO_InputCDR stream (this->cdr_, - this->byte_order_); - return stream.read_long (l); - } - } - else - { - return 0; - } + if (!result) + return 0; + + TAO_InputCDR stream (this->cdr_, + this->byte_order_); + return stream.read_long (l); } ACE_CATCHANY { @@ -1183,24 +828,12 @@ CORBA_Any::operator>>= (CORBA::ULong &l) const ACE_TRY_ENV); ACE_TRY_CHECK; - if (result) - { - if (this->any_owns_data_ && this->value_) - { - l = *(CORBA::ULong *) this->value_; - return 1; - } - else - { - TAO_InputCDR stream (this->cdr_, - this->byte_order_); - return stream.read_ulong (l); - } - } - else - { - return 0; - } + if (!result) + return 0; + + TAO_InputCDR stream (this->cdr_, + this->byte_order_); + return stream.read_ulong (l); } ACE_CATCHANY { @@ -1224,24 +857,12 @@ CORBA_Any::operator>>= (CORBA::LongLong &l) const ACE_TRY_ENV); ACE_TRY_CHECK; - if (result) - { - if (this->any_owns_data_ && this->value_) - { - l = *(CORBA::LongLong *) this->value_; - return 1; - } - else - { - TAO_InputCDR stream (this->cdr_, - this->byte_order_); - return stream.read_longlong (l); - } - } - else - { - return 0; - } + if (!result) + return 0; + + TAO_InputCDR stream (this->cdr_, + this->byte_order_); + return stream.read_longlong (l); } ACE_CATCHANY { @@ -1306,24 +927,12 @@ CORBA_Any::operator>>= (CORBA::Float &f) const ACE_TRY_ENV); ACE_TRY_CHECK; - if (result) - { - if (this->any_owns_data_ && this->value_) - { - f = *(CORBA::Float *) this->value_; - return 1; - } - else - { - TAO_InputCDR stream (this->cdr_, - this->byte_order_); - return stream.read_float (f); - } - } - else - { - return 0; - } + if (!result) + return 0; + + TAO_InputCDR stream (this->cdr_, + this->byte_order_); + return stream.read_float (f); } ACE_CATCHANY { @@ -1347,24 +956,12 @@ CORBA_Any::operator>>= (CORBA::Double &d) const ACE_TRY_ENV); ACE_TRY_CHECK; - if (result) - { - if (this->any_owns_data_ && this->value_) - { - d = *(CORBA::Double *) this->value_; - return 1; - } - else - { - TAO_InputCDR stream (this->cdr_, - this->byte_order_); - return stream.read_double (d); - } - } - else - { - return 0; - } + if (!result) + return 0; + + TAO_InputCDR stream (this->cdr_, + this->byte_order_); + return stream.read_double (d); } ACE_CATCHANY { @@ -1388,24 +985,12 @@ CORBA_Any::operator>>= (CORBA::LongDouble &ld) const 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; - } + if (!result) + return 0; + + TAO_InputCDR stream (this->cdr_, + this->byte_order_); + return stream.read_longdouble (ld); } ACE_CATCHANY { @@ -1429,34 +1014,16 @@ CORBA_Any::operator>>= (CORBA::Any &a) const ACE_TRY_ENV); ACE_TRY_CHECK; - if (result) - { - if (this->any_owns_data_ && this->value_) - { - a = *(CORBA::Any *) this->value_; - return 1; - } - else - { - TAO_InputCDR stream (this->cdr_, - this->byte_order_); - // decode the CDR - CORBA::TypeCode::traverse_status retval = - stream.decode (CORBA::_tc_any, - &a, - 0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return (CORBA::Boolean) ((retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - ? 1 - : 0); - } - } - else - { - return 0; - } + if (!result) + return 0; + + if (!result) + return 0; + + TAO_InputCDR stream (this->cdr_, + this->byte_order_); + if (stream >> a) + return 1; } ACE_CATCHANY { @@ -1475,55 +1042,47 @@ CORBA_Any::operator>>= (const CORBA::Any *&a) const ACE_TRY { - CORBA::Boolean result = + a = 0; + CORBA::Boolean equivalent = this->type_->equivalent (CORBA::_tc_any, ACE_TRY_ENV); ACE_TRY_CHECK; - if (result) + if (!equivalent) + return 0; + + if (this->any_owns_data_ && this->value_) { - if (this->any_owns_data_ && this->value_) - { - a = (CORBA::Any *) this->value_; - return 1; - } - else - { - ACE_NEW_RETURN (a, - CORBA::Any, - 0); - TAO_InputCDR stream (this->cdr_, - this->byte_order_); - // decode the CDR - CORBA::TypeCode::traverse_status retval = - stream.decode (CORBA::_tc_any, - a, - 0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - if (retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - return 1; - } - else - { - delete ACE_const_cast (CORBA::Any *&, a); - a = 0; - return 0; - } - } + a = (CORBA::Any *) this->value_; + return 1; } else { - a = 0; - return 0; + CORBA::Any *x; + ACE_NEW_RETURN (x, CORBA::Any, 0); + CORBA::Any_var tmp = x; + TAO_InputCDR stream (this->cdr_, + this->byte_order_); + if (!(stream >> tmp.inout ())) + return 0; + + ACE_const_cast(CORBA::Any*, + this)->_tao_replace (CORBA::_tc_any, + 1, + ACE_static_cast(CORBA::Any*,tmp), + CORBA::Any::_tao_any_destructor); + + ACE_const_cast (CORBA::Any *&, a) = tmp._retn (); + return 1; } } ACE_CATCHANY { - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("Exception in CORBA::Any extraction\n"))); + if (TAO_debug_level > 0) + { + ACE_DEBUG ((LM_DEBUG, + ASYS_TEXT ("Exception in CORBA::Any extraction\n"))); + } } ACE_ENDTRY; @@ -1532,63 +1091,46 @@ CORBA_Any::operator>>= (const CORBA::Any *&a) const } CORBA::Boolean -CORBA_Any::operator>>= (char *&s) const +CORBA_Any::operator>>= (const char *&s) const { ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { + s = 0; + CORBA::Boolean result = this->type_->equivalent (CORBA::_tc_string, ACE_TRY_ENV); ACE_TRY_CHECK; - if (result) - { - if (this->any_owns_data_ && this->value_) - { - s = *(char **) this->value_; - return 1; - } - else - { - TAO_InputCDR stream (this->cdr_, - this->byte_order_); - if (stream.read_string (s)) - { - ACE_const_cast (CORBA_Any *, - this)->any_owns_data_ = 1; + if (!result) + return 0; - char **tmp; + if (this->any_owns_data_ && this->value_) + { + s = ACE_static_cast (char *,this->value_); + return 1; + } - ACE_NEW_RETURN (tmp, - char *, - 0); - *tmp = s; + TAO_InputCDR stream (this->cdr_, + this->byte_order_); + CORBA::String_var tmp; + if (!stream.read_string (tmp.out ())) + return 0; - ACE_const_cast (CORBA_Any *, - this)->value_ = tmp; + ACE_const_cast(CORBA::Any*, + this)->_tao_replace (CORBA::_tc_string, + 1, + tmp.inout (), + CORBA::Any::_tao_any_string_destructor); - return 1; - } - else - { - s = 0; - return 0; - } - } - } - else - { - s = 0; - return 0; - } + s = tmp._retn (); + return 1; } ACE_CATCHANY { - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("Exception in unbounded string extraction\n"))); } ACE_ENDTRY; @@ -1596,124 +1138,57 @@ CORBA_Any::operator>>= (char *&s) const return 0; } -CORBA::Boolean -CORBA_Any::operator>>= (const char *&s) const +void +CORBA_Any::_tao_any_string_destructor (void *x) { - ACE_DECLARE_NEW_CORBA_ENV; - - ACE_TRY - { - CORBA::Boolean result = - this->type_->equivalent (CORBA::_tc_string, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - if (result) - { - if (this->any_owns_data_ && this->value_) - { - s = *(char **) this->value_; - return 1; - } - else - { - TAO_InputCDR stream (this->cdr_, - this->byte_order_); - if (stream.read_string ((char *&)s)) - { - ACE_const_cast (CORBA_Any *, - this)->any_owns_data_ = 1; - - char **tmp; - - ACE_NEW_RETURN (tmp, - char *, - 0); - - *tmp = (char *)s; - - ACE_const_cast (CORBA_Any *, - this)->value_ = tmp; - - return 1; - } - else - { - s = 0; - return 0; - } - } - } - else - { - s = 0; - return 0; - } - } - ACE_CATCHANY - { - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("Exception in unbounded string extraction\n"))); - } - ACE_ENDTRY; + char *tmp = ACE_static_cast (char*,x); + CORBA::string_free (tmp); +} - s = 0; - return 0; +void +CORBA::Any::_tao_any_wstring_destructor (void *x) +{ + CORBA::WChar *tmp = ACE_static_cast (CORBA::WChar*,x); + CORBA::wstring_free (tmp); } CORBA::Boolean -CORBA_Any::operator>>= (CORBA::WChar *&ws) const +CORBA_Any::operator>>= (const CORBA::WChar *&s) const { ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { + s = 0; + CORBA::Boolean result = this->type_->equivalent (CORBA::_tc_wstring, ACE_TRY_ENV); ACE_TRY_CHECK; - if (result) - { - if (this->any_owns_data_ && this->value_) - { - ws = *(CORBA::WChar **) this->value_; - return 1; - } - else - { - TAO_InputCDR stream (this->cdr_, - this->byte_order_); - if (stream.read_wstring (ws)) - { - ACE_const_cast (CORBA_Any *, - this)->any_owns_data_ = 1; - - CORBA::WChar **tmp; + if (!result) + return 0; - ACE_NEW_RETURN (tmp, - CORBA::WChar *, - 0); + if (this->any_owns_data_ && this->value_) + { + s = ACE_static_cast (CORBA::WChar *,this->value_); + return 1; + } - *tmp = ws; + TAO_InputCDR stream (this->cdr_, + this->byte_order_); + CORBA::WString_var tmp; + if (!stream.read_wstring (tmp.out ())) + return 0; - ACE_const_cast (CORBA_Any *, - this)->value_ = tmp; + ACE_const_cast(CORBA::Any*, + this)->_tao_replace (CORBA::_tc_wstring, + 1, + tmp.inout (), + CORBA::Any::_tao_any_wstring_destructor); - return 1; - } - else - { - ws = 0; - return 0; - } - } - } - else - { - ws = 0; - return 0; - } + s = tmp._retn (); + return 1; } ACE_CATCHANY { @@ -1722,73 +1197,14 @@ CORBA_Any::operator>>= (CORBA::WChar *&ws) const } ACE_ENDTRY; - ws = 0; return 0; } -CORBA::Boolean -CORBA_Any::operator>>= (const CORBA::WChar *&ws) const +void +CORBA::Any::_tao_any_tc_destructor (void *x) { - ACE_DECLARE_NEW_CORBA_ENV; - - ACE_TRY - { - CORBA::Boolean result = - this->type_->equivalent (CORBA::_tc_wstring, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - if (result) - { - if (this->any_owns_data_ && this->value_) - { - ws = *(CORBA::WChar **) this->value_; - return 1; - } - else - { - TAO_InputCDR stream (this->cdr_, - this->byte_order_); - if (stream.read_wstring ((CORBA::WChar *&)ws)) - { - ACE_const_cast (CORBA_Any *, - this)->any_owns_data_ = 1; - - CORBA::WChar **tmp; - - ACE_NEW_RETURN (tmp, - CORBA::WChar *, - 0); - - *tmp = (CORBA::WChar *)ws; - - ACE_const_cast (CORBA_Any *, - this)->value_ = tmp; - - return 1; - } - else - { - ws = 0; - return 0; - } - } - } - else - { - ws = 0; - return 0; - } - } - ACE_CATCHANY - { - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("Exception in unbounded wstring extraction\n"))); - } - ACE_ENDTRY; - - ws = 0; - return 0; + CORBA::TypeCode_ptr tmp = ACE_static_cast (CORBA::TypeCode_ptr,x); + CORBA::release (tmp); } CORBA::Boolean @@ -1803,32 +1219,30 @@ CORBA_Any::operator>>= (CORBA::TypeCode_ptr &tc) const ACE_TRY_ENV); ACE_TRY_CHECK; - if (result) - { - if (this->any_owns_data_ && this->value_) - { - tc = *(CORBA::TypeCode_ptr *) this->value_; - return 1; - } - else - { - TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_, - this->byte_order_); - CORBA::TypeCode::traverse_status retval = - stream.decode (CORBA::_tc_TypeCode, - &tc, - 0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - return (CORBA::Boolean) ((retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - ? 1 - : 0); - } - } - else + if (!result) + return 0; + + if (this->any_owns_data_ && this->value_) { - return 0; + tc = ACE_static_cast (CORBA::TypeCode_ptr, this->value_); + return 1; } + + TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_, + this->byte_order_); + CORBA::TypeCode_var tmp; + + if (!(stream >> tmp.inout ())) + return 0; + + ACE_const_cast(CORBA::Any*, + this)->_tao_replace (CORBA::_tc_TypeCode, + 1, + tmp.in (), + CORBA::Any::_tao_any_tc_destructor); + + tc = tmp._retn (); + return 1; } ACE_CATCHANY { @@ -1854,24 +1268,12 @@ CORBA_Any::operator>>= (to_boolean b) const ACE_TRY_ENV); ACE_TRY_CHECK; - if (result) - { - if (this->any_owns_data_ && this->value_) - { - b.ref_ = *(CORBA::Boolean *) this->value_; - return 1; - } - else - { - TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_, - this->byte_order_); - return stream.read_boolean (b.ref_); - } - } - else - { - return 0; - } + if (!result) + return 0; + + TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_, + this->byte_order_); + return stream.read_boolean (b.ref_); } ACE_CATCHANY { @@ -1895,24 +1297,12 @@ CORBA_Any::operator>>= (to_octet o) const ACE_TRY_ENV); ACE_TRY_CHECK; - if (result) - { - if (this->any_owns_data_ && this->value_) - { - o.ref_ = *(CORBA::Octet *) this->value_; - return 1; - } - else - { - TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_, - this->byte_order_); - return stream.read_octet (o.ref_); - } - } - else - { - return 0; - } + if (!result) + return 0; + + TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_, + this->byte_order_); + return stream.read_octet (o.ref_); } ACE_CATCHANY { @@ -1936,24 +1326,12 @@ CORBA_Any::operator>>= (to_char c) const ACE_TRY_ENV); ACE_TRY_CHECK; - if (result) - { - if (this->any_owns_data_ && this->value_) - { - c.ref_ = *(CORBA::Char *) this->value_; - return 1; - } - else - { - TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_, - this->byte_order_); - return stream.read_char (c.ref_); - } - } - else - { - return 0; - } + if (!result) + return 0; + + TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_, + this->byte_order_); + return stream.read_char (c.ref_); } ACE_CATCHANY { @@ -1977,24 +1355,12 @@ CORBA_Any::operator>>= (to_wchar wc) const ACE_TRY_ENV); ACE_TRY_CHECK; - if (result) - { - if (this->any_owns_data_ && this->value_) - { - wc.ref_ = *(CORBA::WChar *) this->value_; - return 1; - } - else - { - TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_, - this->byte_order_); - return stream.read_wchar (wc.ref_); - } - } - else - { - return 0; - } + if (!result) + return 0; + + TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_, + this->byte_order_); + return stream.read_wchar (wc.ref_); } ACE_CATCHANY { @@ -2013,47 +1379,50 @@ CORBA_Any::operator>>= (to_string s) const ACE_TRY { - CORBA::Boolean result = - this->type_->equivalent (CORBA::_tc_string, - ACE_TRY_ENV); + CORBA::ULong kind = + this->type_->kind (ACE_TRY_ENV); ACE_TRY_CHECK; - if (result) + CORBA::TypeCode_var tcvar = + CORBA::TypeCode::_duplicate (this->type_); + + while (kind == CORBA::tk_alias) { - CORBA::ULong bound = this->type_->length (ACE_TRY_ENV); + tcvar = tcvar->content_type (ACE_TRY_ENV); + ACE_TRY_CHECK; + + kind = tcvar->kind (ACE_TRY_ENV); ACE_TRY_CHECK; - if (s.bound_ == bound) // bounds are same - { - if (this->any_owns_data_ && this->value_) - { - s.val_ = *(char **) this->value_; - return 1; - } - else - { - TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_, - this->byte_order_); - if (stream.read_string (s.val_)) - { - ACE_const_cast (CORBA_Any *, - this)->any_owns_data_ = 1; - return 1; - } - else - { - return 0; - } - } - } - else - { - return 0; - } } - else + + if (kind != CORBA::tk_string) + return 0; + + CORBA::ULong bound = tcvar->length (ACE_TRY_ENV); + ACE_TRY_CHECK; + if (s.bound_ != bound) + return 0; + + if (this->any_owns_data_ && this->value_) { - return 0; + s.val_ = ACE_static_cast (char*,this->value_); + return 1; } + + TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_, + this->byte_order_); + CORBA::String_var tmp; + if (!stream.read_string (tmp.out ())) + return 0; + + ACE_const_cast(CORBA::Any*, + this)->_tao_replace (CORBA::_tc_string, + 1, + ACE_static_cast(char*,tmp), + CORBA::Any::_tao_any_string_destructor); + + s.val_ = tmp._retn (); + return 1; } ACE_CATCHANY { @@ -2072,47 +1441,50 @@ CORBA_Any::operator>>= (to_wstring ws) const ACE_TRY { - CORBA::Boolean result = - this->type_->equivalent (CORBA::_tc_wstring, - ACE_TRY_ENV); + CORBA::ULong kind = + this->type_->kind (ACE_TRY_ENV); ACE_TRY_CHECK; - if (result) + CORBA::TypeCode_var tcvar = + CORBA::TypeCode::_duplicate (this->type_); + + while (kind == CORBA::tk_alias) { - CORBA::ULong bound = this->type_->length (ACE_TRY_ENV); + tcvar = tcvar->content_type (ACE_TRY_ENV); + ACE_TRY_CHECK; + + kind = tcvar->kind (ACE_TRY_ENV); ACE_TRY_CHECK; - if (ws.bound_ == bound) // bounds are same - { - if (this->any_owns_data_ && this->value_) - { - ws.val_ = *(CORBA::WChar **) this->value_; - return 1; - } - else - { - TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_, - this->byte_order_); - if (stream.read_wstring (ws.val_)) - { - ACE_const_cast (CORBA_Any *, - this)->any_owns_data_ = 1; - return 1; - } - else - { - return 0; - } - } - } - else - { - return 0; - } } - else + + if (kind != CORBA::tk_wstring) + return 0; + + CORBA::ULong bound = tcvar->length (ACE_TRY_ENV); + ACE_TRY_CHECK; + if (ws.bound_ != bound) + return 0; + + if (this->any_owns_data_ && this->value_) { - return 0; + ws.val_ = ACE_static_cast(CORBA::WChar *, this->value_); + return 1; } + + TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_, + this->byte_order_); + CORBA::WString_var tmp; + if (!stream.read_wstring (tmp.out ())) + return 0; + + ACE_const_cast(CORBA::Any*, + this)->_tao_replace (CORBA::_tc_string, + 1, + ACE_static_cast(CORBA::WChar*,tmp), + CORBA::Any::_tao_any_wstring_destructor); + + ws.val_ = tmp._retn (); + return 1; } ACE_CATCHANY { @@ -2131,38 +1503,53 @@ CORBA_Any::operator>>= (to_object obj) const ACE_TRY { - // Any interface is allowed - CORBA::Boolean result = - (this->type_->kind (ACE_TRY_ENV) == CORBA::tk_objref); + CORBA::ULong kind = + this->type_->kind (ACE_TRY_ENV); ACE_TRY_CHECK; - if (result) + CORBA::TypeCode_var tcvar = + CORBA::TypeCode::_duplicate (this->type_); + while (kind == CORBA::tk_alias) { - if (this->any_owns_data_ && this->value_) - { - // CORBA 2.3 has changed the behavior of this operator. Caller - // is now responsible for release. - obj.ref_ = - CORBA::Object::_duplicate (*(CORBA::Object_ptr *) this->value_); - - return 1; - } - else - { - // @@ This uses ORB_Core instance because we need one to - // demarshal objects (to create the right profiles for that - // object), but the Any does not belong to any ORB. - TAO_InputCDR stream (this->cdr_, - this->byte_order_, - TAO_ORB_Core_instance ()); + tcvar = tcvar->content_type (ACE_TRY_ENV); + ACE_TRY_CHECK; - return (stream >> obj.ref_); - } - } - else - { - return 0; + kind = tcvar->kind (ACE_TRY_ENV); + ACE_TRY_CHECK; } + + if (kind != CORBA::tk_objref) + return 0; + + // It is hard to apply this optimization, because value_ points + // to a derived class from CORBA::Object, and with multiple + // virtual inheritance. One posibility is to use a helper + // function to upcast from void* to CORBA::Object_ptr, but this + // is only useful to implement the >>=(to_object) operator, + // which is very rarely used. + // It is better to just demarshal the object everytime, + // specially because the caller is owns the returned object. + // + // if (this->any_owns_data_ && this->value_) + // { + // // CORBA 2.3 has changed the behavior of this operator. Caller + // // is now responsible for release. + // obj.ref_ = + // CORBA::Object::_duplicate ( + // (*this->upcast_) (this->value_) + // ); + // return 1; + // } + + // @@ This uses ORB_Core instance because we need one to + // demarshal objects (to create the right profiles for that + // object), but the Any does not belong to any ORB. + TAO_InputCDR stream (this->cdr_, + this->byte_order_, + TAO_ORB_Core_instance ()); + + if (stream >> obj.ref_) + return 1; } ACE_CATCHANY { @@ -2180,102 +1567,91 @@ CORBA_Any::operator>>= (to_object obj) const void CORBA_Any::operator<<= (const char* s) { - ACE_DECLARE_NEW_CORBA_ENV; - - ACE_TRY - { - char **tmp; - - ACE_NEW (tmp, - char * (CORBA::string_dup (s))); - - this->replace (CORBA::_tc_string, - tmp, - 1, - ACE_TRY_ENV); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("Exception in unbounded string insertion\n"))); - } - ACE_ENDTRY; - ACE_CHECK; + TAO_OutputCDR stream; + stream << s; + this->_tao_replace (CORBA::_tc_string, + TAO_ENCAP_BYTE_ORDER, + stream.begin ()); } // and the version for unbounded wide string void CORBA_Any::operator<<= (const CORBA::WChar* s) { - ACE_DECLARE_NEW_CORBA_ENV; - - ACE_TRY - { - CORBA::WChar **tmp; - - ACE_NEW (tmp, - CORBA::WChar * (CORBA::wstring_dup (s))); - - this->replace (CORBA::_tc_wstring, - tmp, - 1, - ACE_TRY_ENV); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("Exception in unbounded wstring insertion\n"))); - } - ACE_ENDTRY; - ACE_CHECK; + TAO_OutputCDR stream; + stream << s; + this->_tao_replace (CORBA::_tc_wstring, + TAO_ENCAP_BYTE_ORDER, + stream.begin ()); } CORBA::Boolean operator<< (TAO_OutputCDR& cdr, const CORBA::Any &x) { - // @@ This function should *not* use the interpreter, there must be - // a way to do this with just CDR operations!!!! + if (!(cdr << x.type ())) + return 0; + ACE_TRY_NEW_ENV { - CORBA::TypeCode::traverse_status status = - TAO_MARSHAL_ANY::instance ()->encode (0, - &x, - 0, - &cdr, - ACE_TRY_ENV); + TAO_InputCDR input (x._tao_get_cdr (), + x._tao_byte_order ()); + cdr.append (x.type (), + &input, + ACE_TRY_ENV); ACE_TRY_CHECK; - - if (status== CORBA::TypeCode::TRAVERSE_CONTINUE) - return 1; - // else return 0 at the end of the function } ACE_CATCH (CORBA_Exception, ex) { return 0; } ACE_ENDTRY; - return 0; + return 1; } CORBA::Boolean operator>> (TAO_InputCDR &cdr, CORBA::Any &x) { + CORBA::TypeCode_var tc; + if (!(cdr >> tc.out ())) + return 0; + ACE_TRY_NEW_ENV { + // @@ (JP) The following code depends on the fact that + // TAO_InputCDR does not contain chained message blocks, + // otherwise <begin> and <end> could be part of + // different buffers! + + // This will be the start of a new message block. + char *begin = cdr.rd_ptr (); + + // Skip over the next aregument. CORBA::TypeCode::traverse_status status = - TAO_MARSHAL_ANY::instance ()->decode (0, - &x, - 0, - &cdr, - ACE_TRY_ENV); + cdr.skip (tc.in (), ACE_TRY_ENV); ACE_TRY_CHECK; if (status != CORBA::TypeCode::TRAVERSE_CONTINUE) - return 0; + { + return 0; + } + + // This will be the end of the new message block. + char *end = cdr.rd_ptr (); + + size_t size = end - begin; + ACE_Message_Block mb (size + ACE_CDR::MAX_ALIGNMENT); + ACE_CDR::mb_align (&mb); + ptr_arith_t offset = ptr_arith_t (begin) % ACE_CDR::MAX_ALIGNMENT; + mb.rd_ptr (offset); + mb.wr_ptr (offset + size); + ACE_OS::memcpy (mb.rd_ptr (), begin, size); + + // Stick it into the Any. It gets duplicated there. + x._tao_replace (tc.in (), + cdr.byte_order (), + &mb); } ACE_CATCH (CORBA_Exception, ex) { diff --git a/TAO/tao/Any.h b/TAO/tao/Any.h index 623dd563bd4..aff2d328074 100644 --- a/TAO/tao/Any.h +++ b/TAO/tao/Any.h @@ -75,9 +75,9 @@ public: // Default constructor. CORBA_Any (CORBA::TypeCode_ptr type, - void *value = 0, - CORBA::Boolean any_owns_data = 0); - // Constructor. The any_owns_data flag determines if the Any owns the value + CORBA::Environment &ACE_TRY_ENV + = TAO_default_environment ()); + // Constructor. // = TAO extension CORBA_Any (CORBA::TypeCode_ptr type, @@ -188,11 +188,9 @@ public: CORBA::Boolean operator>>= (CORBA::TypeCode_ptr&) const; // extract a TypeCode - CORBA::Boolean operator>>= (char*&) const; // deperecated CORBA::Boolean operator>>= (const char*&) const; // extract an unbounded string - CORBA::Boolean operator>>= (CORBA::WChar*&) const; // deprecated CORBA::Boolean operator>>= (const CORBA::WChar*&) const; // extract an unbounded wide string @@ -279,20 +277,31 @@ public: // ORBOS/90-01-11, pg 672: For C++ mapping using the CORBA_Environment // parameter, two forms of the replace method are provided. +#if 0 + CORBA_Any (CORBA::TypeCode_ptr type, + void *value, + CORBA::Boolean any_owns_data, + CORBA::Environment &ACE_TRY_ENV + = TAO_default_environment ()); + CORBA_Any (CORBA::TypeCode_ptr type, + void *value, + CORBA::Environment &ACE_TRY_ENV + = TAO_default_environment ()); + // Obsolete. Raises CORBA::NO_IMPLEMENT. + void replace (CORBA::TypeCode_ptr type, const void *value, CORBA::Boolean any_owns_data, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - // Replace the current typecode and data with the specified one - - // unsafe. + // Obsolete. Raises CORBA::NO_IMPLEMENT. void replace (CORBA::TypeCode_ptr type, const void *value, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - // Replace the current typecode and data with the specified one - - // unsafe. This uses a default value for the "any_owns_data" parameter + // Obsolete. Raises CORBA::NO_IMPLEMENT. +#endif CORBA::TypeCode_ptr type (void) const; // Return TypeCode of the element stored in the Any. @@ -322,10 +331,13 @@ public: int _tao_byte_order (void) const; // Get the byte order inside the CDR stream. + typedef void (*_tao_destructor)(void*); + // Generated data types define a 'destructor' function that + // correctly destroys an object stored in the Any. + void _tao_replace (CORBA::TypeCode_ptr, int byte_order, - const ACE_Message_Block *mb, - CORBA::Environment &ACE_TRY_ENV); + const ACE_Message_Block *mb); // Replace via message block instead of <value_>. void _tao_replace (CORBA::TypeCode_ptr type, @@ -333,13 +345,13 @@ public: const ACE_Message_Block *mb, CORBA::Boolean any_owns_data, void* value, - CORBA::Environment &ACE_TRY_EN); + CORBA::Any::_tao_destructor destructor); // Replace all the contents of the any, used in the <<= operators. void _tao_replace (CORBA::TypeCode_ptr type, CORBA::Boolean any_owns_data, void* value, - CORBA::Environment &ACE_TRY_ENV); + CORBA::Any::_tao_destructor destructor); // Replace the value of the Any, used in the >>= operators. void _tao_encode (TAO_OutputCDR &cdr, @@ -357,17 +369,20 @@ public: #endif /* __GNUC__ */ // Useful for template programming. + static void _tao_any_destructor (void*); + static void _tao_any_string_destructor (void*); + static void _tao_any_wstring_destructor (void*); + static void _tao_any_tc_destructor (void*); + // Used to release Anys contained into anys. + protected: - void free_value (CORBA::Environment &ACE_TRY_ENV); + void free_value (void); // Release the <value_>. private: CORBA::TypeCode_ptr type_; // Typecode for the <Any>. - void *value_; - // Value for the <Any>. - int byte_order_; ACE_Message_Block *cdr_; // encoded value. @@ -375,6 +390,12 @@ private: CORBA::Boolean any_owns_data_; // Flag that indicates the ORB is responsible for deleting the data. + void *value_; + // Value for the <Any>. + + CORBA::Any::_tao_destructor destructor_; + // If not zero this is the function used to destroy objects. + // 94-9-14 hides unsigned char insert/extract void operator<<= (unsigned char); CORBA::Boolean operator>>= (unsigned char&) const; @@ -552,7 +573,9 @@ TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var, TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var, CORBA::TypeCode_ptr&); TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var, - char*&); + const char*&); +TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var, + const CORBA::WChar*&); TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var, CORBA::Any::to_boolean); TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var, diff --git a/TAO/tao/Any.i b/TAO/tao/Any.i index 370cd09cafa..408e4fd4da3 100644 --- a/TAO/tao/Any.i +++ b/TAO/tao/Any.i @@ -3,20 +3,6 @@ // Insertion from special types. -ACE_INLINE -void -CORBA_Any::replace (CORBA::TypeCode_ptr type, - const void *value, - CORBA::Environment &ACE_TRY_ENV) -{ - // Invoke the first form of the replace method and pass the default - // value (FALSE) for the "any_owns_data" parameter - this->replace (type, - value, - 0, - ACE_TRY_ENV); -} - ACE_INLINE CORBA::Boolean CORBA_Any::any_owns_data (void) const { @@ -289,7 +275,13 @@ operator >>= (CORBA_Any_var lhs, CORBA::TypeCode_ptr &rhs) } ACE_INLINE CORBA::Boolean -operator >>= (CORBA_Any_var lhs, char* &rhs) +operator >>= (CORBA_Any_var lhs, const char *&rhs) +{ + return lhs.inout () >>= rhs; +} + +ACE_INLINE CORBA::Boolean +operator >>= (CORBA_Any_var lhs, const CORBA::WChar *&rhs) { return lhs.inout () >>= rhs; } diff --git a/TAO/tao/BoundsC.cpp b/TAO/tao/BoundsC.cpp index fa7be70cea4..ac889a9ef50 100644 --- a/TAO/tao/BoundsC.cpp +++ b/TAO/tao/BoundsC.cpp @@ -25,6 +25,12 @@ CORBA_Bounds::~CORBA_Bounds (void) { } +void CORBA_Bounds::_tao_any_destructor (void *x) +{ + CORBA_Bounds *tmp = ACE_static_cast (CORBA_Bounds*,x); + delete tmp; +} + // copy constructor CORBA_Bounds::CORBA_Bounds (const CORBA::Bounds &_tao_excp) : CORBA_UserException (_tao_excp._type ()) @@ -86,33 +92,25 @@ CORBA::Exception *CORBA_Bounds::_alloc (void) -void operator<<= (CORBA::Any &_tao_any, const CORBA::Bounds &_tao_elem) // copying +void operator<<= (CORBA::Any &_tao_any, const CORBA::Bounds &_tao_elem) { - CORBA::Bounds *_tao_any_val = 0; - ACE_NEW (_tao_any_val, - CORBA::Bounds (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { - _tao_any.replace (CORBA::_tc_Bounds, _tao_any_val, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace (CORBA::_tc_Bounds, + TAO_ENCAP_BYTE_ORDER, + stream.begin ()); } void operator<<= (CORBA::Any &_tao_any, CORBA::Bounds *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { - _tao_any.replace (CORBA::_tc_Bounds, _tao_elem, 1, ACE_TRY_ENV); // consume it - ACE_TRY_CHECK; - } - ACE_CATCHANY {} - ACE_ENDTRY; + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace (CORBA::_tc_Bounds, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + CORBA::Bounds::_tao_any_destructor); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Bounds *&_tao_elem) @@ -130,24 +128,29 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Bounds *&_tao_ele else { ACE_NEW_RETURN (_tao_elem, CORBA::Bounds, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_Bounds, _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 (CORBA::_tc_Bounds, _tao_elem, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_Bounds, + 1, + ACE_reinterpret_cast (void*, _tao_elem), + CORBA::Bounds::_tao_any_destructor); return 1; } else { delete _tao_elem; + _tao_elem = 0; } } } ACE_CATCHANY { delete _tao_elem; + _tao_elem = 0; return 0; } ACE_ENDTRY; diff --git a/TAO/tao/BoundsC.h b/TAO/tao/BoundsC.h index d8f9aae8259..801d27767d4 100644 --- a/TAO/tao/BoundsC.h +++ b/TAO/tao/BoundsC.h @@ -12,6 +12,9 @@ #define _TAO_IDL_BOUNDSC_H_ #include "tao/corbafwd.h" +#include "tao/Exception.h" +#include "tao/CDR.h" +#include "tao/Any.h" #if !defined (ACE_LACKS_PRAGMA_ONCE) # pragma once @@ -45,7 +48,7 @@ CORBA_Bounds (void); // default ctor CORBA_Bounds (const CORBA_Bounds &); // copy ctor ~CORBA_Bounds (void); // dtor - CORBA_Bounds &operator= (const CORBA_Bounds &); + CORBA_Bounds &operator= (const CORBA_Bounds &); virtual void _raise (void); @@ -56,7 +59,7 @@ CORBA::Environment &); static CORBA_Bounds *_narrow (CORBA::Exception *); - + static void _tao_any_destructor (void*); // = TAO extension static CORBA::Exception *_alloc (void); diff --git a/TAO/tao/CDR.cpp b/TAO/tao/CDR.cpp index 7d2a41a04c2..fec38f7d6da 100644 --- a/TAO/tao/CDR.cpp +++ b/TAO/tao/CDR.cpp @@ -126,27 +126,6 @@ TAO_OutputCDR::TAO_OutputCDR (ACE_Message_Block *data, } CORBA::TypeCode::traverse_status -TAO_OutputCDR::encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *data2, - CORBA::Environment &ACE_TRY_ENV) -{ - TAO_Marshal_Object *mobj = - TAO_MARSHAL_FACTORY::instance ()->make_marshal_object - (tc, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - if (!mobj) - return CORBA::TypeCode::TRAVERSE_STOP; - - return mobj->encode (tc, - data, - data2, - this, - ACE_TRY_ENV); -} - -CORBA::TypeCode::traverse_status TAO_OutputCDR::append (CORBA::TypeCode_ptr tc, TAO_InputCDR *src, CORBA::Environment &ACE_TRY_ENV) @@ -192,28 +171,6 @@ TAO_InputCDR::init_translators (void) } CORBA::TypeCode::traverse_status -TAO_InputCDR::decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *data2, - CORBA::Environment &ACE_TRY_ENV) -{ - TAO_Marshal_Object *mobj = - TAO_MARSHAL_FACTORY::instance ()->make_marshal_object - (tc, ACE_TRY_ENV); - - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - if (!mobj) - return CORBA::TypeCode::TRAVERSE_STOP; - - return mobj->decode (tc, - data, - data2, - this, - ACE_TRY_ENV); -} - -CORBA::TypeCode::traverse_status TAO_InputCDR::skip (CORBA::TypeCode_ptr tc, CORBA::Environment &ACE_TRY_ENV) { diff --git a/TAO/tao/CDR.h b/TAO/tao/CDR.h index 497a4339570..cbc617ed079 100644 --- a/TAO/tao/CDR.h +++ b/TAO/tao/CDR.h @@ -132,14 +132,6 @@ public: // = TAO specific methods. - CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - CORBA_Environment &ACE_TRY_ENV = - TAO_default_environment ()); - // Marshalls the contents of <data> as described by the TypeCode in - // <tc>. Any errors are reported though the <ACE_TRY_ENV> parameter. - private: TAO_OutputCDR (const TAO_OutputCDR& rhs); TAO_OutputCDR& operator= (const TAO_OutputCDR& rhs); @@ -229,14 +221,6 @@ public: // = TAO specific methods. - CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - CORBA_Environment &ACE_TRY_ENV = - TAO_default_environment ()); - // Demarshall the contents of the CDR stream into <data> as - // described by <tc>; returning any errors in <ACE_TRY_ENV>. - CORBA::TypeCode::traverse_status skip (CORBA::TypeCode_ptr tc, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); diff --git a/TAO/tao/CONV_FRAMEC.cpp b/TAO/tao/CONV_FRAMEC.cpp index 8b4978ab66a..c9f880f52c1 100644 --- a/TAO/tao/CONV_FRAMEC.cpp +++ b/TAO/tao/CONV_FRAMEC.cpp @@ -24,6 +24,27 @@ #include "tao/CONV_FRAMEC.i" #endif /* !defined INLINE */ +void +CONV_FRAME::CodeSetComponent::_tao_any_destructor (void* x) +{ + CONV_FRAME::CodeSetComponent *tmp = ACE_static_cast(CONV_FRAME::CodeSetComponent*,x); + delete tmp; +} + +void +CONV_FRAME::CodeSetComponentInfo::_tao_any_destructor (void* x) +{ + CONV_FRAME::CodeSetComponentInfo *tmp = ACE_static_cast(CONV_FRAME::CodeSetComponentInfo*,x); + delete tmp; +} + +void +CONV_FRAME::CodeSetContext::_tao_any_destructor (void* x) +{ + CONV_FRAME::CodeSetContext *tmp = ACE_static_cast(CONV_FRAME::CodeSetContext*,x); + delete tmp; +} + static const CORBA::Long _oc_CONV_FRAME_CodeSetId[] = { TAO_ENCAP_BYTE_ORDER, // byte order @@ -269,52 +290,27 @@ TAO_NAMESPACE_END void operator<<= (CORBA::Any &_tao_any, const CONV_FRAME::CodeSetComponent &_tao_elem) // copying { - CONV_FRAME::CodeSetComponent *_any_val = 0; - ACE_NEW (_any_val, CONV_FRAME::CodeSetComponent (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { - 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 - { - delete _any_val; - } - ACE_ENDTRY; + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + CONV_FRAME::_tc_CodeSetComponent, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); } void operator<<= (CORBA::Any &_tao_any, CONV_FRAME::CodeSetComponent *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { - 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 - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CONV_FRAME::_tc_CodeSetComponent, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + CONV_FRAME::CodeSetComponent::_tao_any_destructor + ); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CONV_FRAME::CodeSetComponent *&_tao_elem) @@ -346,9 +342,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CONV_FRAME::CodeSetCompo CONV_FRAME::_tc_CodeSetComponent, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CONV_FRAME::CodeSetComponent::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -362,7 +357,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CONV_FRAME::CodeSetCompo { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -396,10 +391,9 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CONV_FRAME::CodeSe ((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; + ACE_const_cast (CONV_FRAME::CodeSetComponent *&, _tao_elem), + CONV_FRAME::CodeSetComponent::_tao_any_destructor + ); return 1; } else @@ -413,7 +407,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CONV_FRAME::CodeSe { delete ACE_const_cast (CONV_FRAME::CodeSetComponent *&, _tao_elem); _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -421,52 +415,27 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CONV_FRAME::CodeSe void operator<<= (CORBA::Any &_tao_any, const CONV_FRAME::CodeSetComponentInfo &_tao_elem) // copying { - CONV_FRAME::CodeSetComponentInfo *_any_val = 0; - ACE_NEW (_any_val, CONV_FRAME::CodeSetComponentInfo (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { - 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 - { - delete _any_val; - } - ACE_ENDTRY; + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + CONV_FRAME::_tc_CodeSetComponentInfo, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); } void operator<<= (CORBA::Any &_tao_any, CONV_FRAME::CodeSetComponentInfo *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { - 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 - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CONV_FRAME::_tc_CodeSetComponentInfo, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + CONV_FRAME::CodeSetComponentInfo::_tao_any_destructor + ); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CONV_FRAME::CodeSetComponentInfo *&_tao_elem) @@ -498,9 +467,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CONV_FRAME::CodeSetCompo CONV_FRAME::_tc_CodeSetComponentInfo, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CONV_FRAME::CodeSetComponentInfo::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -514,7 +482,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CONV_FRAME::CodeSetCompo { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -549,9 +517,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CONV_FRAME::CodeSe CONV_FRAME::_tc_CodeSetComponentInfo, 1, ACE_reinterpret_cast (void *, ACE_const_cast (CONV_FRAME::CodeSetComponentInfo *&, _tao_elem)), - ACE_TRY_ENV + CONV_FRAME::CodeSetComponentInfo::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -565,7 +532,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CONV_FRAME::CodeSe { delete ACE_const_cast (CONV_FRAME::CodeSetComponentInfo *&, _tao_elem); _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -573,52 +540,27 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CONV_FRAME::CodeSe void operator<<= (CORBA::Any &_tao_any, const CONV_FRAME::CodeSetContext &_tao_elem) // copying { - CONV_FRAME::CodeSetContext *_any_val = 0; - ACE_NEW (_any_val, CONV_FRAME::CodeSetContext (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { - 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 - { - delete _any_val; - } - ACE_ENDTRY; + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + CONV_FRAME::_tc_CodeSetContext, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); } void operator<<= (CORBA::Any &_tao_any, CONV_FRAME::CodeSetContext *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { - 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 - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CONV_FRAME::_tc_CodeSetContext, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + CONV_FRAME::CodeSetContext::_tao_any_destructor + ); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CONV_FRAME::CodeSetContext *&_tao_elem) @@ -650,9 +592,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CONV_FRAME::CodeSetConte CONV_FRAME::_tc_CodeSetContext, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CONV_FRAME::CodeSetContext::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -666,7 +607,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CONV_FRAME::CodeSetConte { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -701,9 +642,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CONV_FRAME::CodeSe CONV_FRAME::_tc_CodeSetContext, 1, ACE_reinterpret_cast (void *, ACE_const_cast (CONV_FRAME::CodeSetContext *&, _tao_elem)), - ACE_TRY_ENV - ); - ACE_TRY_CHECK; + CONV_FRAME::CodeSetContext::_tao_any_destructor + ); return 1; } else @@ -717,7 +657,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CONV_FRAME::CodeSe { delete ACE_const_cast (CONV_FRAME::CodeSetContext *&, _tao_elem); _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; diff --git a/TAO/tao/CONV_FRAMEC.h b/TAO/tao/CONV_FRAMEC.h index 0d7a29da65d..16dce107030 100644 --- a/TAO/tao/CONV_FRAMEC.h +++ b/TAO/tao/CONV_FRAMEC.h @@ -48,6 +48,8 @@ TAO_NAMESPACE CONV_FRAME struct TAO_Export CodeSetComponent { + static void _tao_any_destructor (void*); + CodeSetId native_code_set; #if !defined (TAO_USE_SEQUENCE_TEMPLATES) @@ -239,6 +241,8 @@ TAO_NAMESPACE CONV_FRAME struct TAO_Export CodeSetComponentInfo { + static void _tao_any_destructor (void*); + CodeSetComponent ForCharData; CodeSetComponent ForWcharData; }; @@ -292,6 +296,8 @@ TAO_NAMESPACE CONV_FRAME struct TAO_Export CodeSetContext { + static void _tao_any_destructor (void*); + CodeSetId char_data; CodeSetId wchar_data; }; @@ -331,29 +337,29 @@ TAO_NAMESPACE CONV_FRAME } TAO_NAMESPACE_CLOSE // module CONV_FRAME -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CONV_FRAME::CodeSetComponent &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CONV_FRAME::CodeSetComponent*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CONV_FRAME::CodeSetComponent *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CONV_FRAME::CodeSetComponent *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CONV_FRAME::CodeSetComponentInfo &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CONV_FRAME::CodeSetComponentInfo*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CONV_FRAME::CodeSetComponentInfo *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CONV_FRAME::CodeSetComponentInfo *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CONV_FRAME::CodeSetContext &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CONV_FRAME::CodeSetContext*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CONV_FRAME::CodeSetContext *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CONV_FRAME::CodeSetContext *&); #ifndef __ACE_INLINE__ diff --git a/TAO/tao/CurrentC.cpp b/TAO/tao/CurrentC.cpp index d514f92cc20..c187a2de222 100644 --- a/TAO/tao/CurrentC.cpp +++ b/TAO/tao/CurrentC.cpp @@ -67,6 +67,13 @@ CORBA_Current_ptr CORBA_Current::_nil (void) return (CORBA_Current_ptr)NULL; } // end of _nil +void +CORBA_Current::_tao_any_destructor (void* x) +{ + CORBA_Current *tmp = ACE_static_cast (CORBA_Current*,x); + CORBA::release (tmp); +} + CORBA::Boolean CORBA_Current::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV) { if ( @@ -84,47 +91,25 @@ const char* CORBA_Current::_interface_repository_id (void) const void operator<<= (CORBA::Any &_tao_any, CORBA::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 = CORBA::Current::_duplicate (_tao_elem); - TAO_OutputCDR stream; - if (stream << *_tao_obj_ptr) + TAO_OutputCDR stream; + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_Current, + CORBA::_tc_Current, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - 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::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; @@ -137,24 +122,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Current_ptr &_tao { _tao_elem = CORBA::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 ( CORBA::_tc_Current, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + CORBA::Current::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = CORBA::Current::_nil (); return 0; } @@ -162,4 +140,3 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Current_ptr &_tao _tao_elem = CORBA::Current::_nil (); return 0; } - diff --git a/TAO/tao/CurrentC.h b/TAO/tao/CurrentC.h index cef19359330..97b0aaacac6 100644 --- a/TAO/tao/CurrentC.h +++ b/TAO/tao/CurrentC.h @@ -112,7 +112,7 @@ private: #if !defined (_CORBA_CURRENT_CH_) #define _CORBA_CURRENT_CH_ -class CORBA_Current : public virtual ACE_CORBA_1 (Object) +class CORBA_Current : public virtual CORBA_Object { public: #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8 @@ -126,6 +126,7 @@ class CORBA_Current : public virtual ACE_CORBA_1 (Object) CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); static CORBA_Current_ptr _nil (void); + static void _tao_any_destructor (void*); virtual CORBA::Boolean _is_a (const CORBA::Char *type_id, CORBA_Environment &ACE_TRY_ENV = @@ -148,9 +149,9 @@ class CORBA_Current : public virtual ACE_CORBA_1 (Object) #endif /* end #if !defined */ // Any operators for interface CORBA_Current -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA_Current_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_Current *&); #if defined (__ACE_INLINE__) diff --git a/TAO/tao/DomainC.cpp b/TAO/tao/DomainC.cpp index 643350c3bcf..f1c469b5aa1 100644 --- a/TAO/tao/DomainC.cpp +++ b/TAO/tao/DomainC.cpp @@ -339,52 +339,41 @@ CORBA_DomainManagerList::CORBA_DomainManagerList (const CORBA_DomainManagerList CORBA_DomainManagerList::~CORBA_DomainManagerList (void) // dtor {} +void CORBA_DomainManager::_tao_any_destructor (void* x) +{ + CORBA_DomainManager_ptr tmp = ACE_static_cast (CORBA_DomainManager_ptr,x); + CORBA::release (tmp); +} + 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_OutputCDR stream; - if (stream << *_tao_obj_ptr) + TAO_OutputCDR stream; + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_DomainManager, + CORBA::_tc_DomainManager, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - 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::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 (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (CORBA::_tc_DomainManager, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::DomainManager_ptr)_tao_any.value (); + return 1; + } TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () @@ -394,29 +383,19 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::DomainManager_ptr { _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)->_tao_replace ( CORBA::_tc_DomainManager, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + CORBA::DomainManager::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; - _tao_elem = CORBA::DomainManager::_nil (); - return 0; } ACE_ENDTRY; - _tao_elem = CORBA::DomainManager::_nil (); return 0; } @@ -432,52 +411,42 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::DomainManager_ptr #if ! defined (TAO_HAS_MINIMUM_CORBA) +void +CORBA_ConstructionPolicy::_tao_any_destructor (void *x) +{ + CORBA_ConstructionPolicy_ptr tmp = ACE_static_cast(CORBA_ConstructionPolicy_ptr,x); + CORBA::release (tmp); +} + 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_OutputCDR stream; - if (stream << *_tao_obj_ptr) + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_ConstructionPolicy, + CORBA::_tc_ConstructionPolicy, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - 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::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 (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (CORBA::_tc_ConstructionPolicy, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (CORBA::ConstructionPolicy_ptr)_tao_any.value (); + return 1; + } TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () @@ -487,29 +456,19 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ConstructionPolic { _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)->_tao_replace ( CORBA::_tc_ConstructionPolicy, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + CORBA::ConstructionPolicy::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; - _tao_elem = CORBA::ConstructionPolicy::_nil (); - return 0; } ACE_ENDTRY; - _tao_elem = CORBA::ConstructionPolicy::_nil (); return 0; } @@ -522,63 +481,41 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ConstructionPolic #endif /* ! defined (TAO_HAS_MINIMUM_CORBA) */ +void +CORBA_DomainManagerList::_tao_any_destructor (void *x) +{ + CORBA_DomainManagerList* tmp = ACE_static_cast (CORBA_DomainManagerList*,x); + delete tmp; +} + void operator<<= ( CORBA::Any &_tao_any, const CORBA::DomainManagerList &_tao_elem ) // copying { - CORBA::DomainManagerList *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA::DomainManagerList (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - if (stream << *_tao_any_val) + if (stream << _tao_elem) { _tao_any._tao_replace ( CORBA::_tc_DomainManagerList, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_any_val; } - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; } void operator<<= (CORBA::Any &_tao_any, CORBA::DomainManagerList *_tao_elem) // non copying { - ACE_TRY_NEW_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 - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_DomainManagerList, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + CORBA::DomainManagerList::_tao_any_destructor + ); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::DomainManagerList *&_tao_elem) @@ -610,9 +547,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::DomainManagerList CORBA::_tc_DomainManagerList, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::DomainManagerList::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -626,7 +562,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::DomainManagerList { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -634,52 +570,5 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::DomainManagerList 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; + return _tao_any >>= ACE_const_cast(CORBA::DomainManagerList*&,_tao_elem); } - diff --git a/TAO/tao/DomainC.h b/TAO/tao/DomainC.h index 650a3e9d87c..8d9e9d9703a 100644 --- a/TAO/tao/DomainC.h +++ b/TAO/tao/DomainC.h @@ -96,6 +96,7 @@ public: TAO_default_environment () ); static CORBA_DomainManager_ptr _nil (void); + static void _tao_any_destructor (void*); virtual CORBA::Policy_ptr get_domain_policy ( CORBA::PolicyType policy_type, @@ -138,6 +139,7 @@ public: ); CORBA_DomainManagerList (const CORBA_DomainManagerList &); // copy ctor ~CORBA_DomainManagerList (void); // dtor + static void _tao_any_destructor (void*); }; typedef CORBA_DomainManagerList *CORBA_DomainManagerList_ptr; @@ -259,6 +261,7 @@ public: TAO_default_environment () ); static CORBA_ConstructionPolicy_ptr _nil (void); + static void _tao_any_destructor (void*); virtual void make_domain_manager ( CORBA::InterfaceDef_ptr object_type, @@ -316,9 +319,9 @@ 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 &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::DomainManagerList *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +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 113a5c0f719..07ea897c72f 100644 --- a/TAO/tao/DynAnyC.cpp +++ b/TAO/tao/DynAnyC.cpp @@ -106,12 +106,12 @@ CORBA_DynAny::Invalid::operator= (const CORBA_DynAny::Invalid &_tao_excp) } // narrow -CORBA_DynAny::Invalid_ptr +CORBA_DynAny::Invalid * CORBA_DynAny::Invalid::_narrow (CORBA::Exception *exc) { if (!ACE_OS::strcmp ("IDL:/CORBA_DynAny/Invalid:1.0", exc->_id ())) // same type - return ACE_dynamic_cast (CORBA_DynAny::Invalid_ptr, + return ACE_dynamic_cast (CORBA_DynAny::Invalid *, exc); else return 0; @@ -205,12 +205,12 @@ CORBA_DynAny::InvalidValue::operator= ( } // narrow -CORBA_DynAny::InvalidValue_ptr +CORBA_DynAny::InvalidValue * CORBA_DynAny::InvalidValue::_narrow (CORBA::Exception *exc) { if (!ACE_OS::strcmp ("IDL:/CORBA_DynAny/InvalidValue:1.0", exc->_id ())) // same type - return ACE_dynamic_cast (CORBA_DynAny::InvalidValue_ptr, + return ACE_dynamic_cast (CORBA_DynAny::InvalidValue *, exc); else return 0; @@ -308,12 +308,12 @@ CORBA_DynAny::TypeMismatch::operator= ( } // narrow -CORBA_DynAny::TypeMismatch_ptr +CORBA_DynAny::TypeMismatch * CORBA_DynAny::TypeMismatch::_narrow (CORBA::Exception *exc) { if (!ACE_OS::strcmp ("IDL:/CORBA_DynAny/TypeMismatch:1.0", exc->_id ())) // same type - return ACE_dynamic_cast (CORBA_DynAny::TypeMismatch_ptr, + return ACE_dynamic_cast (CORBA_DynAny::TypeMismatch *, exc); else return 0; @@ -410,12 +410,12 @@ CORBA_DynAny::InvalidSeq::operator= ( } // narrow -CORBA_DynAny::InvalidSeq_ptr +CORBA_DynAny::InvalidSeq * CORBA_DynAny::InvalidSeq::_narrow (CORBA::Exception *exc) { if (!ACE_OS::strcmp ("IDL:/CORBA_DynAny/InvalidSeq:1.0", exc->_id ())) // same type - return ACE_dynamic_cast (CORBA_DynAny::InvalidSeq_ptr, + return ACE_dynamic_cast (CORBA_DynAny::InvalidSeq *, exc); else return 0; diff --git a/TAO/tao/DynAnyC.h b/TAO/tao/DynAnyC.h index 3b7cb2577c4..cf1933ed0bd 100644 --- a/TAO/tao/DynAnyC.h +++ b/TAO/tao/DynAnyC.h @@ -97,7 +97,7 @@ private: CORBA_DynAny_ptr &ptr_; }; -class TAO_Export CORBA_DynAny : public virtual ACE_CORBA_1 (Object) +class TAO_Export CORBA_DynAny : public virtual CORBA_Object { public: #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8 @@ -115,7 +115,6 @@ public: static CORBA_DynAny_ptr _nil (void); class Invalid; - typedef Invalid *Invalid_ptr; class TAO_Export Invalid : public CORBA::UserException { @@ -139,17 +138,11 @@ public: // = TAO extension static CORBA::Exception *_alloc (void); -#if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8 - typedef Invalid_ptr _ptr_type; -#endif /* __GNUC__ */ - // Useful for template programming. - }; // exception CORBA_DynAny::Invalid static CORBA::TypeCode_ptr _tc_Invalid; class InvalidValue; - typedef InvalidValue *InvalidValue_ptr; class TAO_Export InvalidValue : public CORBA::UserException { @@ -173,17 +166,11 @@ public: // = TAO extension static CORBA::Exception *_alloc (void); -#if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8 - typedef InvalidValue_ptr _ptr_type; -#endif /* __GNUC__ */ - // Useful for template programming. - }; // exception CORBA_DynAny::InvalidValue static CORBA::TypeCode_ptr _tc_InvalidValue; class TypeMismatch; - typedef TypeMismatch *TypeMismatch_ptr; class TAO_Export TypeMismatch : public CORBA::UserException { @@ -207,17 +194,11 @@ public: // = TAO extension static CORBA::Exception *_alloc (void); -#if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8 - typedef TypeMismatch_ptr _ptr_type; -#endif /* __GNUC__ */ - // Useful for template programming. - - }; // exception CORBA_DynAny::TypeMismatch + }; // exception CORBA_DynAny::TypeMismatch static CORBA::TypeCode_ptr _tc_TypeMismatch; class InvalidSeq; - typedef InvalidSeq *InvalidSeq_ptr; class TAO_Export InvalidSeq : public CORBA::UserException { @@ -241,11 +222,6 @@ public: // = TAO extension static CORBA::Exception *_alloc (void); -#if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8 - typedef InvalidSeq_ptr _ptr_type; -#endif /* __GNUC__ */ - // Useful for template programming. - }; // exception CORBA_DynAny::InvalidSeq static CORBA::TypeCode_ptr _tc_InvalidSeq; @@ -611,7 +587,6 @@ struct TAO_Export CORBA_NameValuePair CORBA::Any value; #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8 - typedef CORBA_NameValuePair_ptr _ptr_type; typedef CORBA_NameValuePair_var _var_type; #endif /* __GNUC__ */ // Useful for template programming. @@ -880,7 +855,6 @@ public: ~CORBA_NameValuePairSeq (void); // dtor #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8 - typedef CORBA_NameValuePairSeq_ptr _ptr_type; typedef CORBA_NameValuePairSeq_var _var_type; #endif /* __GNUC__ */ // Useful for template programming. @@ -1365,7 +1339,6 @@ public: ~CORBA_AnySeq (void); // dtor #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8 - typedef CORBA_AnySeq_ptr _ptr_type; typedef CORBA_AnySeq_var _var_type; #endif /* __GNUC__ */ diff --git a/TAO/tao/DynAny_i.cpp b/TAO/tao/DynAny_i.cpp index 31e4c676080..0df5b4fda22 100644 --- a/TAO/tao/DynAny_i.cpp +++ b/TAO/tao/DynAny_i.cpp @@ -424,18 +424,17 @@ TAO_DynAny_i::insert_reference (CORBA::Object_ptr value, if (kind == CORBA::tk_objref) { - CORBA::Object_ptr *_tao_object_ptr; - - ACE_NEW (_tao_object_ptr, - CORBA::Object_ptr); - - *_tao_object_ptr = CORBA::Object::_duplicate (value); - - this->value_.replace (this->value_.type (), - (void*)_tao_object_ptr, - 1, - ACE_TRY_ENV); - ACE_CHECK; + CORBA::Object_var obj = CORBA::Object::_duplicate (value); + + TAO_OutputCDR stream; + if (!(stream << obj.in ())) + ACE_THROW (CORBA::MARSHAL ()); + this->value_._tao_replace (this->value_.type (), + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + obj._retn (), + CORBA::Object::_tao_any_destructor); } else { @@ -668,12 +667,11 @@ TAO_DynAny_i::get_double (CORBA::Environment &ACE_TRY_ENV) char * TAO_DynAny_i::get_string (CORBA::Environment &ACE_TRY_ENV) { - CORBA::Char *val; + const char *val; if (!(this->value_ >>= val)) { - ACE_THROW_RETURN (CORBA_DynAny::TypeMismatch (), - val); + ACE_THROW_RETURN (CORBA_DynAny::TypeMismatch (), 0); } return CORBA::string_dup (val); diff --git a/TAO/tao/Exception.cpp b/TAO/tao/Exception.cpp index 5525bad34a6..2fdf002a071 100644 --- a/TAO/tao/Exception.cpp +++ b/TAO/tao/Exception.cpp @@ -661,22 +661,20 @@ TAO_Exceptions::make_unknown_user_typecode (CORBA::TypeCode_ptr &tcp, || stream.write_string (interface_id) == 0 || stream.write_string (name) == 0 || stream.write_ulong (1L) == 0 - || stream.write_string (field_name) == 0 - || stream.encode (CORBA::_tc_TypeCode, - &CORBA::_tc_any, 0, - ACE_TRY_ENV) != CORBA::TypeCode::TRAVERSE_CONTINUE; - ACE_CHECK; - + || stream.write_string (field_name) == 0; if (result) ACE_THROW (CORBA_INITIALIZE ()); + if (!(stream << CORBA::_tc_any)) + ACE_THROW (CORBA_INITIALIZE ()); + ACE_NEW_THROW_EX (tcp, CORBA::TypeCode (CORBA::tk_except, stream.length (), stream.buffer (), 1, sizeof (CORBA_UserException)), - CORBA_NO_MEMORY ()); + CORBA_INITIALIZE ()); } void @@ -737,19 +735,14 @@ TAO_Exceptions::make_standard_typecode (CORBA::TypeCode_ptr &tcp, || stream.write_string (full_id) == 0 || stream.write_string (name) == 0 || stream.write_ulong (2L) != 1 - || stream.write_string (minor) == 0 - || stream.encode (CORBA::_tc_TypeCode, - &CORBA::_tc_ulong, 0, - ACE_TRY_ENV) != CORBA::TypeCode::TRAVERSE_CONTINUE; - ACE_CHECK; // @@ Maybe we should transform this exception + || stream.write_string (minor) == 0; + + result = result || !(stream << CORBA::_tc_ulong); CORBA::string_free (full_id); // No longer need the string - result = result || stream.write_string (completed) == 0 - || stream.encode (CORBA::_tc_TypeCode, - &TC_completion_status, 0, - ACE_TRY_ENV) != CORBA::TypeCode::TRAVERSE_CONTINUE; - ACE_CHECK; // @@ Maybe we should transform this exception + result = result || stream.write_string (completed) == 0; + result = result || !(stream << TC_completion_status); if (result) ACE_THROW (CORBA::INITIALIZE ()); @@ -768,7 +761,7 @@ TAO_Exceptions::make_standard_typecode (CORBA::TypeCode_ptr &tcp, stream.buffer (), 1, sizeof (CORBA_SystemException)), - CORBA_NO_MEMORY ()); + CORBA_INITIALIZE ()); ACE_CHECK; TAO_Exceptions::system_exceptions->add (tcp); diff --git a/TAO/tao/Forwarding_Servant.cpp b/TAO/tao/Forwarding_Servant.cpp index bd2ae762d23..54f7e33fc33 100644 --- a/TAO/tao/Forwarding_Servant.cpp +++ b/TAO/tao/Forwarding_Servant.cpp @@ -22,19 +22,12 @@ void TAO_Forwarding_Servant::invoke (CORBA::ServerRequest_ptr request, CORBA::Environment &ACE_TRY_ENV) { - ACE_UNUSED_ARG (request); + PortableServer::ForwardRequest exception (this->forward_to_.in ()); - CORBA::Exception *exception = 0; - ACE_NEW_THROW_EX (exception, - PortableServer::ForwardRequest (this->forward_to_.in ()), - CORBA::NO_MEMORY ()); + CORBA::Any any; + any <<= exception; - CORBA::Any any (exception->_type (), - exception, - 1); - - request->set_exception (any, - ACE_TRY_ENV); + request->set_exception (any, ACE_TRY_ENV); } CORBA::RepositoryId diff --git a/TAO/tao/GIOPC.cpp b/TAO/tao/GIOPC.cpp index 2d173c1e2e3..e99104e1975 100644 --- a/TAO/tao/GIOPC.cpp +++ b/TAO/tao/GIOPC.cpp @@ -346,54 +346,36 @@ TAO_NAMESPACE_BEGIN (GIOP) TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_TargetAddress, &_tc_TAO_tc_GIOP_TargetAddress) TAO_NAMESPACE_END +void +GIOP::IORAddressingInfo::_tao_any_destructor (void *x) +{ + GIOP::IORAddressingInfo *tmp = ACE_static_cast (GIOP::IORAddressingInfo*,x); + delete tmp; +} + void operator<<= (CORBA::Any &_tao_any, const GIOP::IORAddressingInfo &_tao_elem) // copying { - GIOP::IORAddressingInfo *_any_val = 0; - ACE_NEW (_any_val, GIOP::IORAddressingInfo (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { - 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 - { - delete _any_val; - } - ACE_ENDTRY; + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + GIOP::_tc_IORAddressingInfo, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); } void operator<<= (CORBA::Any &_tao_any, GIOP::IORAddressingInfo *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { - 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 - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + GIOP::_tc_IORAddressingInfo, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + GIOP::IORAddressingInfo::_tao_any_destructor + ); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, GIOP::IORAddressingInfo *&_tao_elem) @@ -425,9 +407,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, GIOP::IORAddressingInfo GIOP::_tc_IORAddressingInfo, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + GIOP::IORAddressingInfo::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -441,7 +422,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, GIOP::IORAddressingInfo { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -449,53 +430,14 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, GIOP::IORAddressingInfo 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; + return _tao_any >>= ACE_const_cast(GIOP::IORAddressingInfo*&,_tao_elem); +} + +void +GIOP::TargetAddress::_tao_any_destructor (void *x) +{ + GIOP::TargetAddress *tmp = ACE_static_cast (GIOP::TargetAddress*,x); + delete tmp; } void operator<<= ( @@ -503,33 +445,15 @@ void operator<<= ( const GIOP::TargetAddress &_tao_elem ) { - GIOP::TargetAddress *_any_val = 0; - ACE_NEW (_any_val, GIOP::TargetAddress (_tao_elem)); - ACE_TRY_NEW_ENV - { - TAO_OutputCDR stream; - if (stream << *_any_val) + TAO_OutputCDR stream; + if (stream << _tao_elem) { _tao_any._tao_replace ( GIOP::_tc_TargetAddress, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _any_val; } - } - ACE_CATCHANY - { - delete _any_val; - } - ACE_ENDTRY; } void operator<<= ( @@ -537,10 +461,8 @@ void operator<<= ( GIOP::TargetAddress *_tao_elem ) { - ACE_TRY_NEW_ENV - { - TAO_OutputCDR stream; - if (stream << *_tao_elem) + TAO_OutputCDR stream; + if (stream << *_tao_elem) { _tao_any._tao_replace ( GIOP::_tc_TargetAddress, @@ -548,21 +470,9 @@ void operator<<= ( stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + GIOP::IORAddressingInfo::_tao_any_destructor ); - ACE_TRY_CHECK; - } - else - { - delete _tao_elem; } - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= ( @@ -591,16 +501,15 @@ CORBA::Boolean operator>>= ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); - + if (stream >> *_tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( GIOP::_tc_TargetAddress, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + GIOP::IORAddressingInfo::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -624,53 +533,5 @@ CORBA::Boolean operator>>= ( 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 ACE_const_cast (GIOP::TargetAddress *&, _tao_elem); - _tao_elem = 0; - } - ACE_ENDTRY; - return 0; + return _tao_any >>= ACE_const_cast (GIOP::TargetAddress*&,_tao_elem); } - - diff --git a/TAO/tao/GIOPC.h b/TAO/tao/GIOPC.h index 89df16d6a7a..e3f5d36dcb7 100644 --- a/TAO/tao/GIOPC.h +++ b/TAO/tao/GIOPC.h @@ -81,7 +81,7 @@ TAO_NAMESPACE GIOP struct IORAddressingInfo; class IORAddressingInfo_var; typedef IORAddressingInfo* IORAddressingInfo_ptr; - + struct TAO_Export IORAddressingInfo { @@ -89,6 +89,7 @@ TAO_NAMESPACE GIOP typedef IORAddressingInfo_ptr _ptr_type; typedef IORAddressingInfo_var _var_type; #endif /* ! __GNUC__ || g++ >= 2.8 */ + static void _tao_any_destructor (void*); CORBA::ULong selected_profile_index; IOP::IOR ior; @@ -101,16 +102,16 @@ TAO_NAMESPACE GIOP IORAddressingInfo_var (IORAddressingInfo *); IORAddressingInfo_var (const IORAddressingInfo_var &); // copy constructor ~IORAddressingInfo_var (void); // destructor - + IORAddressingInfo_var &operator= (IORAddressingInfo *); IORAddressingInfo_var &operator= (const IORAddressingInfo_var &); IORAddressingInfo *operator-> (void); const IORAddressingInfo *operator-> (void) const; - + operator const IORAddressingInfo &() const; operator IORAddressingInfo &(); operator IORAddressingInfo &() const; - // in, inout, out, _retn + // in, inout, out, _retn const IORAddressingInfo &in (void) const; IORAddressingInfo &inout (void); IORAddressingInfo *&out (void); @@ -132,7 +133,7 @@ TAO_NAMESPACE GIOP operator IORAddressingInfo *&(); IORAddressingInfo *&ptr (void); IORAddressingInfo *operator-> (void); - + private: IORAddressingInfo *&ptr_; // assignment from T_var not allowed @@ -142,14 +143,11 @@ TAO_NAMESPACE GIOP TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_IORAddressingInfo; -#if !defined (_GIOP_TARGETADDRESS_CH_) -#define _GIOP_TARGETADDRESS_CH_ - class TargetAddress; class TargetAddress_var; typedef TargetAddress* TargetAddress_ptr; - - class TAO_Export TargetAddress: public TAO_Base_Union + + class TAO_Export TargetAddress: public TAO_Base_Union { public: TargetAddress (void); // default constructor @@ -164,6 +162,8 @@ TAO_NAMESPACE GIOP typedef TargetAddress_ptr _ptr_type; typedef TargetAddress_var _var_type; #endif /* ! __GNUC__ || g++ >= 2.8 */ + static void _tao_any_destructor (void*); + void object_key (const TAO_ObjectKey &);// set const TAO_ObjectKey &object_key (void) const; // get method (read only) @@ -172,11 +172,11 @@ TAO_NAMESPACE GIOP void profile (const IOP::TaggedProfile &);// set const IOP::TaggedProfile &profile (void) const; // get method (read only) IOP::TaggedProfile &profile (void); // get method (read/write only) - + void ior (const ACE_NESTED_CLASS (GIOP, IORAddressingInfo) &);// set const ACE_NESTED_CLASS (GIOP, IORAddressingInfo) &ior (void) const; // get method (read only) ACE_NESTED_CLASS (GIOP, IORAddressingInfo) &ior (void); // get method (read/write only) - + void _default (); private: CORBA::Short disc_; @@ -189,27 +189,20 @@ TAO_NAMESPACE GIOP // TAO extensions void _reset (CORBA::Short, CORBA::Boolean); // Frees any allocated storage - + virtual void *_discriminant (void); // returns pointer to the discriminant - + virtual void _reset (void); // calls the above reset with finalize=1 - + virtual void *_access (CORBA::Boolean flag); // accesses the right data member. Also will allocate on TRUE flag - + }; // GIOP::TargetAddress TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_TargetAddress; - -#endif /* end #if !defined */ - - -#if !defined (_GIOP_TARGETADDRESS___VAR_CH_) -#define _GIOP_TARGETADDRESS___VAR_CH_ - class TAO_Export TargetAddress_var { public: @@ -217,16 +210,16 @@ public: TargetAddress_var (TargetAddress *); TargetAddress_var (const TargetAddress_var &); // copy constructor ~TargetAddress_var (void); // destructor - + TargetAddress_var &operator= (TargetAddress *); TargetAddress_var &operator= (const TargetAddress_var &); TargetAddress *operator-> (void); const TargetAddress *operator-> (void) const; - + operator const TargetAddress &() const; operator TargetAddress &(); operator TargetAddress &() const; - // in, inout, out, _retn + // in, inout, out, _retn const TargetAddress &in (void) const; TargetAddress &inout (void); TargetAddress *&out (void); @@ -237,13 +230,6 @@ private: TargetAddress *ptr_; }; - -#endif /* end #if !defined */ - - -#if !defined (_GIOP_TARGETADDRESS___OUT_CH_) -#define _GIOP_TARGETADDRESS___OUT_CH_ - class TAO_Export TargetAddress_out { public: @@ -255,7 +241,7 @@ public: operator TargetAddress *&(); TargetAddress *&ptr (void); TargetAddress *operator-> (void); - + private: TargetAddress *&ptr_; // assignment from T_var not allowed @@ -263,34 +249,31 @@ private: }; -#endif /* end #if !defined */ - - } TAO_NAMESPACE_CLOSE // module GIOP -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const GIOP::IORAddressingInfo &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, GIOP::IORAddressingInfo*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, GIOP::IORAddressingInfo *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const GIOP::IORAddressingInfo *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const GIOP::TargetAddress &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, GIOP::TargetAddress*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, GIOP::TargetAddress *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const GIOP::TargetAddress *&); #ifndef __ACE_INLINE__ TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const GIOP::IORAddressingInfo &); TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, GIOP::IORAddressingInfo &); -TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const GIOP::TargetAddress &); // +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const GIOP::TargetAddress &); // TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, GIOP::TargetAddress &); #endif /* __ACE_INLINE__ */ diff --git a/TAO/tao/GIOP_Server_Request.cpp b/TAO/tao/GIOP_Server_Request.cpp index 66132ec48db..ae12a690a93 100644 --- a/TAO/tao/GIOP_Server_Request.cpp +++ b/TAO/tao/GIOP_Server_Request.cpp @@ -50,19 +50,19 @@ TAO_GIOP_ServerRequest:: TAO_OutputCDR &output, TAO_ORB_Core *orb_core, const TAO_GIOP_Version &version) - :mesg_base_ (mesg_base), + :mesg_base_ (mesg_base), incoming_ (&input), outgoing_ (&output), response_expected_ (0), sync_with_server_ (0), lazy_evaluation_ (0), - + #if !defined (TAO_HAS_MINIMUM_CORBA) - + params_ (0), - + #endif /* TAO_HAS_MINIMUM_CORBA */ - + retval_ (0), exception_ (0), exception_type_ (TAO_GIOP_NO_EXCEPTION), @@ -96,13 +96,13 @@ TAO_GIOP_ServerRequest:: response_expected_ (response_expected), sync_with_server_ (0), lazy_evaluation_ (0), - + #if !defined (TAO_HAS_MINIMUM_CORBA) - + params_ (0), - + #endif /* TAO_HAS_MINIMUM_CORBA */ - + retval_ (0), exception_ (0), exception_type_ (TAO_GIOP_NO_EXCEPTION), @@ -265,9 +265,9 @@ TAO_GIOP_ServerRequest::dsi_marshal (CORBA::Environment &ACE_TRY_ENV) CORBA::TypeCode_var tc = this->retval_->type (); if (this->retval_->any_owns_data ()) { - (void) this->outgoing_->encode (tc.in (), - retval_->value (), - 0, ACE_TRY_ENV); + this->retval_->_tao_encode (*this->outgoing_, + this->orb_core_, + ACE_TRY_ENV); ACE_CHECK; } else @@ -294,132 +294,6 @@ TAO_GIOP_ServerRequest::dsi_marshal (CORBA::Environment &ACE_TRY_ENV) #endif /* TAO_HAS_MINIMUM_CORBA */ -// Extension -void -TAO_GIOP_ServerRequest::demarshal (CORBA::Environment &ACE_TRY_ENV, - // ORB related exception reporting - const TAO_Call_Data_Skel *info, - // call description - ...) -{ - CORBA::ULong i; - const TAO_Param_Data_Skel *pdp; - va_list param_vector; - va_start (param_vector, info); - - for (i = 0, pdp = info->params; - i < info->param_count; - i++, pdp++) - { - void *ptr = va_arg (param_vector, void *); - - if ((pdp->mode == CORBA::ARG_IN) - || (pdp->mode == CORBA::ARG_INOUT)) - { - // Then just unmarshal the value. - (void) incoming_->decode (pdp->tc, ptr, 0, ACE_TRY_ENV); - ACE_CHECK; - } - } - va_end (param_vector); -} - -// Extension - -void -TAO_GIOP_ServerRequest::marshal (CORBA::Environment &ACE_TRY_ENV, - // ORB related exception reporting - // CORBA::Environment &skel_env, - // skeleton related exception reporting - const TAO_Call_Data_Skel *info, - // call description - ...) -{ - // what is "ACE_TRY_ENV" and "skel_env"? - // "skel_env" holds the exception that got raised inside the operation - // implementation (upcall) - // - // "orb_env" is the exception that may have been raised due to things going - // wrong in the entire dispatch process. These are always system exceptions. - - // check if we are inside with an exception. This may have happened - // since the upcall could have set some exception -#if 0 /* ASG */ - if (skel_env.exception ()) - { - // We must increase the "refcnt" on the exception, because it is - // "owned" by both <skel_env> and (eventually) by the - // Server_Request. - CORBA::Exception_ptr exception = skel_env.exception (); - exception->_incr_refcnt (); - - // The Any does not own the because ultimately it will be owned - // by the Server_Request via the call to "set_exception" - CORBA::Any any (skel_env.exception ()->_type (), exception); - this->set_exception (any, ACE_TRY_ENV); - } -#endif - - // Setup a Reply message so that we can marshal all the outgoing parameters - // into it. If an exception was set, then that gets marshaled into the reply - // message and we don't do anything after that - this->init_reply (ACE_TRY_ENV); - ACE_CHECK; - -#if 0 /* ASG */ - // exception? nothing to do after this - if (orb_env.exception () || skel_env.exception ()) - return; - ACE_CHECK; -#endif - - CORBA::ULong i; - const TAO_Param_Data_Skel *pdp; - va_list param_vector; - va_start (param_vector, info); - - ACE_TRY - { - for (i = 0, pdp = info->params; - i < info->param_count; - i++, pdp++) - { - void *ptr = va_arg (param_vector, void *); - - if (pdp->mode == 0) - { - // check if the return type is not void - CORBA::TCKind result = pdp->tc->kind (ACE_TRY_ENV); - ACE_TRY_CHECK; - if (result != CORBA::tk_void) - { - // Then just marshal the value. - (void) this->outgoing_->encode (pdp->tc, ptr, 0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - } - } - else if ((pdp->mode == CORBA::ARG_INOUT) - || (pdp->mode == CORBA::ARG_OUT)) - { - // Then just marshal the value. - (void) this->outgoing_->encode (pdp->tc, ptr, 0, ACE_TRY_ENV); - ACE_TRY_CHECK; - } - } - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "TAO_GIOP_ServerRequest::marshal - parameter encode failed"); - ACE_RETHROW; - } - ACE_ENDTRY; - ACE_CHECK; - - va_end (param_vector); -} - void TAO_GIOP_ServerRequest::init_reply (CORBA::Environment &ACE_TRY_ENV) { @@ -598,7 +472,7 @@ TAO_GIOP_ServerRequest::send_no_exception_reply (TAO_Transport *transport) int result = this->mesg_base_->send_message (transport, *this->outgoing_); - + if (result == -1) { diff --git a/TAO/tao/GIOP_Server_Request.h b/TAO/tao/GIOP_Server_Request.h index 9534bd8ca80..c0eb1e444bb 100644 --- a/TAO/tao/GIOP_Server_Request.h +++ b/TAO/tao/GIOP_Server_Request.h @@ -46,7 +46,7 @@ public: TAO_OutputCDR &output, TAO_ORB_Core *orb_core, const TAO_GIOP_Version &version); - + // Constructor TAO_GIOP_ServerRequest (TAO_Pluggable_Messaging *mesg_base, CORBA::ULong &request_id, @@ -94,8 +94,8 @@ public: void operation (const char * name, int release); // set the operation name - - + + unsigned int operation_length (void) const; // return the legnth of the operation @@ -115,19 +115,6 @@ public: // meant to be used internally. // - virtual void demarshal (CORBA_Environment &ACE_TRY_ENV, - const TAO_Call_Data_Skel *info, - ...); - // demarshal incoming parameters. Used by the SII skeleton (i.e., the IDL - // compiler generated skeleton) - - virtual void marshal (CORBA_Environment &ACE_TRY_ENV, - // CORBA_Environment &skel_env, - const TAO_Call_Data_Skel *info, - ...); - // marshal outgoing parameters and return value. This is used by the SSI - // i.e., by the IDL compiler generated skeletons. - virtual void init_reply (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); // start a Reply message @@ -193,7 +180,7 @@ public: private: TAO_Pluggable_Messaging *mesg_base_; - + ACE_CString operation_; // Operation name. diff --git a/TAO/tao/IIOP_Profile.cpp b/TAO/tao/IIOP_Profile.cpp index 691c49cca2d..351a4d5dd58 100644 --- a/TAO/tao/IIOP_Profile.cpp +++ b/TAO/tao/IIOP_Profile.cpp @@ -182,7 +182,7 @@ TAO_IIOP_Profile::decode (TAO_InputCDR& cdr) return -1; } - if (this->object_addr_.set (this->port_, + if (this->object_addr_.set (this->port_, this->host_.in ()) == -1) { if (TAO_debug_level > 0) @@ -311,7 +311,7 @@ TAO_IIOP_Profile::parse_string (const char *string, this->host_ = tmp._retn (); - if (this->object_addr_.set (this->port_, + if (this->object_addr_.set (this->port_, this->host_.in ()) == -1) { if (TAO_debug_level > 0) @@ -409,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_Transport.h b/TAO/tao/IIOP_Transport.h index da1876ee421..89d6f1ba39f 100644 --- a/TAO/tao/IIOP_Transport.h +++ b/TAO/tao/IIOP_Transport.h @@ -85,7 +85,7 @@ public: int twoway, ACE_Time_Value *max_wait_time); - virtual CORBA::Boolean + virtual CORBA::Boolean send_request_header (TAO_Operation_Details &opdetails, TAO_Target_Specification &spec, TAO_OutputCDR &msg); @@ -125,7 +125,7 @@ public: TAO_OutputCDR &output, CORBA::Environment &ACE_TRY_ENV = TAO_default_environment ()) ACE_THROW_SPEC ((CORBA::SystemException)); - + virtual void start_locate (TAO_ORB_Core *orb_core, TAO_Target_Specification &spec, TAO_Operation_Details &opdetails, @@ -143,10 +143,10 @@ public: ACE_Time_Value *max_time_value = 0); virtual int register_handler (void); - virtual CORBA::Boolean + virtual CORBA::Boolean send_request_header (TAO_Operation_Details &opdetails, TAO_Target_Specification &spec, - TAO_OutputCDR &msg); + TAO_OutputCDR &msg); int messaging_init (CORBA::Octet major, CORBA::Octet minor); @@ -161,13 +161,13 @@ private: TAO_Pluggable_Messaging *client_mesg_factory_; // The message_factor instance specific for this particular // transport protocol. - + TAO_ORB_Core *orb_core_; // Our ORB core CORBA::Boolean lite_flag_; // Are we using lite? - + TAO_Pluggable_Reply_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 226f26aab0b..c1b4f298d60 100644 --- a/TAO/tao/IOPC.cpp +++ b/TAO/tao/IOPC.cpp @@ -538,34 +538,23 @@ 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 = 0; - ACE_NEW (_any_val, IOP::TaggedProfile (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_any_val; + stream << _tao_elem; _tao_any._tao_replace ( IOP::_tc_TaggedProfile, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _any_val; - } - ACE_ENDTRY; +} + +void IOP::TaggedProfile::_tao_any_destructor (void *x) +{ + IOP::TaggedProfile *tmp = ACE_static_cast(IOP::TaggedProfile*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, IOP::TaggedProfile *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -574,16 +563,8 @@ void operator<<= (CORBA::Any &_tao_any, IOP::TaggedProfile *_tao_elem) // non co stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + IOP::TaggedProfile::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::TaggedProfile *&_tao_elem) @@ -615,9 +596,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::TaggedProfile *&_ta IOP::_tc_TaggedProfile, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + IOP::TaggedProfile::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -631,7 +611,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::TaggedProfile *&_ta { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -666,9 +646,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IOP::TaggedProfile IOP::_tc_TaggedProfile, 1, ACE_reinterpret_cast (void *, ACE_const_cast (IOP::TaggedProfile *&, _tao_elem)), - ACE_TRY_ENV + IOP::TaggedProfile::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -682,7 +661,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IOP::TaggedProfile { delete ACE_const_cast (IOP::TaggedProfile *&, _tao_elem); _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -690,34 +669,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IOP::TaggedProfile void operator<<= (CORBA::Any &_tao_any, const IOP::IOR &_tao_elem) // copying { - IOP::IOR *_any_val = 0; - ACE_NEW (_any_val, IOP::IOR (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_any_val; + stream << _tao_elem; _tao_any._tao_replace ( IOP::_tc_IOR, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _any_val; - } - ACE_ENDTRY; +} + +void IOP::IOR::_tao_any_destructor (void *x) +{ + IOP::IOR *tmp = ACE_static_cast(IOP::IOR*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, IOP::IOR *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -726,16 +694,8 @@ void operator<<= (CORBA::Any &_tao_any, IOP::IOR *_tao_elem) // non copying stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + IOP::IOR::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::IOR *&_tao_elem) @@ -767,9 +727,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::IOR *&_tao_elem) IOP::_tc_IOR, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + IOP::IOR::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -783,7 +742,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::IOR *&_tao_elem) { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -818,9 +777,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IOP::IOR *&_tao_el IOP::_tc_IOR, 1, ACE_reinterpret_cast (void *, ACE_const_cast (IOP::IOR *&, _tao_elem)), - ACE_TRY_ENV + IOP::IOR::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -834,7 +792,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IOP::IOR *&_tao_el { delete ACE_const_cast (IOP::IOR *&, _tao_elem); _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -842,34 +800,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IOP::IOR *&_tao_el void operator<<= (CORBA::Any &_tao_any, const IOP::TaggedComponent &_tao_elem) // copying { - IOP::TaggedComponent *_any_val = 0; - ACE_NEW (_any_val, IOP::TaggedComponent (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_any_val; + stream << _tao_elem; _tao_any._tao_replace ( IOP::_tc_TaggedComponent, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _any_val; - } - ACE_ENDTRY; +} + +void IOP::TaggedComponent::_tao_any_destructor (void *x) +{ + IOP::TaggedComponent *tmp = ACE_static_cast(IOP::TaggedComponent*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, IOP::TaggedComponent *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -878,16 +825,8 @@ void operator<<= (CORBA::Any &_tao_any, IOP::TaggedComponent *_tao_elem) // non stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + IOP::TaggedComponent::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::TaggedComponent *&_tao_elem) @@ -919,9 +858,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::TaggedComponent *&_ IOP::_tc_TaggedComponent, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + IOP::TaggedComponent::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -935,7 +873,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::TaggedComponent *&_ { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -970,9 +908,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IOP::TaggedCompone IOP::_tc_TaggedComponent, 1, ACE_reinterpret_cast (void *, ACE_const_cast (IOP::TaggedComponent *&, _tao_elem)), - ACE_TRY_ENV + IOP::TaggedComponent::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -986,7 +923,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IOP::TaggedCompone { delete ACE_const_cast (IOP::TaggedComponent *&, _tao_elem); _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -997,40 +934,25 @@ void operator<<= ( const IOP::MultipleComponentProfile &_tao_elem ) // copying { - IOP::MultipleComponentProfile *_tao_any_val; - ACE_NEW (_tao_any_val, IOP::MultipleComponentProfile (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - if (stream << *_tao_any_val) + if (stream << _tao_elem) { _tao_any._tao_replace ( IOP::_tc_MultipleComponentProfile, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_any_val; } - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void IOP::MultipleComponentProfile::_tao_any_destructor (void *x) +{ + IOP::MultipleComponentProfile *tmp = ACE_static_cast(IOP::MultipleComponentProfile*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, IOP::MultipleComponentProfile *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -1039,16 +961,8 @@ void operator<<= (CORBA::Any &_tao_any, IOP::MultipleComponentProfile *_tao_elem stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + IOP::MultipleComponentProfile::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::MultipleComponentProfile *&_tao_elem) @@ -1080,9 +994,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::MultipleComponentPr IOP::_tc_MultipleComponentProfile, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + IOP::MultipleComponentProfile::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -1096,7 +1009,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::MultipleComponentPr { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -1131,9 +1044,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IOP::MultipleCompo IOP::_tc_MultipleComponentProfile, 1, ACE_reinterpret_cast (void *, ACE_const_cast (IOP::MultipleComponentProfile *&, _tao_elem)), - ACE_TRY_ENV + IOP::MultipleComponentProfile::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -1147,7 +1059,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IOP::MultipleCompo { delete ACE_const_cast (IOP::MultipleComponentProfile *&, _tao_elem); _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -1155,34 +1067,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IOP::MultipleCompo void operator<<= (CORBA::Any &_tao_any, const IOP::ServiceContext &_tao_elem) // copying { - IOP::ServiceContext *_any_val = 0; - ACE_NEW (_any_val, IOP::ServiceContext (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_any_val; + stream << _tao_elem; _tao_any._tao_replace ( IOP::_tc_ServiceContext, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _any_val; - } - ACE_ENDTRY; +} + +void IOP::ServiceContext::_tao_any_destructor (void *x) +{ + IOP::ServiceContext *tmp = ACE_static_cast(IOP::ServiceContext*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, IOP::ServiceContext *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -1191,16 +1092,8 @@ void operator<<= (CORBA::Any &_tao_any, IOP::ServiceContext *_tao_elem) // non c stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + IOP::ServiceContext::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::ServiceContext *&_tao_elem) @@ -1232,9 +1125,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::ServiceContext *&_t IOP::_tc_ServiceContext, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + IOP::ServiceContext::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -1248,7 +1140,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::ServiceContext *&_t { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -1283,9 +1175,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IOP::ServiceContex IOP::_tc_ServiceContext, 1, ACE_reinterpret_cast (void *, ACE_const_cast (IOP::ServiceContext *&, _tao_elem)), - ACE_TRY_ENV + IOP::ServiceContext::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -1299,7 +1190,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IOP::ServiceContex { delete ACE_const_cast (IOP::ServiceContext *&, _tao_elem); _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -1310,40 +1201,25 @@ void operator<<= ( const IOP::ServiceContextList &_tao_elem ) // copying { - IOP::ServiceContextList *_tao_any_val; - ACE_NEW (_tao_any_val, IOP::ServiceContextList (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - if (stream << *_tao_any_val) + if (stream << _tao_elem) { _tao_any._tao_replace ( IOP::_tc_ServiceContextList, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_any_val; - } - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void IOP::ServiceContextList::_tao_any_destructor (void *x) +{ + IOP::ServiceContextList *tmp = ACE_static_cast(IOP::ServiceContextList*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, IOP::ServiceContextList *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -1352,16 +1228,8 @@ void operator<<= (CORBA::Any &_tao_any, IOP::ServiceContextList *_tao_elem) // n stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + IOP::ServiceContextList::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::ServiceContextList *&_tao_elem) @@ -1393,9 +1261,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::ServiceContextList IOP::_tc_ServiceContextList, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + IOP::ServiceContextList::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -1409,7 +1276,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::ServiceContextList { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -1444,9 +1311,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IOP::ServiceContex IOP::_tc_ServiceContextList, 1, ACE_reinterpret_cast (void *, ACE_const_cast (IOP::ServiceContextList *&, _tao_elem)), - ACE_TRY_ENV + IOP::ServiceContextList::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -1460,7 +1326,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IOP::ServiceContex { delete ACE_const_cast (IOP::ServiceContextList *&, _tao_elem); _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; diff --git a/TAO/tao/IOPC.h b/TAO/tao/IOPC.h index 37e230be8df..d680f9981f7 100644 --- a/TAO/tao/IOPC.h +++ b/TAO/tao/IOPC.h @@ -54,6 +54,8 @@ TAO_NAMESPACE IOP struct TAO_Export TaggedProfile { + static void _tao_any_destructor (void*); + ProfileId tag; class TAO_Export _tao_seq_Octet : public TAO_Unbounded_Sequence<CORBA::Octet> @@ -132,6 +134,8 @@ TAO_NAMESPACE IOP struct TAO_Export IOR { + static void _tao_any_destructor (void*); + TAO_String_Manager type_id; @@ -211,6 +215,8 @@ TAO_NAMESPACE IOP struct TAO_Export TaggedComponent { + static void _tao_any_destructor (void*); + ComponentId tag; class TAO_Export _tao_seq_Octet : public TAO_Unbounded_Sequence<CORBA::Octet> @@ -301,6 +307,8 @@ TAO_NAMESPACE IOP ); MultipleComponentProfile (const MultipleComponentProfile &); // copy ctor ~MultipleComponentProfile (void); // dtor + + static void _tao_any_destructor (void*); }; typedef MultipleComponentProfile *MultipleComponentProfile_ptr; @@ -405,6 +413,8 @@ TAO_NAMESPACE IOP struct TAO_Export ServiceContext { + static void _tao_any_destructor (void*); + ServiceId context_id; // ************************************************************* @@ -499,6 +509,8 @@ TAO_NAMESPACE IOP ); ServiceContextList (const ServiceContextList &); // copy ctor ~ServiceContextList (void); // dtor + + static void _tao_any_destructor (void*); }; typedef ServiceContextList *ServiceContextList_ptr; @@ -576,53 +588,53 @@ TAO_NAMESPACE IOP } TAO_NAMESPACE_CLOSE // module IOP -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const IOP::TaggedProfile &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, IOP::TaggedProfile*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IOP::TaggedProfile *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IOP::TaggedProfile *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const IOP::IOR &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, IOP::IOR*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IOP::IOR *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IOP::IOR *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const IOP::TaggedComponent &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, IOP::TaggedComponent*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IOP::TaggedComponent *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IOP::TaggedComponent *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const IOP::MultipleComponentProfile &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, IOP::MultipleComponentProfile*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IOP::MultipleComponentProfile *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IOP::MultipleComponentProfile *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const IOP::ServiceContext &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, IOP::ServiceContext*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IOP::ServiceContext *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IOP::ServiceContext *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const IOP::ServiceContextList &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, IOP::ServiceContextList*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IOP::ServiceContextList *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IOP::ServiceContextList *&); diff --git a/TAO/tao/IORC.cpp b/TAO/tao/IORC.cpp index a4ac85e380b..659ccd25469 100644 --- a/TAO/tao/IORC.cpp +++ b/TAO/tao/IORC.cpp @@ -462,47 +462,31 @@ TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_TAO_IOR_Manipulation, &_tc_TAO_tc TAO_NAMESPACE_END void operator<<= (CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipulation_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 = TAO_IOP::TAO_IOR_Manipulation::_duplicate (_tao_elem); TAO_OutputCDR stream; - if (stream << *_tao_obj_ptr) + if (stream << _tao_elem) { _tao_any._tao_replace ( - TAO_IOP::_tc_TAO_IOR_Manipulation, + TAO_IOP::_tc_TAO_IOR_Manipulation, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void TAO_IOP::TAO_IOR_Manipulation::_tao_any_destructor (void *x) +{ + TAO_IOP::TAO_IOR_Manipulation *tmp = ACE_static_cast(TAO_IOP::TAO_IOR_Manipulation*,x); + CORBA::release (tmp); } 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->equivalent (TAO_IOP::_tc_TAO_IOR_Manipulation, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -517,24 +501,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul { _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)->_tao_replace ( TAO_IOP::_tc_TAO_IOR_Manipulation, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + TAO_IOP::TAO_IOR_Manipulation::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = TAO_IOP::TAO_IOR_Manipulation::_nil (); return 0; } @@ -554,34 +531,23 @@ 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 = 0; - ACE_NEW (_tao_any_val, TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_tao_any_val; + stream << _tao_elem; _tao_any._tao_replace ( TAO_IOP::TAO_IOR_Manipulation::_tc_EmptyProfileList, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList::_tao_any_destructor (void *x) +{ + TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList *tmp = ACE_static_cast(TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -590,16 +556,8 @@ void operator<<= (CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipulation::EmptyProf stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList *&_tao_elem) @@ -631,9 +589,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul TAO_IOP::TAO_IOR_Manipulation::_tc_EmptyProfileList, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -647,7 +604,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -655,85 +612,28 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul 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; + return _tao_any >>= ACE_const_cast(TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList *&,_tao_elem); } 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 = 0; - ACE_NEW (_tao_any_val, TAO_IOP::TAO_IOR_Manipulation::NotFound (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_tao_any_val; + stream << _tao_elem; _tao_any._tao_replace ( TAO_IOP::TAO_IOR_Manipulation::_tc_NotFound, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void TAO_IOP::TAO_IOR_Manipulation::NotFound::_tao_any_destructor (void *x) +{ + TAO_IOP::TAO_IOR_Manipulation::NotFound *tmp = ACE_static_cast(TAO_IOP::TAO_IOR_Manipulation::NotFound*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipulation::NotFound *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -742,16 +642,8 @@ void operator<<= (CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipulation::NotFound stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + TAO_IOP::TAO_IOR_Manipulation::NotFound::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipulation::NotFound *&_tao_elem) @@ -783,9 +675,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul TAO_IOP::TAO_IOR_Manipulation::_tc_NotFound, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + TAO_IOP::TAO_IOR_Manipulation::NotFound::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -799,7 +690,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -807,85 +698,28 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul 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; + return _tao_any >>= ACE_const_cast(TAO_IOP::TAO_IOR_Manipulation::NotFound *&,_tao_elem); } 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 = 0; - ACE_NEW (_tao_any_val, TAO_IOP::TAO_IOR_Manipulation::Duplicate (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_tao_any_val; + stream << _tao_elem; _tao_any._tao_replace ( TAO_IOP::TAO_IOR_Manipulation::_tc_Duplicate, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void TAO_IOP::TAO_IOR_Manipulation::Duplicate::_tao_any_destructor (void *x) +{ + TAO_IOP::TAO_IOR_Manipulation::Duplicate *tmp = ACE_static_cast(TAO_IOP::TAO_IOR_Manipulation::Duplicate*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipulation::Duplicate *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -894,16 +728,8 @@ void operator<<= (CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipulation::Duplicate stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + TAO_IOP::TAO_IOR_Manipulation::Duplicate::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipulation::Duplicate *&_tao_elem) @@ -935,9 +761,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul TAO_IOP::TAO_IOR_Manipulation::_tc_Duplicate, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + TAO_IOP::TAO_IOR_Manipulation::Duplicate::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -951,7 +776,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -959,85 +784,28 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul 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; + return _tao_any >>= ACE_const_cast(TAO_IOP::TAO_IOR_Manipulation::Duplicate *&,_tao_elem); } 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 = 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_OutputCDR stream; - stream << *_tao_any_val; + stream << _tao_elem; _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 + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR::_tao_any_destructor (void *x) +{ + TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR *tmp = ACE_static_cast(TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -1046,16 +814,8 @@ void operator<<= (CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipulation::Invalid_I stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR *&_tao_elem) @@ -1087,9 +847,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul TAO_IOP::TAO_IOR_Manipulation::_tc_Invalid_IOR, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -1103,7 +862,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -1111,53 +870,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul 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; + return _tao_any >>= ACE_const_cast(TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR *&,_tao_elem); } void operator<<= ( @@ -1165,40 +878,25 @@ void operator<<= ( const TAO_IOP::TAO_IOR_Manipulation::IORList &_tao_elem ) // copying { - TAO_IOP::TAO_IOR_Manipulation::IORList *_tao_any_val; - ACE_NEW (_tao_any_val, TAO_IOP::TAO_IOR_Manipulation::IORList (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - if (stream << *_tao_any_val) + if (stream << _tao_elem) { _tao_any._tao_replace ( TAO_IOP::TAO_IOR_Manipulation::_tc_IORList, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_any_val; } - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void TAO_IOP::TAO_IOR_Manipulation::IORList::_tao_any_destructor (void *x) +{ + TAO_IOP::TAO_IOR_Manipulation::IORList *tmp = ACE_static_cast(TAO_IOP::TAO_IOR_Manipulation::IORList*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipulation::IORList *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -1207,16 +905,8 @@ void operator<<= (CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipulation::IORList * stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + TAO_IOP::TAO_IOR_Manipulation::IORList::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipulation::IORList *&_tao_elem) @@ -1248,9 +938,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul TAO_IOP::TAO_IOR_Manipulation::_tc_IORList, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + TAO_IOP::TAO_IOR_Manipulation::IORList::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -1264,7 +953,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -1272,53 +961,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul 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; + return _tao_any >>= ACE_const_cast(TAO_IOP::TAO_IOR_Manipulation::IORList *&,_tao_elem); } CORBA::Boolean operator<< ( diff --git a/TAO/tao/IORC.h b/TAO/tao/IORC.h index 4bd5a3db4fe..86ee3677998 100644 --- a/TAO/tao/IORC.h +++ b/TAO/tao/IORC.h @@ -124,7 +124,7 @@ TAO_NAMESPACE TAO_IOP TAO_default_environment () ); static TAO_IOR_Manipulation_ptr _nil (void); - + static void _tao_any_destructor (void*); #if !defined (_TAO_IOP_TAO_IOR_MANIPULATION_EMPTYPROFILELIST___PTR_CH_) #define _TAO_IOP_TAO_IOR_MANIPULATION_EMPTYPROFILELIST___PTR_CH_ @@ -156,7 +156,7 @@ TAO_NAMESPACE TAO_IOP CORBA::Environment &); static EmptyProfileList *_narrow (CORBA::Exception *); - + static void _tao_any_destructor (void*); // = TAO extension static CORBA::Exception *_alloc (void); @@ -199,6 +199,7 @@ TAO_NAMESPACE TAO_IOP CORBA::Environment &); static NotFound *_narrow (CORBA::Exception *); + static void _tao_any_destructor (void*); // = TAO extension @@ -242,6 +243,7 @@ TAO_NAMESPACE TAO_IOP CORBA::Environment &); static Duplicate *_narrow (CORBA::Exception *); + static void _tao_any_destructor (void*); // = TAO extension @@ -285,6 +287,7 @@ TAO_NAMESPACE TAO_IOP CORBA::Environment &); static Invalid_IOR *_narrow (CORBA::Exception *); + static void _tao_any_destructor (void*); // = TAO extension @@ -318,6 +321,8 @@ TAO_NAMESPACE TAO_IOP ); IORList (const IORList &); // copy ctor ~IORList (void); // dtor + + static void _tao_any_destructor (void*); }; typedef IORList *IORList_ptr; @@ -480,49 +485,49 @@ 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_Export void operator<<= (CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList *&); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const TAO_IOP::TAO_IOR_Manipulation::NotFound &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::NotFound*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::NotFound *&); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const TAO_IOP::TAO_IOR_Manipulation::NotFound *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const TAO_IOP::TAO_IOR_Manipulation::Duplicate &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::Duplicate*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::Duplicate *&); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const TAO_IOP::TAO_IOR_Manipulation::Duplicate *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR *&); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const TAO_IOP::TAO_IOR_Manipulation::IORList &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::IORList*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::IORList *&); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const TAO_IOP::TAO_IOR_Manipulation::IORList *&); #ifndef __ACE_INLINE__ diff --git a/TAO/tao/ImplRepoC.cpp b/TAO/tao/ImplRepoC.cpp index 8a3592e8970..222aecb15fe 100644 --- a/TAO/tao/ImplRepoC.cpp +++ b/TAO/tao/ImplRepoC.cpp @@ -13,18 +13,24 @@ #include "ImplRepoC.i" #endif /* !defined INLINE */ +void ImplementationRepository::ServerObject::_tao_any_destructor (void *x) +{ + ImplementationRepository::ServerObject *tmp = ACE_static_cast (ImplementationRepository::ServerObject*,x); + CORBA::release (tmp); +} + ImplementationRepository::ServerObject_ptr ImplementationRepository::ServerObject::_narrow ( CORBA::Object_ptr obj, CORBA::Environment &ACE_TRY_ENV ) { if (CORBA::is_nil (obj)) - return ImplementationRepository::ServerObject::_nil (); + return ServerObject::_nil (); CORBA::Boolean is_a = obj->_is_a ("IDL:ImplementationRepository/ServerObject:1.0", ACE_TRY_ENV); - ACE_CHECK_RETURN (ImplementationRepository::ServerObject::_nil ()); + ACE_CHECK_RETURN (ServerObject::_nil ()); if (is_a == 0) - return ImplementationRepository::ServerObject::_nil (); - return ImplementationRepository::ServerObject::_unchecked_narrow (obj, ACE_TRY_ENV); + return ServerObject::_nil (); + return ServerObject::_unchecked_narrow (obj, ACE_TRY_ENV); } ImplementationRepository::ServerObject_ptr ImplementationRepository::ServerObject::_unchecked_narrow ( @@ -33,21 +39,21 @@ ImplementationRepository::ServerObject_ptr ImplementationRepository::ServerObjec ) { if (CORBA::is_nil (obj)) - return ImplementationRepository::ServerObject::_nil (); + return ServerObject::_nil (); TAO_Stub* stub = obj->_stubobj (); stub->_incr_refcnt (); - ImplementationRepository::ServerObject_ptr default_proxy = ImplementationRepository::ServerObject::_nil (); + ServerObject_ptr default_proxy = ServerObject::_nil (); if (obj->_is_collocated () && _TAO_collocation_ImplementationRepository_ServerObject_Stub_Factory_function_pointer != 0) { default_proxy = _TAO_collocation_ImplementationRepository_ServerObject_Stub_Factory_function_pointer (obj); } if (CORBA::is_nil (default_proxy)) - ACE_NEW_RETURN (default_proxy, ImplementationRepository::ServerObject (stub), ImplementationRepository::ServerObject::_nil ()); + ACE_NEW_RETURN (default_proxy, ServerObject (stub), ServerObject::_nil ()); return TAO_ImplementationRepository_ServerObject_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy); } -ImplementationRepository::ServerObject_ptr -ImplementationRepository::ServerObject::_duplicate (ImplementationRepository::ServerObject_ptr obj) +ImplementationRepository::ServerObject_ptr +ImplementationRepository::ServerObject::_duplicate (ServerObject_ptr obj) { if (!CORBA::is_nil (obj)) obj->_incr_refcnt (); @@ -61,15 +67,15 @@ void ImplementationRepository::ServerObject::ping ( CORBA::SystemException )) { + - - - + + TAO_Stub *istub = this->_stubobj (); if (istub == 0) ACE_THROW (CORBA::INTERNAL ()); - + TAO_GIOP_Twoway_Invocation _tao_call ( istub, "ping", @@ -112,6 +118,8 @@ void ImplementationRepository::ServerObject::ping ( ); TAO_INTERCEPTOR_CHECK; CORBA::Short flag = 131; + // Tremporary hack until GIOP 1.2 is implemented. + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); TAO_INTERCEPTOR_CHECK; @@ -125,7 +133,7 @@ void ImplementationRepository::ServerObject::ping ( { TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); } - + TAO_INTERCEPTOR ( _tao_vfr.postinvoke ( _tao_call.request_id (), @@ -140,10 +148,10 @@ void ImplementationRepository::ServerObject::ping ( ); TAO_INTERCEPTOR_CHECK; break; - + } #if defined (TAO_HAS_INTERCEPTORS) - + } ACE_CATCHANY { @@ -170,15 +178,15 @@ void ImplementationRepository::ServerObject::shutdown ( CORBA::SystemException )) { + - - - + + TAO_Stub *istub = this->_stubobj (); if (istub == 0) ACE_THROW (CORBA::INTERNAL ()); - + TAO_GIOP_Twoway_Invocation _tao_call ( istub, "shutdown", @@ -221,6 +229,8 @@ void ImplementationRepository::ServerObject::shutdown ( ); TAO_INTERCEPTOR_CHECK; CORBA::Short flag = 131; + // Tremporary hack until GIOP 1.2 is implemented. + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); TAO_INTERCEPTOR_CHECK; @@ -234,7 +244,7 @@ void ImplementationRepository::ServerObject::shutdown ( { TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); } - + TAO_INTERCEPTOR ( _tao_vfr.postinvoke ( _tao_call.request_id (), @@ -249,10 +259,10 @@ void ImplementationRepository::ServerObject::shutdown ( ); TAO_INTERCEPTOR_CHECK; break; - + } #if defined (TAO_HAS_INTERCEPTORS) - + } ACE_CATCHANY { @@ -301,7 +311,7 @@ ImplementationRepository::TAO_ImplementationRepository_ServerObject_Default_Prox ImplementationRepository::ServerObject_ptr ImplementationRepository::TAO_ImplementationRepository_ServerObject_Default_Proxy_Factory::create_proxy ( - ImplementationRepository::ServerObject_ptr proxy, + ::ImplementationRepository::ServerObject_ptr proxy, CORBA::Environment & ) { @@ -346,7 +356,7 @@ ImplementationRepository::TAO_ImplementationRepository_ServerObject_Proxy_Factor if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0) { // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it - // doesnt get into an infinite loop in <unregister_proxy_factory> as it is + // doesnt get into an infinite loop in <unregister_proxy_factory> as it is // invoked in the destructor of the class too. this->delete_proxy_factory_ = 1; delete this->proxy_factory_; @@ -357,23 +367,23 @@ return 0; ImplementationRepository::ServerObject_ptr ImplementationRepository::TAO_ImplementationRepository_ServerObject_Proxy_Factory_Adapter::create_proxy ( - ImplementationRepository::ServerObject_ptr proxy, - CORBA::Environment & - ) + ::ImplementationRepository::ServerObject_ptr proxy, + CORBA::Environment & + ) { ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, this->lock_, 0)); // Verify that an <proxy_factory_> is available else make one. if (this->proxy_factory_ == 0) ACE_NEW_RETURN (this->proxy_factory_, - TAO_ImplementationRepository_ServerObject_Default_Proxy_Factory (1), + TAO_ImplementationRepository_ServerObject_Default_Proxy_Factory (1), 0); - - + + return this->proxy_factory_->create_proxy (proxy); } -ImplementationRepository::TAO_ImplementationRepository_ServerObject_Smart_Proxy_Base::TAO_ImplementationRepository_ServerObject_Smart_Proxy_Base (ImplementationRepository::ServerObject_ptr proxy) +ImplementationRepository::TAO_ImplementationRepository_ServerObject_Smart_Proxy_Base::TAO_ImplementationRepository_ServerObject_Smart_Proxy_Base (::ImplementationRepository::ServerObject_ptr proxy) : base_proxy_ (proxy) { } @@ -433,10 +443,10 @@ static const CORBA::Long _oc_ImplementationRepository_EnvironmentVariable[] = 20, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7456), ACE_NTOHL (0x61726961), ACE_NTOHL (0x626c6500), // name = EnvironmentVariable 2, // member count 5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0), // name = name - CORBA::tk_string, + CORBA::tk_string, 0U, // string length 6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000), // name = value - CORBA::tk_string, + CORBA::tk_string, 0U, // string length }; static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_EnvironmentVariable (CORBA::tk_struct, sizeof (_oc_ImplementationRepository_EnvironmentVariable), (char *) &_oc_ImplementationRepository_EnvironmentVariable, 0, sizeof (ImplementationRepository::EnvironmentVariable)); @@ -444,12 +454,18 @@ TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) TAO_NAMESPACE_BEGIN (ImplementationRepository) TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_EnvironmentVariable, &_tc_TAO_tc_ImplementationRepository_EnvironmentVariable) TAO_NAMESPACE_END +void ImplementationRepository::EnvironmentVariable::_tao_any_destructor (void *x) +{ + ImplementationRepository::EnvironmentVariable *tmp = ACE_static_cast (ImplementationRepository::EnvironmentVariable*,x); + delete tmp; +} + static const CORBA::Long _oc_ImplementationRepository_Address[] = { TAO_ENCAP_BYTE_ORDER, // byte order 41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f416464), ACE_NTOHL (0x72657373), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/Address:1.0 8, ACE_NTOHL (0x41646472), ACE_NTOHL (0x65737300), // name = Address - CORBA::tk_string, + CORBA::tk_string, 0U, // string length }; static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_Address (CORBA::tk_alias, sizeof (_oc_ImplementationRepository_Address), (char *) &_oc_ImplementationRepository_Address, 0, sizeof (ImplementationRepository::Address)); @@ -459,7 +475,7 @@ TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Address, &_tc_TAO_tc_Implementati TAO_NAMESPACE_END #if !defined (TAO_USE_SEQUENCE_TEMPLATES) - + #if !defined (__TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CS_) #define __TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CS_ @@ -467,44 +483,44 @@ TAO_NAMESPACE_END ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::_allocate_buffer (CORBA::ULong length) { ImplementationRepository::EnvironmentVariable* tmp = 0; - tmp = ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::allocbuf (length); - + tmp = _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::allocbuf (length); + if (this->buffer_ != 0) { ImplementationRepository::EnvironmentVariable *old = ACE_reinterpret_cast (ImplementationRepository::EnvironmentVariable *,this->buffer_); - + for (CORBA::ULong i = 0; i < this->length_; ++i) tmp[i] = old[i]; - + if (this->release_) - ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::freebuf (old); - + _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::freebuf (old); + } this->buffer_ = tmp; } - + void ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::_deallocate_buffer (void) { if (this->buffer_ == 0 || this->release_ == 0) return; - + ImplementationRepository::EnvironmentVariable *tmp = ACE_reinterpret_cast (ImplementationRepository::EnvironmentVariable *,this->buffer_); - - ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::freebuf (tmp); + + _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::freebuf (tmp); this->buffer_ = 0; - } - + } + ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::~_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList (void) // Dtor. { this->_deallocate_buffer (); } - - + + #endif /* end #if !defined */ -#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ #if !defined (_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CS_) #define _IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CS_ @@ -516,34 +532,39 @@ TAO_NAMESPACE_END ImplementationRepository::EnvironmentList::EnvironmentList (void) {} ImplementationRepository::EnvironmentList::EnvironmentList (CORBA::ULong max) // uses max size - : + : #if !defined (TAO_USE_SEQUENCE_TEMPLATES) _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList #else /* TAO_USE_SEQUENCE_TEMPLATES */ TAO_Unbounded_Sequence<ImplementationRepository::EnvironmentVariable> -#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ (max) {} ImplementationRepository::EnvironmentList::EnvironmentList (CORBA::ULong max, CORBA::ULong length, ImplementationRepository::EnvironmentVariable *buffer, CORBA::Boolean release) - : + : #if !defined (TAO_USE_SEQUENCE_TEMPLATES) _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList #else /* TAO_USE_SEQUENCE_TEMPLATES */ TAO_Unbounded_Sequence<ImplementationRepository::EnvironmentVariable> -#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ (max, length, buffer, release) {} ImplementationRepository::EnvironmentList::EnvironmentList (const EnvironmentList &seq) // copy ctor - : + : #if !defined (TAO_USE_SEQUENCE_TEMPLATES) _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList #else /* TAO_USE_SEQUENCE_TEMPLATES */ TAO_Unbounded_Sequence<ImplementationRepository::EnvironmentVariable> -#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ (seq) {} ImplementationRepository::EnvironmentList::~EnvironmentList (void) // dtor {} +void ImplementationRepository::EnvironmentList::_tao_any_destructor (void *x) +{ + ImplementationRepository::EnvironmentList *tmp = ACE_static_cast (ImplementationRepository::EnvironmentList*,x); + delete tmp; +} #endif /* end #if !defined */ @@ -563,10 +584,10 @@ static const CORBA::Long _oc_ImplementationRepository_EnvironmentList[] = 20, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7456), ACE_NTOHL (0x61726961), ACE_NTOHL (0x626c6500), // name = EnvironmentVariable 2, // member count 5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0), // name = name - CORBA::tk_string, + CORBA::tk_string, 0U, // string length 6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000), // name = value - CORBA::tk_string, + CORBA::tk_string, 0U, // string length 0U, @@ -600,7 +621,7 @@ static const CORBA::Long _oc_ImplementationRepository_StartupOptions[] = 15, ACE_NTOHL (0x53746172), ACE_NTOHL (0x7475704f), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000), // name = StartupOptions 4, // member count 13, ACE_NTOHL (0x636f6d6d), ACE_NTOHL (0x616e645f), ACE_NTOHL (0x6c696e65), ACE_NTOHL (0x0), // name = command_line - CORBA::tk_string, + CORBA::tk_string, 0U, // string length 12, ACE_NTOHL (0x656e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7400), // name = environment CORBA::tk_alias, // typecode kind for typedefs @@ -618,17 +639,17 @@ static const CORBA::Long _oc_ImplementationRepository_StartupOptions[] = 20, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7456), ACE_NTOHL (0x61726961), ACE_NTOHL (0x626c6500), // name = EnvironmentVariable 2, // member count 5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0), // name = name - CORBA::tk_string, + CORBA::tk_string, 0U, // string length 6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000), // name = value - CORBA::tk_string, + CORBA::tk_string, 0U, // string length 0U, 18, ACE_NTOHL (0x776f726b), ACE_NTOHL (0x696e675f), ACE_NTOHL (0x64697265), ACE_NTOHL (0x63746f72), ACE_NTOHL (0x79000000), // name = working_directory - CORBA::tk_string, + CORBA::tk_string, 0U, // string length 11, ACE_NTOHL (0x61637469), ACE_NTOHL (0x76617469), ACE_NTOHL (0x6f6e0000), // name = activation CORBA::tk_enum, // typecode kind @@ -648,6 +669,12 @@ TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) TAO_NAMESPACE_BEGIN (ImplementationRepository) TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_StartupOptions, &_tc_TAO_tc_ImplementationRepository_StartupOptions) TAO_NAMESPACE_END +void ImplementationRepository::StartupOptions::_tao_any_destructor (void *x) +{ + ImplementationRepository::StartupOptions *tmp = ACE_static_cast (ImplementationRepository::StartupOptions*,x); + delete tmp; +} + static const CORBA::Long _oc_ImplementationRepository_ServerInformation[] = { TAO_ENCAP_BYTE_ORDER, // byte order @@ -655,10 +682,10 @@ static const CORBA::Long _oc_ImplementationRepository_ServerInformation[] = 18, ACE_NTOHL (0x53657276), ACE_NTOHL (0x6572496e), ACE_NTOHL (0x666f726d), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e000000), // name = ServerInformation 4, // member count 15, ACE_NTOHL (0x6c6f6769), ACE_NTOHL (0x63616c5f), ACE_NTOHL (0x73657276), ACE_NTOHL (0x65720000), // name = logical_server - CORBA::tk_string, + CORBA::tk_string, 0U, // string length 7, ACE_NTOHL (0x73657276), ACE_NTOHL (0x65720000), // name = server - CORBA::tk_string, + CORBA::tk_string, 0U, // string length 8, ACE_NTOHL (0x73746172), ACE_NTOHL (0x74757000), // name = startup CORBA::tk_struct, // typecode kind @@ -668,7 +695,7 @@ static const CORBA::Long _oc_ImplementationRepository_ServerInformation[] = 15, ACE_NTOHL (0x53746172), ACE_NTOHL (0x7475704f), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000), // name = StartupOptions 4, // member count 13, ACE_NTOHL (0x636f6d6d), ACE_NTOHL (0x616e645f), ACE_NTOHL (0x6c696e65), ACE_NTOHL (0x0), // name = command_line - CORBA::tk_string, + CORBA::tk_string, 0U, // string length 12, ACE_NTOHL (0x656e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7400), // name = environment CORBA::tk_alias, // typecode kind for typedefs @@ -686,17 +713,17 @@ static const CORBA::Long _oc_ImplementationRepository_ServerInformation[] = 20, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7456), ACE_NTOHL (0x61726961), ACE_NTOHL (0x626c6500), // name = EnvironmentVariable 2, // member count 5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0), // name = name - CORBA::tk_string, + CORBA::tk_string, 0U, // string length 6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000), // name = value - CORBA::tk_string, + CORBA::tk_string, 0U, // string length 0U, 18, ACE_NTOHL (0x776f726b), ACE_NTOHL (0x696e675f), ACE_NTOHL (0x64697265), ACE_NTOHL (0x63746f72), ACE_NTOHL (0x79000000), // name = working_directory - CORBA::tk_string, + CORBA::tk_string, 0U, // string length 11, ACE_NTOHL (0x61637469), ACE_NTOHL (0x76617469), ACE_NTOHL (0x6f6e0000), // name = activation CORBA::tk_enum, // typecode kind @@ -717,7 +744,7 @@ static const CORBA::Long _oc_ImplementationRepository_ServerInformation[] = TAO_ENCAP_BYTE_ORDER, // byte order 41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f416464), ACE_NTOHL (0x72657373), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/Address:1.0 8, ACE_NTOHL (0x41646472), ACE_NTOHL (0x65737300), // name = Address - CORBA::tk_string, + CORBA::tk_string, 0U, // string length }; @@ -726,9 +753,15 @@ TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) TAO_NAMESPACE_BEGIN (ImplementationRepository) TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ServerInformation, &_tc_TAO_tc_ImplementationRepository_ServerInformation) TAO_NAMESPACE_END +void ImplementationRepository::ServerInformation::_tao_any_destructor (void *x) +{ + ImplementationRepository::ServerInformation *tmp = ACE_static_cast (ImplementationRepository::ServerInformation*,x); + delete tmp; +} -#if !defined (TAO_USE_SEQUENCE_TEMPLATES) +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + #if !defined (__TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CS_) #define __TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CS_ @@ -736,44 +769,44 @@ TAO_NAMESPACE_END ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::_allocate_buffer (CORBA::ULong length) { ImplementationRepository::ServerInformation* tmp = 0; - tmp = ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::allocbuf (length); - + tmp = _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::allocbuf (length); + if (this->buffer_ != 0) { ImplementationRepository::ServerInformation *old = ACE_reinterpret_cast (ImplementationRepository::ServerInformation *,this->buffer_); - + for (CORBA::ULong i = 0; i < this->length_; ++i) tmp[i] = old[i]; - + if (this->release_) - ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::freebuf (old); - + _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::freebuf (old); + } this->buffer_ = tmp; } - + void ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::_deallocate_buffer (void) { if (this->buffer_ == 0 || this->release_ == 0) return; - + ImplementationRepository::ServerInformation *tmp = ACE_reinterpret_cast (ImplementationRepository::ServerInformation *,this->buffer_); - - ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::freebuf (tmp); + + _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::freebuf (tmp); this->buffer_ = 0; - } - + } + ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::~_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList (void) // Dtor. { this->_deallocate_buffer (); } - - + + #endif /* end #if !defined */ -#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ #if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CS_) #define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CS_ @@ -785,34 +818,39 @@ TAO_NAMESPACE_END ImplementationRepository::ServerInformationList::ServerInformationList (void) {} ImplementationRepository::ServerInformationList::ServerInformationList (CORBA::ULong max) // uses max size - : + : #if !defined (TAO_USE_SEQUENCE_TEMPLATES) _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList #else /* TAO_USE_SEQUENCE_TEMPLATES */ TAO_Unbounded_Sequence<ImplementationRepository::ServerInformation> -#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ (max) {} ImplementationRepository::ServerInformationList::ServerInformationList (CORBA::ULong max, CORBA::ULong length, ImplementationRepository::ServerInformation *buffer, CORBA::Boolean release) - : + : #if !defined (TAO_USE_SEQUENCE_TEMPLATES) _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList #else /* TAO_USE_SEQUENCE_TEMPLATES */ TAO_Unbounded_Sequence<ImplementationRepository::ServerInformation> -#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ (max, length, buffer, release) {} ImplementationRepository::ServerInformationList::ServerInformationList (const ServerInformationList &seq) // copy ctor - : + : #if !defined (TAO_USE_SEQUENCE_TEMPLATES) _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList #else /* TAO_USE_SEQUENCE_TEMPLATES */ TAO_Unbounded_Sequence<ImplementationRepository::ServerInformation> -#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ (seq) {} ImplementationRepository::ServerInformationList::~ServerInformationList (void) // dtor {} +void ImplementationRepository::ServerInformationList::_tao_any_destructor (void *x) +{ + ImplementationRepository::ServerInformationList *tmp = ACE_static_cast (ImplementationRepository::ServerInformationList*,x); + delete tmp; +} #endif /* end #if !defined */ @@ -832,10 +870,10 @@ static const CORBA::Long _oc_ImplementationRepository_ServerInformationList[] = 18, ACE_NTOHL (0x53657276), ACE_NTOHL (0x6572496e), ACE_NTOHL (0x666f726d), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e000000), // name = ServerInformation 4, // member count 15, ACE_NTOHL (0x6c6f6769), ACE_NTOHL (0x63616c5f), ACE_NTOHL (0x73657276), ACE_NTOHL (0x65720000), // name = logical_server - CORBA::tk_string, + CORBA::tk_string, 0U, // string length 7, ACE_NTOHL (0x73657276), ACE_NTOHL (0x65720000), // name = server - CORBA::tk_string, + CORBA::tk_string, 0U, // string length 8, ACE_NTOHL (0x73746172), ACE_NTOHL (0x74757000), // name = startup CORBA::tk_struct, // typecode kind @@ -845,7 +883,7 @@ static const CORBA::Long _oc_ImplementationRepository_ServerInformationList[] = 15, ACE_NTOHL (0x53746172), ACE_NTOHL (0x7475704f), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000), // name = StartupOptions 4, // member count 13, ACE_NTOHL (0x636f6d6d), ACE_NTOHL (0x616e645f), ACE_NTOHL (0x6c696e65), ACE_NTOHL (0x0), // name = command_line - CORBA::tk_string, + CORBA::tk_string, 0U, // string length 12, ACE_NTOHL (0x656e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7400), // name = environment CORBA::tk_alias, // typecode kind for typedefs @@ -863,17 +901,17 @@ static const CORBA::Long _oc_ImplementationRepository_ServerInformationList[] = 20, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7456), ACE_NTOHL (0x61726961), ACE_NTOHL (0x626c6500), // name = EnvironmentVariable 2, // member count 5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0), // name = name - CORBA::tk_string, + CORBA::tk_string, 0U, // string length 6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000), // name = value - CORBA::tk_string, + CORBA::tk_string, 0U, // string length 0U, 18, ACE_NTOHL (0x776f726b), ACE_NTOHL (0x696e675f), ACE_NTOHL (0x64697265), ACE_NTOHL (0x63746f72), ACE_NTOHL (0x79000000), // name = working_directory - CORBA::tk_string, + CORBA::tk_string, 0U, // string length 11, ACE_NTOHL (0x61637469), ACE_NTOHL (0x76617469), ACE_NTOHL (0x6f6e0000), // name = activation CORBA::tk_enum, // typecode kind @@ -894,7 +932,7 @@ static const CORBA::Long _oc_ImplementationRepository_ServerInformationList[] = TAO_ENCAP_BYTE_ORDER, // byte order 41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f416464), ACE_NTOHL (0x72657373), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/Address:1.0 8, ACE_NTOHL (0x41646472), ACE_NTOHL (0x65737300), // name = Address - CORBA::tk_string, + CORBA::tk_string, 0U, // string length @@ -906,18 +944,24 @@ TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) TAO_NAMESPACE_BEGIN (ImplementationRepository) TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ServerInformationList, &_tc_TAO_tc_ImplementationRepository_ServerInformationList) TAO_NAMESPACE_END +void ImplementationRepository::Administration::_tao_any_destructor (void *x) +{ + ImplementationRepository::Administration *tmp = ACE_static_cast (ImplementationRepository::Administration*,x); + CORBA::release (tmp); +} + ImplementationRepository::Administration_ptr ImplementationRepository::Administration::_narrow ( CORBA::Object_ptr obj, CORBA::Environment &ACE_TRY_ENV ) { if (CORBA::is_nil (obj)) - return ImplementationRepository::Administration::_nil (); + return Administration::_nil (); CORBA::Boolean is_a = obj->_is_a ("IDL:ImplementationRepository/Administration:1.0", ACE_TRY_ENV); - ACE_CHECK_RETURN (ImplementationRepository::Administration::_nil ()); + ACE_CHECK_RETURN (Administration::_nil ()); if (is_a == 0) - return ImplementationRepository::Administration::_nil (); - return ImplementationRepository::Administration::_unchecked_narrow (obj, ACE_TRY_ENV); + return Administration::_nil (); + return Administration::_unchecked_narrow (obj, ACE_TRY_ENV); } ImplementationRepository::Administration_ptr ImplementationRepository::Administration::_unchecked_narrow ( @@ -926,21 +970,21 @@ ImplementationRepository::Administration_ptr ImplementationRepository::Administr ) { if (CORBA::is_nil (obj)) - return ImplementationRepository::Administration::_nil (); + return Administration::_nil (); TAO_Stub* stub = obj->_stubobj (); stub->_incr_refcnt (); - ImplementationRepository::Administration_ptr default_proxy = ImplementationRepository::Administration::_nil (); + Administration_ptr default_proxy = Administration::_nil (); if (obj->_is_collocated () && _TAO_collocation_ImplementationRepository_Administration_Stub_Factory_function_pointer != 0) { default_proxy = _TAO_collocation_ImplementationRepository_Administration_Stub_Factory_function_pointer (obj); } if (CORBA::is_nil (default_proxy)) - ACE_NEW_RETURN (default_proxy, ImplementationRepository::Administration (stub), ImplementationRepository::Administration::_nil ()); + ACE_NEW_RETURN (default_proxy, Administration (stub), Administration::_nil ()); return TAO_ImplementationRepository_Administration_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy); } -ImplementationRepository::Administration_ptr -ImplementationRepository::Administration::_duplicate (ImplementationRepository::Administration_ptr obj) +ImplementationRepository::Administration_ptr +ImplementationRepository::Administration::_duplicate (Administration_ptr obj) { if (!CORBA::is_nil (obj)) obj->_incr_refcnt (); @@ -949,7 +993,7 @@ ImplementationRepository::Administration::_duplicate (ImplementationRepository:: // default constructor ImplementationRepository::Administration::AlreadyRegistered::AlreadyRegistered (void) - : CORBA_UserException (ImplementationRepository::Administration::_tc_AlreadyRegistered) + : CORBA_UserException (::ImplementationRepository::Administration::_tc_AlreadyRegistered) { } @@ -958,15 +1002,21 @@ ImplementationRepository::Administration::AlreadyRegistered::~AlreadyRegistered { } +void ImplementationRepository::Administration::AlreadyRegistered::_tao_any_destructor (void *x) +{ + ImplementationRepository::Administration::AlreadyRegistered *tmp = ACE_static_cast (ImplementationRepository::Administration::AlreadyRegistered*,x); + delete tmp; +} + // copy constructor -ImplementationRepository::Administration::AlreadyRegistered::AlreadyRegistered (const ImplementationRepository::Administration::AlreadyRegistered &_tao_excp) +ImplementationRepository::Administration::AlreadyRegistered::AlreadyRegistered (const ::ImplementationRepository::Administration::AlreadyRegistered &_tao_excp) : CORBA_UserException (_tao_excp._type ()) { } // assignment operator ImplementationRepository::Administration::AlreadyRegistered& -ImplementationRepository::Administration::AlreadyRegistered::operator= (const ImplementationRepository::Administration::AlreadyRegistered &_tao_excp) +ImplementationRepository::Administration::AlreadyRegistered::operator= (const ::ImplementationRepository::Administration::AlreadyRegistered &_tao_excp) { this->CORBA_UserException::operator= (_tao_excp); @@ -974,11 +1024,11 @@ ImplementationRepository::Administration::AlreadyRegistered::operator= (const Im } // narrow -ImplementationRepository::Administration::AlreadyRegistered_ptr +ImplementationRepository::Administration::AlreadyRegistered_ptr ImplementationRepository::Administration::AlreadyRegistered::_narrow (CORBA::Exception *exc) { if (!ACE_OS::strcmp ("IDL:ImplementationRepository/Administration/AlreadyRegistered:1.0", exc->_id ())) // same type - return ACE_dynamic_cast (ImplementationRepository::Administration::AlreadyRegistered_ptr, exc); + return ACE_dynamic_cast (AlreadyRegistered_ptr, exc); else return 0; } @@ -989,16 +1039,20 @@ void ImplementationRepository::Administration::AlreadyRegistered::_raise () TAO_RAISE(*this); } -void ImplementationRepository::Administration::AlreadyRegistered::_tao_encode (TAO_OutputCDR &cdr, - CORBA::Environment &ACE_TRY_ENV) const + +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) + +void ImplementationRepository::Administration::AlreadyRegistered::_tao_decode ( + TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) { if (cdr >> *this) return; @@ -1009,7 +1063,7 @@ void ImplementationRepository::Administration::AlreadyRegistered::_tao_decode (T CORBA::Exception *ImplementationRepository::Administration::AlreadyRegistered::_alloc (void) { CORBA::Exception *retval = 0; - ACE_NEW_RETURN (retval, ImplementationRepository::Administration::AlreadyRegistered, 0); + ACE_NEW_RETURN (retval, ::ImplementationRepository::Administration::AlreadyRegistered, 0); return retval; } @@ -1025,7 +1079,7 @@ CORBA::TypeCode_ptr ImplementationRepository::Administration::_tc_AlreadyRegiste // default constructor ImplementationRepository::Administration::CannotActivate::CannotActivate (void) - : CORBA_UserException (ImplementationRepository::Administration::_tc_CannotActivate) + : CORBA_UserException (::ImplementationRepository::Administration::_tc_CannotActivate) { } @@ -1034,8 +1088,14 @@ ImplementationRepository::Administration::CannotActivate::~CannotActivate (void) { } +void ImplementationRepository::Administration::CannotActivate::_tao_any_destructor (void *x) +{ + ImplementationRepository::Administration::CannotActivate *tmp = ACE_static_cast (ImplementationRepository::Administration::CannotActivate*,x); + delete tmp; +} + // copy constructor -ImplementationRepository::Administration::CannotActivate::CannotActivate (const ImplementationRepository::Administration::CannotActivate &_tao_excp) +ImplementationRepository::Administration::CannotActivate::CannotActivate (const ::ImplementationRepository::Administration::CannotActivate &_tao_excp) : CORBA_UserException (_tao_excp._type ()) { this->reason = CORBA::string_dup (_tao_excp.reason.in ()); @@ -1043,7 +1103,7 @@ ImplementationRepository::Administration::CannotActivate::CannotActivate (const // assignment operator ImplementationRepository::Administration::CannotActivate& -ImplementationRepository::Administration::CannotActivate::operator= (const ImplementationRepository::Administration::CannotActivate &_tao_excp) +ImplementationRepository::Administration::CannotActivate::operator= (const ::ImplementationRepository::Administration::CannotActivate &_tao_excp) { this->CORBA_UserException::operator= (_tao_excp); @@ -1052,11 +1112,11 @@ ImplementationRepository::Administration::CannotActivate::operator= (const Imple } // narrow -ImplementationRepository::Administration::CannotActivate_ptr +ImplementationRepository::Administration::CannotActivate_ptr ImplementationRepository::Administration::CannotActivate::_narrow (CORBA::Exception *exc) { if (!ACE_OS::strcmp ("IDL:ImplementationRepository/Administration/CannotActivate:1.0", exc->_id ())) // same type - return ACE_dynamic_cast (ImplementationRepository::Administration::CannotActivate_ptr, exc); + return ACE_dynamic_cast (CannotActivate_ptr, exc); else return 0; } @@ -1067,16 +1127,20 @@ void ImplementationRepository::Administration::CannotActivate::_raise () TAO_RAISE(*this); } -void ImplementationRepository::Administration::CannotActivate::_tao_encode (TAO_OutputCDR &cdr, - CORBA::Environment &ACE_TRY_ENV) const + +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) + +void ImplementationRepository::Administration::CannotActivate::_tao_decode ( + TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) { if (cdr >> *this) return; @@ -1087,7 +1151,7 @@ void ImplementationRepository::Administration::CannotActivate::_tao_decode (TAO_ CORBA::Exception *ImplementationRepository::Administration::CannotActivate::_alloc (void) { CORBA::Exception *retval = 0; - ACE_NEW_RETURN (retval, ImplementationRepository::Administration::CannotActivate, 0); + ACE_NEW_RETURN (retval, ::ImplementationRepository::Administration::CannotActivate, 0); return retval; } @@ -1106,7 +1170,7 @@ static const CORBA::Long _oc_ImplementationRepository_Administration_CannotActiv 15, ACE_NTOHL (0x43616e6e), ACE_NTOHL (0x6f744163), ACE_NTOHL (0x74697661), ACE_NTOHL (0x74650000), // name = CannotActivate 1, // member count 7, ACE_NTOHL (0x72656173), ACE_NTOHL (0x6f6e0000), // name = reason - CORBA::tk_string, + CORBA::tk_string, 0U, // string length }; static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_Administration_CannotActivate (CORBA::tk_except, sizeof (_oc_ImplementationRepository_Administration_CannotActivate), (char *) &_oc_ImplementationRepository_Administration_CannotActivate, 0, sizeof (ImplementationRepository::Administration::CannotActivate)); @@ -1114,7 +1178,7 @@ CORBA::TypeCode_ptr ImplementationRepository::Administration::_tc_CannotActivate // default constructor ImplementationRepository::Administration::NotFound::NotFound (void) - : CORBA_UserException (ImplementationRepository::Administration::_tc_NotFound) + : CORBA_UserException (::ImplementationRepository::Administration::_tc_NotFound) { } @@ -1123,15 +1187,21 @@ ImplementationRepository::Administration::NotFound::~NotFound (void) { } +void ImplementationRepository::Administration::NotFound::_tao_any_destructor (void *x) +{ + ImplementationRepository::Administration::NotFound *tmp = ACE_static_cast (ImplementationRepository::Administration::NotFound*,x); + delete tmp; +} + // copy constructor -ImplementationRepository::Administration::NotFound::NotFound (const ImplementationRepository::Administration::NotFound &_tao_excp) +ImplementationRepository::Administration::NotFound::NotFound (const ::ImplementationRepository::Administration::NotFound &_tao_excp) : CORBA_UserException (_tao_excp._type ()) { } // assignment operator ImplementationRepository::Administration::NotFound& -ImplementationRepository::Administration::NotFound::operator= (const ImplementationRepository::Administration::NotFound &_tao_excp) +ImplementationRepository::Administration::NotFound::operator= (const ::ImplementationRepository::Administration::NotFound &_tao_excp) { this->CORBA_UserException::operator= (_tao_excp); @@ -1139,11 +1209,11 @@ ImplementationRepository::Administration::NotFound::operator= (const Implementat } // narrow -ImplementationRepository::Administration::NotFound_ptr +ImplementationRepository::Administration::NotFound_ptr ImplementationRepository::Administration::NotFound::_narrow (CORBA::Exception *exc) { if (!ACE_OS::strcmp ("IDL:ImplementationRepository/Administration/NotFound:1.0", exc->_id ())) // same type - return ACE_dynamic_cast (ImplementationRepository::Administration::NotFound_ptr, exc); + return ACE_dynamic_cast (NotFound_ptr, exc); else return 0; } @@ -1154,16 +1224,20 @@ void ImplementationRepository::Administration::NotFound::_raise () TAO_RAISE(*this); } -void ImplementationRepository::Administration::NotFound::_tao_encode (TAO_OutputCDR &cdr, - CORBA::Environment &ACE_TRY_ENV) const + +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) + +void ImplementationRepository::Administration::NotFound::_tao_decode ( + TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) { if (cdr >> *this) return; @@ -1174,7 +1248,7 @@ void ImplementationRepository::Administration::NotFound::_tao_decode (TAO_InputC CORBA::Exception *ImplementationRepository::Administration::NotFound::_alloc (void) { CORBA::Exception *retval = 0; - ACE_NEW_RETURN (retval, ImplementationRepository::Administration::NotFound, 0); + ACE_NEW_RETURN (retval, ::ImplementationRepository::Administration::NotFound, 0); return retval; } @@ -1198,21 +1272,21 @@ void ImplementationRepository::Administration::activate_server ( ImplementationRepository::Administration::CannotActivate )) { - - static TAO_Exception_Data _tao_ImplementationRepository_Administration_activate_server_exceptiondata [] = + + static TAO_Exception_Data _tao_ImplementationRepository_Administration_activate_server_exceptiondata [] = { {ImplementationRepository::Administration::_tc_NotFound, ImplementationRepository::Administration::NotFound::_alloc}, {ImplementationRepository::Administration::_tc_CannotActivate, ImplementationRepository::Administration::CannotActivate::_alloc} }; - - + + TAO_Stub *istub = this->_stubobj (); if (istub == 0) ACE_THROW (CORBA::INTERNAL ()); - + TAO_GIOP_Twoway_Invocation _tao_call ( istub, "activate_server", @@ -1255,6 +1329,8 @@ void ImplementationRepository::Administration::activate_server ( ); TAO_INTERCEPTOR_CHECK; CORBA::Short flag = 131; + // Tremporary hack until GIOP 1.2 is implemented. + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); TAO_INTERCEPTOR_CHECK; @@ -1273,7 +1349,7 @@ void ImplementationRepository::Administration::activate_server ( { TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); } - + TAO_INTERCEPTOR ( _tao_vfr.postinvoke ( _tao_call.request_id (), @@ -1288,10 +1364,10 @@ void ImplementationRepository::Administration::activate_server ( ); TAO_INTERCEPTOR_CHECK; break; - + } #if defined (TAO_HAS_INTERCEPTORS) - + } ACE_CATCHANY { @@ -1321,20 +1397,20 @@ void ImplementationRepository::Administration::register_server ( ImplementationRepository::Administration::AlreadyRegistered )) { - - static TAO_Exception_Data _tao_ImplementationRepository_Administration_register_server_exceptiondata [] = + + static TAO_Exception_Data _tao_ImplementationRepository_Administration_register_server_exceptiondata [] = { {ImplementationRepository::Administration::_tc_AlreadyRegistered, ImplementationRepository::Administration::AlreadyRegistered::_alloc} }; - - + + TAO_Stub *istub = this->_stubobj (); if (istub == 0) ACE_THROW (CORBA::INTERNAL ()); - + TAO_GIOP_Twoway_Invocation _tao_call ( istub, "register_server", @@ -1377,6 +1453,8 @@ void ImplementationRepository::Administration::register_server ( ); TAO_INTERCEPTOR_CHECK; CORBA::Short flag = 131; + // Tremporary hack until GIOP 1.2 is implemented. + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); TAO_INTERCEPTOR_CHECK; @@ -1396,7 +1474,7 @@ void ImplementationRepository::Administration::register_server ( { TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); } - + TAO_INTERCEPTOR ( _tao_vfr.postinvoke ( _tao_call.request_id (), @@ -1411,10 +1489,10 @@ void ImplementationRepository::Administration::register_server ( ); TAO_INTERCEPTOR_CHECK; break; - + } #if defined (TAO_HAS_INTERCEPTORS) - + } ACE_CATCHANY { @@ -1443,15 +1521,15 @@ void ImplementationRepository::Administration::reregister_server ( CORBA::SystemException )) { + - - - + + TAO_Stub *istub = this->_stubobj (); if (istub == 0) ACE_THROW (CORBA::INTERNAL ()); - + TAO_GIOP_Twoway_Invocation _tao_call ( istub, "reregister_server", @@ -1494,6 +1572,8 @@ void ImplementationRepository::Administration::reregister_server ( ); TAO_INTERCEPTOR_CHECK; CORBA::Short flag = 131; + // Tremporary hack until GIOP 1.2 is implemented. + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); TAO_INTERCEPTOR_CHECK; @@ -1513,7 +1593,7 @@ void ImplementationRepository::Administration::reregister_server ( { TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); } - + TAO_INTERCEPTOR ( _tao_vfr.postinvoke ( _tao_call.request_id (), @@ -1528,10 +1608,10 @@ void ImplementationRepository::Administration::reregister_server ( ); TAO_INTERCEPTOR_CHECK; break; - + } #if defined (TAO_HAS_INTERCEPTORS) - + } ACE_CATCHANY { @@ -1560,20 +1640,20 @@ void ImplementationRepository::Administration::remove_server ( ImplementationRepository::Administration::NotFound )) { - - static TAO_Exception_Data _tao_ImplementationRepository_Administration_remove_server_exceptiondata [] = + + static TAO_Exception_Data _tao_ImplementationRepository_Administration_remove_server_exceptiondata [] = { {ImplementationRepository::Administration::_tc_NotFound, ImplementationRepository::Administration::NotFound::_alloc} }; - - + + TAO_Stub *istub = this->_stubobj (); if (istub == 0) ACE_THROW (CORBA::INTERNAL ()); - + TAO_GIOP_Twoway_Invocation _tao_call ( istub, "remove_server", @@ -1616,6 +1696,8 @@ void ImplementationRepository::Administration::remove_server ( ); TAO_INTERCEPTOR_CHECK; CORBA::Short flag = 131; + // Tremporary hack until GIOP 1.2 is implemented. + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); TAO_INTERCEPTOR_CHECK; @@ -1634,7 +1716,7 @@ void ImplementationRepository::Administration::remove_server ( { TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); } - + TAO_INTERCEPTOR ( _tao_vfr.postinvoke ( _tao_call.request_id (), @@ -1649,10 +1731,10 @@ void ImplementationRepository::Administration::remove_server ( ); TAO_INTERCEPTOR_CHECK; break; - + } #if defined (TAO_HAS_INTERCEPTORS) - + } ACE_CATCHANY { @@ -1681,20 +1763,20 @@ void ImplementationRepository::Administration::shutdown_server ( ImplementationRepository::Administration::NotFound )) { - - static TAO_Exception_Data _tao_ImplementationRepository_Administration_shutdown_server_exceptiondata [] = + + static TAO_Exception_Data _tao_ImplementationRepository_Administration_shutdown_server_exceptiondata [] = { {ImplementationRepository::Administration::_tc_NotFound, ImplementationRepository::Administration::NotFound::_alloc} }; - - + + TAO_Stub *istub = this->_stubobj (); if (istub == 0) ACE_THROW (CORBA::INTERNAL ()); - + TAO_GIOP_Twoway_Invocation _tao_call ( istub, "shutdown_server", @@ -1737,6 +1819,8 @@ void ImplementationRepository::Administration::shutdown_server ( ); TAO_INTERCEPTOR_CHECK; CORBA::Short flag = 131; + // Tremporary hack until GIOP 1.2 is implemented. + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); TAO_INTERCEPTOR_CHECK; @@ -1755,7 +1839,7 @@ void ImplementationRepository::Administration::shutdown_server ( { TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); } - + TAO_INTERCEPTOR ( _tao_vfr.postinvoke ( _tao_call.request_id (), @@ -1770,10 +1854,10 @@ void ImplementationRepository::Administration::shutdown_server ( ); TAO_INTERCEPTOR_CHECK; break; - + } #if defined (TAO_HAS_INTERCEPTORS) - + } ACE_CATCHANY { @@ -1804,20 +1888,20 @@ char * ImplementationRepository::Administration::server_is_running ( ImplementationRepository::Administration::NotFound )) { - - static TAO_Exception_Data _tao_ImplementationRepository_Administration_server_is_running_exceptiondata [] = + + static TAO_Exception_Data _tao_ImplementationRepository_Administration_server_is_running_exceptiondata [] = { {ImplementationRepository::Administration::_tc_NotFound, ImplementationRepository::Administration::NotFound::_alloc} }; CORBA::String_var _tao_safe_retval; - - + + TAO_Stub *istub = this->_stubobj (); if (istub == 0) ACE_THROW_RETURN (CORBA::INTERNAL (), 0); - + TAO_GIOP_Twoway_Invocation _tao_call ( istub, "server_is_running", @@ -1860,6 +1944,8 @@ char * ImplementationRepository::Administration::server_is_running ( ); TAO_INTERCEPTOR_CHECK_RETURN (0); CORBA::Short flag = 131; + // Tremporary hack until GIOP 1.2 is implemented. + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); TAO_INTERCEPTOR_CHECK_RETURN (0); @@ -1902,10 +1988,10 @@ char * ImplementationRepository::Administration::server_is_running ( ); TAO_INTERCEPTOR_CHECK_RETURN (0); break; - + } #if defined (TAO_HAS_INTERCEPTORS) - + } ACE_CATCHANY { @@ -1934,20 +2020,20 @@ void ImplementationRepository::Administration::server_is_shutting_down ( ImplementationRepository::Administration::NotFound )) { - - static TAO_Exception_Data _tao_ImplementationRepository_Administration_server_is_shutting_down_exceptiondata [] = + + static TAO_Exception_Data _tao_ImplementationRepository_Administration_server_is_shutting_down_exceptiondata [] = { {ImplementationRepository::Administration::_tc_NotFound, ImplementationRepository::Administration::NotFound::_alloc} }; - - + + TAO_Stub *istub = this->_stubobj (); if (istub == 0) ACE_THROW (CORBA::INTERNAL ()); - + TAO_GIOP_Twoway_Invocation _tao_call ( istub, "server_is_shutting_down", @@ -1990,6 +2076,8 @@ void ImplementationRepository::Administration::server_is_shutting_down ( ); TAO_INTERCEPTOR_CHECK; CORBA::Short flag = 131; + // Tremporary hack until GIOP 1.2 is implemented. + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); TAO_INTERCEPTOR_CHECK; @@ -2008,7 +2096,7 @@ void ImplementationRepository::Administration::server_is_shutting_down ( { TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); } - + TAO_INTERCEPTOR ( _tao_vfr.postinvoke ( _tao_call.request_id (), @@ -2023,10 +2111,10 @@ void ImplementationRepository::Administration::server_is_shutting_down ( ); TAO_INTERCEPTOR_CHECK; break; - + } #if defined (TAO_HAS_INTERCEPTORS) - + } ACE_CATCHANY { @@ -2056,20 +2144,20 @@ void ImplementationRepository::Administration::find ( ImplementationRepository::Administration::NotFound )) { - - static TAO_Exception_Data _tao_ImplementationRepository_Administration_find_exceptiondata [] = + + static TAO_Exception_Data _tao_ImplementationRepository_Administration_find_exceptiondata [] = { {ImplementationRepository::Administration::_tc_NotFound, ImplementationRepository::Administration::NotFound::_alloc} }; - - + + TAO_Stub *istub = this->_stubobj (); if (istub == 0) ACE_THROW (CORBA::INTERNAL ()); - + ACE_NEW (info.ptr (), ImplementationRepository::ServerInformation); TAO_GIOP_Twoway_Invocation _tao_call ( istub, @@ -2113,12 +2201,14 @@ void ImplementationRepository::Administration::find ( ); TAO_INTERCEPTOR_CHECK; CORBA::Short flag = 131; + // Tremporary hack until GIOP 1.2 is implemented. + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); TAO_INTERCEPTOR_CHECK; TAO_OutputCDR &_tao_out = _tao_call.out_stream (); if (!( - (_tao_out << server) + (_tao_out << server) )) TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ()); int _invoke_status = @@ -2150,10 +2240,10 @@ void ImplementationRepository::Administration::find ( ); TAO_INTERCEPTOR_CHECK; break; - + } #if defined (TAO_HAS_INTERCEPTORS) - + } ACE_CATCHANY { @@ -2183,15 +2273,15 @@ void ImplementationRepository::Administration::list ( CORBA::SystemException )) { + - - - + + TAO_Stub *istub = this->_stubobj (); if (istub == 0) ACE_THROW (CORBA::INTERNAL ()); - + ACE_NEW (server_list.ptr (), ImplementationRepository::ServerInformationList); TAO_GIOP_Twoway_Invocation _tao_call ( istub, @@ -2235,12 +2325,14 @@ void ImplementationRepository::Administration::list ( ); TAO_INTERCEPTOR_CHECK; CORBA::Short flag = 131; + // Tremporary hack until GIOP 1.2 is implemented. + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); TAO_INTERCEPTOR_CHECK; TAO_OutputCDR &_tao_out = _tao_call.out_stream (); if (!( - (_tao_out << how_many) + (_tao_out << how_many) )) TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ()); int _invoke_status = @@ -2273,10 +2365,10 @@ void ImplementationRepository::Administration::list ( ); TAO_INTERCEPTOR_CHECK; break; - + } #if defined (TAO_HAS_INTERCEPTORS) - + } ACE_CATCHANY { @@ -2325,7 +2417,7 @@ ImplementationRepository::TAO_ImplementationRepository_Administration_Default_Pr ImplementationRepository::Administration_ptr ImplementationRepository::TAO_ImplementationRepository_Administration_Default_Proxy_Factory::create_proxy ( - ImplementationRepository::Administration_ptr proxy, + ::ImplementationRepository::Administration_ptr proxy, CORBA::Environment & ) { @@ -2370,7 +2462,7 @@ ImplementationRepository::TAO_ImplementationRepository_Administration_Proxy_Fact if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0) { // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it - // doesnt get into an infinite loop in <unregister_proxy_factory> as it is + // doesnt get into an infinite loop in <unregister_proxy_factory> as it is // invoked in the destructor of the class too. this->delete_proxy_factory_ = 1; delete this->proxy_factory_; @@ -2381,23 +2473,23 @@ return 0; ImplementationRepository::Administration_ptr ImplementationRepository::TAO_ImplementationRepository_Administration_Proxy_Factory_Adapter::create_proxy ( - ImplementationRepository::Administration_ptr proxy, - CORBA::Environment & - ) + ::ImplementationRepository::Administration_ptr proxy, + CORBA::Environment & + ) { ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, this->lock_, 0)); // Verify that an <proxy_factory_> is available else make one. if (this->proxy_factory_ == 0) ACE_NEW_RETURN (this->proxy_factory_, - TAO_ImplementationRepository_Administration_Default_Proxy_Factory (1), + TAO_ImplementationRepository_Administration_Default_Proxy_Factory (1), 0); - - + + return this->proxy_factory_->create_proxy (proxy); } -ImplementationRepository::TAO_ImplementationRepository_Administration_Smart_Proxy_Base::TAO_ImplementationRepository_Administration_Smart_Proxy_Base (ImplementationRepository::Administration_ptr proxy) +ImplementationRepository::TAO_ImplementationRepository_Administration_Smart_Proxy_Base::TAO_ImplementationRepository_Administration_Smart_Proxy_Base (::ImplementationRepository::Administration_ptr proxy) : base_proxy_ (proxy) { } @@ -2581,18 +2673,24 @@ TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) TAO_NAMESPACE_BEGIN (ImplementationRepository) TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Administration, &_tc_TAO_tc_ImplementationRepository_Administration) TAO_NAMESPACE_END +void ImplementationRepository::ServerInformationIterator::_tao_any_destructor (void *x) +{ + ImplementationRepository::ServerInformationIterator *tmp = ACE_static_cast (ImplementationRepository::ServerInformationIterator*,x); + CORBA::release (tmp); +} + ImplementationRepository::ServerInformationIterator_ptr ImplementationRepository::ServerInformationIterator::_narrow ( CORBA::Object_ptr obj, CORBA::Environment &ACE_TRY_ENV ) { if (CORBA::is_nil (obj)) - return ImplementationRepository::ServerInformationIterator::_nil (); + return ServerInformationIterator::_nil (); CORBA::Boolean is_a = obj->_is_a ("IDL:ImplementationRepository/ServerInformationIterator:1.0", ACE_TRY_ENV); - ACE_CHECK_RETURN (ImplementationRepository::ServerInformationIterator::_nil ()); + ACE_CHECK_RETURN (ServerInformationIterator::_nil ()); if (is_a == 0) - return ImplementationRepository::ServerInformationIterator::_nil (); - return ImplementationRepository::ServerInformationIterator::_unchecked_narrow (obj, ACE_TRY_ENV); + return ServerInformationIterator::_nil (); + return ServerInformationIterator::_unchecked_narrow (obj, ACE_TRY_ENV); } ImplementationRepository::ServerInformationIterator_ptr ImplementationRepository::ServerInformationIterator::_unchecked_narrow ( @@ -2601,21 +2699,21 @@ ImplementationRepository::ServerInformationIterator_ptr ImplementationRepository ) { if (CORBA::is_nil (obj)) - return ImplementationRepository::ServerInformationIterator::_nil (); + return ServerInformationIterator::_nil (); TAO_Stub* stub = obj->_stubobj (); stub->_incr_refcnt (); - ImplementationRepository::ServerInformationIterator_ptr default_proxy = ImplementationRepository::ServerInformationIterator::_nil (); + ServerInformationIterator_ptr default_proxy = ServerInformationIterator::_nil (); if (obj->_is_collocated () && _TAO_collocation_ImplementationRepository_ServerInformationIterator_Stub_Factory_function_pointer != 0) { default_proxy = _TAO_collocation_ImplementationRepository_ServerInformationIterator_Stub_Factory_function_pointer (obj); } if (CORBA::is_nil (default_proxy)) - ACE_NEW_RETURN (default_proxy, ImplementationRepository::ServerInformationIterator (stub), ImplementationRepository::ServerInformationIterator::_nil ()); + ACE_NEW_RETURN (default_proxy, ServerInformationIterator (stub), ServerInformationIterator::_nil ()); return TAO_ImplementationRepository_ServerInformationIterator_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy); } -ImplementationRepository::ServerInformationIterator_ptr -ImplementationRepository::ServerInformationIterator::_duplicate (ImplementationRepository::ServerInformationIterator_ptr obj) +ImplementationRepository::ServerInformationIterator_ptr +ImplementationRepository::ServerInformationIterator::_duplicate (ServerInformationIterator_ptr obj) { if (!CORBA::is_nil (obj)) obj->_incr_refcnt (); @@ -2631,15 +2729,15 @@ CORBA::Boolean ImplementationRepository::ServerInformationIterator::next_n ( CORBA::SystemException )) { - + CORBA::Boolean _tao_retval = 0; - - + + TAO_Stub *istub = this->_stubobj (); if (istub == 0) ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval); - + ACE_NEW_RETURN (server_list.ptr (), ImplementationRepository::ServerInformationList, _tao_retval); TAO_GIOP_Twoway_Invocation _tao_call ( istub, @@ -2683,12 +2781,14 @@ CORBA::Boolean ImplementationRepository::ServerInformationIterator::next_n ( ); TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval); CORBA::Short flag = 131; + // Tremporary hack until GIOP 1.2 is implemented. + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval); TAO_OutputCDR &_tao_out = _tao_call.out_stream (); if (!( - (_tao_out << how_many) + (_tao_out << how_many) )) TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), _tao_retval); @@ -2724,10 +2824,10 @@ CORBA::Boolean ImplementationRepository::ServerInformationIterator::next_n ( ); TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval); break; - + } #if defined (TAO_HAS_INTERCEPTORS) - + } ACE_CATCHANY { @@ -2754,15 +2854,15 @@ void ImplementationRepository::ServerInformationIterator::destroy ( CORBA::SystemException )) { + - - - + + TAO_Stub *istub = this->_stubobj (); if (istub == 0) ACE_THROW (CORBA::INTERNAL ()); - + TAO_GIOP_Twoway_Invocation _tao_call ( istub, "destroy", @@ -2805,6 +2905,8 @@ void ImplementationRepository::ServerInformationIterator::destroy ( ); TAO_INTERCEPTOR_CHECK; CORBA::Short flag = 131; + // Tremporary hack until GIOP 1.2 is implemented. + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); TAO_INTERCEPTOR_CHECK; @@ -2818,7 +2920,7 @@ void ImplementationRepository::ServerInformationIterator::destroy ( { TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); } - + TAO_INTERCEPTOR ( _tao_vfr.postinvoke ( _tao_call.request_id (), @@ -2833,10 +2935,10 @@ void ImplementationRepository::ServerInformationIterator::destroy ( ); TAO_INTERCEPTOR_CHECK; break; - + } #if defined (TAO_HAS_INTERCEPTORS) - + } ACE_CATCHANY { @@ -2885,7 +2987,7 @@ ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator ImplementationRepository::ServerInformationIterator_ptr ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator_Default_Proxy_Factory::create_proxy ( - ImplementationRepository::ServerInformationIterator_ptr proxy, + ::ImplementationRepository::ServerInformationIterator_ptr proxy, CORBA::Environment & ) { @@ -2930,7 +3032,7 @@ ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0) { // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it - // doesnt get into an infinite loop in <unregister_proxy_factory> as it is + // doesnt get into an infinite loop in <unregister_proxy_factory> as it is // invoked in the destructor of the class too. this->delete_proxy_factory_ = 1; delete this->proxy_factory_; @@ -2941,23 +3043,23 @@ return 0; ImplementationRepository::ServerInformationIterator_ptr ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator_Proxy_Factory_Adapter::create_proxy ( - ImplementationRepository::ServerInformationIterator_ptr proxy, - CORBA::Environment & - ) + ::ImplementationRepository::ServerInformationIterator_ptr proxy, + CORBA::Environment & + ) { ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, this->lock_, 0)); // Verify that an <proxy_factory_> is available else make one. if (this->proxy_factory_ == 0) ACE_NEW_RETURN (this->proxy_factory_, - TAO_ImplementationRepository_ServerInformationIterator_Default_Proxy_Factory (1), + TAO_ImplementationRepository_ServerInformationIterator_Default_Proxy_Factory (1), 0); - - + + return this->proxy_factory_->create_proxy (proxy); } -ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator_Smart_Proxy_Base::TAO_ImplementationRepository_ServerInformationIterator_Smart_Proxy_Base (ImplementationRepository::ServerInformationIterator_ptr proxy) +ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator_Smart_Proxy_Base::TAO_ImplementationRepository_ServerInformationIterator_Smart_Proxy_Base (::ImplementationRepository::ServerInformationIterator_ptr proxy) : base_proxy_ (proxy) { } @@ -3019,47 +3121,28 @@ ImplementationRepository::ServerObject_ptr (*_TAO_collocation_ImplementationRepo ) = 0; void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ServerObject_ptr _tao_elem) { - CORBA::Object_ptr *_tao_obj_ptr = 0; - ACE_TRY_NEW_ENV + TAO_OutputCDR stream; + if (stream << _tao_elem) { - ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); - *_tao_obj_ptr = ImplementationRepository::ServerObject::_duplicate (_tao_elem); - 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 - { - delete _tao_obj_ptr; + _tao_any._tao_replace ( + ImplementationRepository::_tc_ServerObject, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + ImplementationRepository::ServerObject::_duplicate (_tao_elem), + ImplementationRepository::ServerObject::_tao_any_destructor + ); } - ACE_ENDTRY; } 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)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -3072,24 +3155,18 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository { _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)->_tao_replace ( ImplementationRepository::_tc_ServerObject, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + ImplementationRepository::ServerObject::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = ImplementationRepository::ServerObject::_nil (); return 0; } @@ -3109,151 +3186,80 @@ 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 = 0; - ACE_NEW (_any_val, ImplementationRepository::EnvironmentVariable (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { - 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 - { - delete _any_val; - } - ACE_ENDTRY; + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + ImplementationRepository::_tc_EnvironmentVariable, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); } void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::EnvironmentVariable *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { - 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 - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + ImplementationRepository::_tc_EnvironmentVariable, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + ImplementationRepository::EnvironmentVariable::_tao_any_destructor + ); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, 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 >> *_tao_elem) - { - ((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; - _tao_elem = 0; - return 0; - } - ACE_ENDTRY; - return 0; + return _tao_any >>= ACE_const_cast(ImplementationRepository::EnvironmentVariable*&,_tao_elem); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::EnvironmentVariable *&_tao_elem) { + _tao_elem = 0; 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 (); + _tao_elem = ACE_static_cast( + const ImplementationRepository::EnvironmentVariable*, + _tao_any.value () + ); return 1; - } + } else { - ACE_NEW_RETURN (_tao_elem, ImplementationRepository::EnvironmentVariable, 0); + ImplementationRepository::EnvironmentVariable *tmp; + ACE_NEW_RETURN (tmp, ImplementationRepository::EnvironmentVariable, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); - if (stream >> *(ImplementationRepository::EnvironmentVariable *)_tao_elem) + if (stream >> *tmp) { ((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_static_cast (void *, tmp), + ImplementationRepository::EnvironmentVariable::_tao_any_destructor ); - ACE_TRY_CHECK; + _tao_elem = tmp; return 1; } else { - delete ACE_const_cast (ImplementationRepository::EnvironmentVariable *&, _tao_elem); - _tao_elem = 0; + delete tmp; } } } ACE_CATCHANY { - delete ACE_const_cast (ImplementationRepository::EnvironmentVariable *&, _tao_elem); - _tao_elem = 0; - return 0; } ACE_ENDTRY; return 0; @@ -3264,157 +3270,85 @@ void operator<<= ( const ImplementationRepository::EnvironmentList &_tao_elem ) // copying { - ImplementationRepository::EnvironmentList *_tao_any_val; - ACE_NEW (_tao_any_val, ImplementationRepository::EnvironmentList (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { - 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 - { - delete _tao_any_val; - } - ACE_ENDTRY; -} - -void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::EnvironmentList *_tao_elem) // non copying -{ - ACE_TRY_NEW_ENV + TAO_OutputCDR stream; + if (stream << _tao_elem) { - 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 + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; } - ACE_ENDTRY; +} + +void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::EnvironmentList *_tao_elem) // non copying +{ + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + ImplementationRepository::_tc_EnvironmentList, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + ImplementationRepository::EnvironmentList::_tao_any_destructor + ); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, 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 >> *_tao_elem) - { - ((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; - _tao_elem = 0; - return 0; - } - ACE_ENDTRY; - return 0; + return _tao_any >>= ACE_const_cast( + const ImplementationRepository::EnvironmentList*&, + _tao_elem + ); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::EnvironmentList *&_tao_elem) { + _tao_elem = 0; 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 (); + _tao_elem = ACE_static_cast( + const ImplementationRepository::EnvironmentList*, + _tao_any.value () + ); return 1; } else { - ACE_NEW_RETURN (_tao_elem, ImplementationRepository::EnvironmentList, 0); + ImplementationRepository::EnvironmentList *tmp; + ACE_NEW_RETURN (tmp, ImplementationRepository::EnvironmentList, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); - if (stream >> *(ImplementationRepository::EnvironmentList *)_tao_elem) + if (stream >> *tmp) { ((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_static_cast (void *, tmp), + ImplementationRepository::EnvironmentList::_tao_any_destructor ); - ACE_TRY_CHECK; + _tao_elem = tmp; return 1; } else { - delete ACE_const_cast (ImplementationRepository::EnvironmentList *&, _tao_elem); - _tao_elem = 0; + delete tmp; } } } ACE_CATCHANY { - delete ACE_const_cast (ImplementationRepository::EnvironmentList *&, _tao_elem); - _tao_elem = 0; - return 0; } ACE_ENDTRY; return 0; @@ -3422,29 +3356,13 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepo void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ActivationMode _tao_elem) { - ImplementationRepository::ActivationMode *_tao_any_val; - ACE_NEW (_tao_any_val, ImplementationRepository::ActivationMode (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_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 _tao_any_val; - } - ACE_ENDTRY; + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + ImplementationRepository::_tc_ActivationMode, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::ActivationMode &_tao_elem) @@ -3476,151 +3394,80 @@ 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 = 0; - ACE_NEW (_any_val, ImplementationRepository::StartupOptions (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { - 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 - { - delete _any_val; - } - ACE_ENDTRY; + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + ImplementationRepository::_tc_StartupOptions, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); } void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::StartupOptions *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { - 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 - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + ImplementationRepository::_tc_StartupOptions, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + ImplementationRepository::StartupOptions::_tao_any_destructor + ); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, 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 >> *_tao_elem) - { - ((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; - _tao_elem = 0; - return 0; - } - ACE_ENDTRY; - return 0; + return _tao_any >>= ACE_const_cast(ImplementationRepository::StartupOptions*&,_tao_elem); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::StartupOptions *&_tao_elem) { + _tao_elem = 0; 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 (); + _tao_elem = ACE_static_cast( + const ImplementationRepository::StartupOptions*, + _tao_any.value () + ); return 1; - } + } else { - ACE_NEW_RETURN (_tao_elem, ImplementationRepository::StartupOptions, 0); + ImplementationRepository::StartupOptions *tmp; + ACE_NEW_RETURN (tmp, ImplementationRepository::StartupOptions, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); - if (stream >> *(ImplementationRepository::StartupOptions *)_tao_elem) + if (stream >> *tmp) { ((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_static_cast (void *, tmp), + ImplementationRepository::StartupOptions::_tao_any_destructor ); - ACE_TRY_CHECK; + _tao_elem = tmp; return 1; } else { - delete ACE_const_cast (ImplementationRepository::StartupOptions *&, _tao_elem); - _tao_elem = 0; + delete tmp; } } } ACE_CATCHANY { - delete ACE_const_cast (ImplementationRepository::StartupOptions *&, _tao_elem); - _tao_elem = 0; - return 0; } ACE_ENDTRY; return 0; @@ -3628,151 +3475,80 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepo void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::ServerInformation &_tao_elem) // copying { - ImplementationRepository::ServerInformation *_any_val = 0; - ACE_NEW (_any_val, ImplementationRepository::ServerInformation (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { - 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 - { - delete _any_val; - } - ACE_ENDTRY; + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + ImplementationRepository::_tc_ServerInformation, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); } void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ServerInformation *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { - 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 - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + ImplementationRepository::_tc_ServerInformation, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + ImplementationRepository::ServerInformation::_tao_any_destructor + ); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, 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 >> *_tao_elem) - { - ((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; - _tao_elem = 0; - return 0; - } - ACE_ENDTRY; - return 0; + return _tao_any >>= ACE_const_cast(ImplementationRepository::ServerInformation*&,_tao_elem); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::ServerInformation *&_tao_elem) { + _tao_elem = 0; 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 (); + _tao_elem = ACE_static_cast( + const ImplementationRepository::ServerInformation*, + _tao_any.value () + ); return 1; - } + } else { - ACE_NEW_RETURN (_tao_elem, ImplementationRepository::ServerInformation, 0); + ImplementationRepository::ServerInformation *tmp; + ACE_NEW_RETURN (tmp, ImplementationRepository::ServerInformation, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); - if (stream >> *(ImplementationRepository::ServerInformation *)_tao_elem) + if (stream >> *tmp) { ((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_static_cast (void *, tmp), + ImplementationRepository::ServerInformation::_tao_any_destructor ); - ACE_TRY_CHECK; + _tao_elem = tmp; return 1; } else { - delete ACE_const_cast (ImplementationRepository::ServerInformation *&, _tao_elem); - _tao_elem = 0; + delete tmp; } } } ACE_CATCHANY { - delete ACE_const_cast (ImplementationRepository::ServerInformation *&, _tao_elem); - _tao_elem = 0; - return 0; } ACE_ENDTRY; return 0; @@ -3783,157 +3559,85 @@ void operator<<= ( const ImplementationRepository::ServerInformationList &_tao_elem ) // copying { - ImplementationRepository::ServerInformationList *_tao_any_val; - ACE_NEW (_tao_any_val, ImplementationRepository::ServerInformationList (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV + TAO_OutputCDR stream; + if (stream << _tao_elem) { - 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 - { - delete _tao_any_val; - } - ACE_ENDTRY; -} - -void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ServerInformationList *_tao_elem) // non copying -{ - ACE_TRY_NEW_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 + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; } - ACE_ENDTRY; +} + +void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ServerInformationList *_tao_elem) // non copying +{ + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + ImplementationRepository::_tc_ServerInformationList, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + ImplementationRepository::ServerInformationList::_tao_any_destructor + ); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, 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 >> *_tao_elem) - { - ((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; - _tao_elem = 0; - return 0; - } - ACE_ENDTRY; - return 0; + return _tao_any >>= ACE_const_cast( + const ImplementationRepository::ServerInformationList*&, + _tao_elem + ); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::ServerInformationList *&_tao_elem) { + _tao_elem = 0; 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 (); + _tao_elem = ACE_static_cast( + const ImplementationRepository::ServerInformationList*, + _tao_any.value () + ); return 1; } else { - ACE_NEW_RETURN (_tao_elem, ImplementationRepository::ServerInformationList, 0); + ImplementationRepository::ServerInformationList *tmp; + ACE_NEW_RETURN (tmp, ImplementationRepository::ServerInformationList, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); - if (stream >> *(ImplementationRepository::ServerInformationList *)_tao_elem) + if (stream >> *tmp) { ((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_static_cast (void *, tmp), + ImplementationRepository::ServerInformationList::_tao_any_destructor ); - ACE_TRY_CHECK; + _tao_elem = tmp; return 1; } else { - delete ACE_const_cast (ImplementationRepository::ServerInformationList *&, _tao_elem); - _tao_elem = 0; + delete tmp; } } } ACE_CATCHANY { - delete ACE_const_cast (ImplementationRepository::ServerInformationList *&, _tao_elem); - _tao_elem = 0; - return 0; } ACE_ENDTRY; return 0; @@ -3944,47 +3648,28 @@ ImplementationRepository::Administration_ptr (*_TAO_collocation_ImplementationRe ) = 0; void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::Administration_ptr _tao_elem) { - CORBA::Object_ptr *_tao_obj_ptr = 0; - ACE_TRY_NEW_ENV + TAO_OutputCDR stream; + if (stream << _tao_elem) { - ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); - *_tao_obj_ptr = ImplementationRepository::Administration::_duplicate (_tao_elem); - 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 - { - delete _tao_obj_ptr; + _tao_any._tao_replace ( + ImplementationRepository::_tc_Administration, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + ImplementationRepository::Administration::_duplicate (_tao_elem), + ImplementationRepository::Administration::_tao_any_destructor + ); } - ACE_ENDTRY; } 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)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -3997,24 +3682,18 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository { _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)->_tao_replace ( ImplementationRepository::_tc_Administration, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + ImplementationRepository::Administration::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = ImplementationRepository::Administration::_nil (); return 0; } @@ -4034,113 +3713,45 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::Administration::AlreadyRegistered &_tao_elem) // copying { - 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_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 - { - delete _tao_any_val; - } - ACE_ENDTRY; + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + ImplementationRepository::Administration::_tc_AlreadyRegistered, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); } void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::Administration::AlreadyRegistered *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { - 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 - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + ImplementationRepository::Administration::_tc_AlreadyRegistered, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + ImplementationRepository::Administration::AlreadyRegistered::_tao_any_destructor + ); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, 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 >> *_tao_elem) - { - ((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; - _tao_elem = 0; - return 0; - } - ACE_ENDTRY; - return 0; + return _tao_any >>= ACE_const_cast( + const ImplementationRepository::Administration::AlreadyRegistered*&, + _tao_elem + ); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::Administration::AlreadyRegistered *&_tao_elem) { + _tao_elem = 0; 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; @@ -4151,34 +3762,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepo } else { - ACE_NEW_RETURN (_tao_elem, ImplementationRepository::Administration::AlreadyRegistered, 0); + ImplementationRepository::Administration::AlreadyRegistered *tmp; + ACE_NEW_RETURN (tmp, ImplementationRepository::Administration::AlreadyRegistered, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); - if (stream >> *(ImplementationRepository::Administration::AlreadyRegistered *)_tao_elem) + if (stream >> *tmp) { ((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 + tmp, + ImplementationRepository::Administration::AlreadyRegistered::_tao_any_destructor ); - ACE_TRY_CHECK; + _tao_elem = tmp; return 1; } else { - delete ACE_const_cast (ImplementationRepository::Administration::AlreadyRegistered *&, _tao_elem); - _tao_elem = 0; + delete tmp; } } } ACE_CATCHANY { - delete ACE_const_cast (ImplementationRepository::Administration::AlreadyRegistered *&, _tao_elem); - _tao_elem = 0; - return 0; } ACE_ENDTRY; return 0; @@ -4186,113 +3794,45 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepo void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::Administration::CannotActivate &_tao_elem) // copying { - 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_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 - { - delete _tao_any_val; - } - ACE_ENDTRY; + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + ImplementationRepository::Administration::_tc_CannotActivate, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); } void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::Administration::CannotActivate *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { - 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 - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + ImplementationRepository::Administration::_tc_CannotActivate, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + ImplementationRepository::Administration::CannotActivate::_tao_any_destructor + ); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, 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 >> *_tao_elem) - { - ((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; - _tao_elem = 0; - return 0; - } - ACE_ENDTRY; - return 0; + return _tao_any >>= ACE_const_cast( + const ImplementationRepository::Administration::CannotActivate*&, + _tao_elem + ); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::Administration::CannotActivate *&_tao_elem) { + _tao_elem = 0; 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; @@ -4303,34 +3843,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepo } else { - ACE_NEW_RETURN (_tao_elem, ImplementationRepository::Administration::CannotActivate, 0); + ImplementationRepository::Administration::CannotActivate *tmp; + ACE_NEW_RETURN (tmp, ImplementationRepository::Administration::CannotActivate, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); - if (stream >> *(ImplementationRepository::Administration::CannotActivate *)_tao_elem) + if (stream >> *tmp) { ((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 + tmp, + ImplementationRepository::Administration::CannotActivate::_tao_any_destructor ); - ACE_TRY_CHECK; + _tao_elem = tmp; return 1; } else { - delete ACE_const_cast (ImplementationRepository::Administration::CannotActivate *&, _tao_elem); - _tao_elem = 0; + delete tmp; } } } ACE_CATCHANY { - delete ACE_const_cast (ImplementationRepository::Administration::CannotActivate *&, _tao_elem); - _tao_elem = 0; - return 0; } ACE_ENDTRY; return 0; @@ -4338,113 +3875,45 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepo void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::Administration::NotFound &_tao_elem) // copying { - 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_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 - { - delete _tao_any_val; - } - ACE_ENDTRY; + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + ImplementationRepository::Administration::_tc_NotFound, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); } void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::Administration::NotFound *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { - 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 - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + ImplementationRepository::Administration::_tc_NotFound, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + ImplementationRepository::Administration::NotFound::_tao_any_destructor + ); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, 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 >> *_tao_elem) - { - ((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; - _tao_elem = 0; - return 0; - } - ACE_ENDTRY; - return 0; + return _tao_any >>= ACE_const_cast( + const ImplementationRepository::Administration::NotFound*&, + _tao_elem + ); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::Administration::NotFound *&_tao_elem) { + _tao_elem = 0; 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; @@ -4455,34 +3924,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepo } else { - ACE_NEW_RETURN (_tao_elem, ImplementationRepository::Administration::NotFound, 0); + ImplementationRepository::Administration::NotFound *tmp; + ACE_NEW_RETURN (tmp, ImplementationRepository::Administration::NotFound, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); - if (stream >> *(ImplementationRepository::Administration::NotFound *)_tao_elem) + if (stream >> *tmp) { ((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 + tmp, + ImplementationRepository::Administration::NotFound::_tao_any_destructor ); - ACE_TRY_CHECK; + _tao_elem = tmp; return 1; } else { - delete ACE_const_cast (ImplementationRepository::Administration::NotFound *&, _tao_elem); - _tao_elem = 0; + delete tmp; } } } ACE_CATCHANY { - delete ACE_const_cast (ImplementationRepository::Administration::NotFound *&, _tao_elem); - _tao_elem = 0; - return 0; } ACE_ENDTRY; return 0; @@ -4493,47 +3959,28 @@ ImplementationRepository::ServerInformationIterator_ptr (*_TAO_collocation_Imple ) = 0; void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ServerInformationIterator_ptr _tao_elem) { - CORBA::Object_ptr *_tao_obj_ptr = 0; - ACE_TRY_NEW_ENV + TAO_OutputCDR stream; + if (stream << _tao_elem) { - ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); - *_tao_obj_ptr = ImplementationRepository::ServerInformationIterator::_duplicate (_tao_elem); - 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 - { - delete _tao_obj_ptr; + _tao_any._tao_replace ( + ImplementationRepository::_tc_ServerInformationIterator, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + ImplementationRepository::ServerInformationIterator::_duplicate (_tao_elem), + ImplementationRepository::ServerInformationIterator::_tao_any_destructor + ); } - ACE_ENDTRY; } 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)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -4546,24 +3993,18 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository { _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)->_tao_replace ( ImplementationRepository::_tc_ServerInformationIterator, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + ImplementationRepository::ServerInformationIterator::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = ImplementationRepository::ServerInformationIterator::_nil (); return 0; } @@ -4609,6 +4050,9 @@ CORBA::Boolean operator>> ( { // 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++) @@ -4648,6 +4092,9 @@ CORBA::Boolean operator>> ( { // 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++) @@ -4658,3 +4105,4 @@ CORBA::Boolean operator>> ( } return 0; // error } + diff --git a/TAO/tao/ImplRepoC.h b/TAO/tao/ImplRepoC.h index 1eded2ec089..23b5bd2ec1d 100644 --- a/TAO/tao/ImplRepoC.h +++ b/TAO/tao/ImplRepoC.h @@ -11,26 +11,16 @@ #include "ace/pre.h" #define _TAO_IDL_IMPLREPOC_H_ -#include "tao/Object.h" -#include "tao/Managed_Types.h" -#include "tao/POAC.h" -#include "tao/Servant_Base.h" -#include "tao/Operation_Table.h" -#include "tao/Stub.h" -#include "tao/ORB_Core.h" -#include "tao/Server_Request.h" -#include "tao/NVList.h" -#include "tao/Object_Adapter.h" -#include "tao/Invocation.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ +#include "tao/corba.h" #if defined (ACE_HAS_MINIMUM_IOSTREAMH_INCLUSION) #include "ace/streams.h" #endif /* ACE_HAS_MINIMUM_IOSTREAMH_INCLUSION */ +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + #if defined (TAO_EXPORT_MACRO) #undef TAO_EXPORT_MACRO @@ -59,7 +49,7 @@ TAO_NAMESPACE ImplementationRepository class ServerObject; typedef ServerObject *ServerObject_ptr; - + #endif /* end #if !defined */ @@ -73,14 +63,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); @@ -110,7 +100,7 @@ TAO_NAMESPACE ImplementationRepository operator ServerObject_ptr &(); ServerObject_ptr &ptr (void); ServerObject_ptr operator-> (void); - + private: ServerObject_ptr &ptr_; }; @@ -134,21 +124,23 @@ 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) { - return (ImplementationRepository::ServerObject_ptr)0; + return (ServerObject_ptr)0; } + static void _tao_any_destructor (void*); + virtual void ping ( - CORBA::Environment &ACE_TRY_ENV = + CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ) ACE_THROW_SPEC (( @@ -156,7 +148,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 (( @@ -164,16 +156,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); @@ -185,14 +177,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 = + + virtual ServerObject_ptr create_proxy ( + ServerObject_ptr proxy, + CORBA::Environment &env = TAO_default_environment () ); }; @@ -200,23 +192,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 = + + ServerObject_ptr create_proxy ( + ServerObject_ptr proxy, + CORBA::Environment &env = TAO_default_environment () ); @@ -232,13 +224,13 @@ protected: }; typedef ACE_Singleton<TAO_ImplementationRepository_ServerObject_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_ImplementationRepository_ServerObject_PROXY_FACTORY_ADAPTER; - class TAO_ImplementationRepository_ServerObject_Smart_Proxy_Base : public virtual ImplementationRepository::ServerObject + class TAO_ImplementationRepository_ServerObject_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (ImplementationRepository, ServerObject) { public: - TAO_ImplementationRepository_ServerObject_Smart_Proxy_Base (ImplementationRepository::ServerObject_ptr proxy); + 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 (( @@ -246,7 +238,7 @@ protected: )); virtual void shutdown ( - CORBA::Environment &ACE_TRY_ENV = + CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ) ACE_THROW_SPEC (( @@ -254,7 +246,7 @@ protected: )); private: - ImplementationRepository::ServerObject_var base_proxy_; + ::ImplementationRepository::ServerObject_var base_proxy_; }; @@ -264,16 +256,16 @@ TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ServerObject; struct EnvironmentVariable; class EnvironmentVariable_var; -typedef EnvironmentVariable* EnvironmentVariable_ptr; struct TAO_Export EnvironmentVariable { #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) - typedef EnvironmentVariable_ptr _ptr_type; typedef EnvironmentVariable_var _var_type; #endif /* ! __GNUC__ || g++ >= 2.8 */ + static void _tao_any_destructor (void*); + TAO_String_Manager name; TAO_String_Manager value; }; @@ -285,16 +277,18 @@ 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 + operator EnvironmentVariable *&(); // variable-size types only + + // in, inout, out, _retn const EnvironmentVariable &in (void) const; EnvironmentVariable &inout (void); EnvironmentVariable *&out (void); @@ -316,7 +310,7 @@ public: operator EnvironmentVariable *&(); EnvironmentVariable *&ptr (void); EnvironmentVariable *operator-> (void); - + private: EnvironmentVariable *&ptr_; // assignment from T_var not allowed @@ -332,7 +326,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_ @@ -340,9 +334,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, @@ -359,7 +353,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, @@ -371,7 +365,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_ @@ -384,24 +378,25 @@ 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 - ~EnvironmentList (void); // dtor + ~EnvironmentList (void); + static void _tao_any_destructor (void*); #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) typedef EnvironmentList_ptr _ptr_type; @@ -427,17 +422,19 @@ 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; + operator EnvironmentList *&(); // variable-size base types only + EnvironmentVariable &operator[] (CORBA::ULong index); - // in, inout, out, _retn + // in, inout, out, _retn const EnvironmentList &in (void) const; EnvironmentList &inout (void); EnvironmentList *&out (void); @@ -467,7 +464,7 @@ public: EnvironmentList *&ptr (void); EnvironmentList *operator-> (void); EnvironmentVariable &operator[] (CORBA::ULong index); - + private: EnvironmentList *&ptr_; // assignment from T_var not allowed @@ -492,20 +489,20 @@ TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ActivationMode; struct StartupOptions; class StartupOptions_var; -typedef StartupOptions* StartupOptions_ptr; struct TAO_Export StartupOptions { #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) - typedef StartupOptions_ptr _ptr_type; typedef StartupOptions_var _var_type; #endif /* ! __GNUC__ || g++ >= 2.8 */ + static void _tao_any_destructor (void*); + TAO_String_Manager command_line; - ImplementationRepository::EnvironmentList environment; + ACE_NESTED_CLASS (ImplementationRepository, EnvironmentList) environment; TAO_String_Manager working_directory; - ImplementationRepository::ActivationMode activation; + ACE_NESTED_CLASS (ImplementationRepository, ActivationMode) activation; }; class TAO_Export StartupOptions_var @@ -515,16 +512,18 @@ 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 + operator StartupOptions *&(); // variable-size types only + + // in, inout, out, _retn const StartupOptions &in (void) const; StartupOptions &inout (void); StartupOptions *&out (void); @@ -546,7 +545,7 @@ public: operator StartupOptions *&(); StartupOptions *&ptr (void); StartupOptions *operator-> (void); - + private: StartupOptions *&ptr_; // assignment from T_var not allowed @@ -557,19 +556,19 @@ TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_StartupOptions; struct ServerInformation; class ServerInformation_var; -typedef ServerInformation* ServerInformation_ptr; struct TAO_Export ServerInformation { #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) - typedef ServerInformation_ptr _ptr_type; typedef ServerInformation_var _var_type; #endif /* ! __GNUC__ || g++ >= 2.8 */ + static void _tao_any_destructor (void*); + TAO_String_Manager logical_server; TAO_String_Manager server; - ImplementationRepository::StartupOptions startup; + ACE_NESTED_CLASS (ImplementationRepository, StartupOptions) startup; TAO_String_Manager location; }; @@ -580,16 +579,18 @@ 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 + operator ServerInformation *&(); // variable-size types only + + // in, inout, out, _retn const ServerInformation &in (void) const; ServerInformation &inout (void); ServerInformation *&out (void); @@ -611,7 +612,7 @@ public: operator ServerInformation *&(); ServerInformation *&ptr (void); ServerInformation *operator-> (void); - + private: ServerInformation *&ptr_; // assignment from T_var not allowed @@ -622,7 +623,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_ @@ -630,9 +631,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, @@ -649,7 +650,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, @@ -661,7 +662,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_ @@ -674,24 +675,25 @@ 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 - ~ServerInformationList (void); // dtor + ~ServerInformationList (void); + static void _tao_any_destructor (void*); #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) typedef ServerInformationList_ptr _ptr_type; @@ -717,17 +719,19 @@ 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; + operator ServerInformationList *&(); // variable-size base types only + ServerInformation &operator[] (CORBA::ULong index); - // in, inout, out, _retn + // in, inout, out, _retn const ServerInformationList &in (void) const; ServerInformationList &inout (void); ServerInformationList *&out (void); @@ -757,7 +761,7 @@ public: ServerInformationList *&ptr (void); ServerInformationList *operator-> (void); ServerInformation &operator[] (CORBA::ULong index); - + private: ServerInformationList *&ptr_; // assignment from T_var not allowed @@ -789,14 +793,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); @@ -826,7 +830,7 @@ public: operator ServerInformationIterator_ptr &(); ServerInformationIterator_ptr &ptr (void); ServerInformationIterator_ptr operator-> (void); - + private: ServerInformationIterator_ptr &ptr_; }; @@ -854,14 +858,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); @@ -891,7 +895,7 @@ public: operator Administration_ptr &(); Administration_ptr &ptr (void); Administration_ptr operator-> (void); - + private: Administration_ptr &ptr_; }; @@ -915,26 +919,28 @@ 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) { - return (ImplementationRepository::Administration_ptr)0; + return (Administration_ptr)0; } + static void _tao_any_destructor (void*); + #if !defined (_IMPLEMENTATIONREPOSITORY_ADMINISTRATION_ALREADYREGISTERED___PTR_CH_) #define _IMPLEMENTATIONREPOSITORY_ADMINISTRATION_ALREADYREGISTERED___PTR_CH_ class AlreadyRegistered; typedef AlreadyRegistered *AlreadyRegistered_ptr; - + #endif /* end #if !defined */ @@ -952,16 +958,19 @@ public: AlreadyRegistered (void); // default ctor AlreadyRegistered (const AlreadyRegistered &); // copy ctor - ~AlreadyRegistered (void); // dtor + ~AlreadyRegistered (void); + static void _tao_any_destructor (void*); AlreadyRegistered &operator= (const AlreadyRegistered &); virtual void _raise (void); - virtual void _tao_encode (TAO_OutputCDR &cdr, - CORBA::Environment &) const; - virtual void _tao_decode (TAO_InputCDR &cdr, - CORBA::Environment &); + virtual void _tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &) const; + virtual void _tao_decode ( + TAO_InputCDR &, + CORBA::Environment &); static AlreadyRegistered *_narrow (CORBA::Exception *); @@ -982,7 +991,7 @@ public: class CannotActivate; typedef CannotActivate *CannotActivate_ptr; - + #endif /* end #if !defined */ @@ -1001,16 +1010,19 @@ public: CannotActivate (void); // default ctor CannotActivate (const CannotActivate &); // copy ctor - ~CannotActivate (void); // dtor + ~CannotActivate (void); + static void _tao_any_destructor (void*); CannotActivate &operator= (const CannotActivate &); virtual void _raise (void); - virtual void _tao_encode (TAO_OutputCDR &cdr, - CORBA::Environment &) const; - virtual void _tao_decode (TAO_InputCDR &cdr, - CORBA::Environment &); + virtual void _tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &) const; + virtual void _tao_decode ( + TAO_InputCDR &, + CORBA::Environment &); static CannotActivate *_narrow (CORBA::Exception *); @@ -1034,7 +1046,7 @@ public: class NotFound; typedef NotFound *NotFound_ptr; - + #endif /* end #if !defined */ @@ -1052,16 +1064,19 @@ public: NotFound (void); // default ctor NotFound (const NotFound &); // copy ctor - ~NotFound (void); // dtor + ~NotFound (void); + static void _tao_any_destructor (void*); NotFound &operator= (const NotFound &); virtual void _raise (void); - virtual void _tao_encode (TAO_OutputCDR &cdr, - CORBA::Environment &) const; - virtual void _tao_decode (TAO_InputCDR &cdr, - CORBA::Environment &); + virtual void _tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &) const; + virtual void _tao_decode ( + TAO_InputCDR &, + CORBA::Environment &); static NotFound *_narrow (CORBA::Exception *); @@ -1078,7 +1093,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 (( @@ -1090,7 +1105,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 (( @@ -1101,7 +1116,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 (( @@ -1110,7 +1125,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 (( @@ -1120,7 +1135,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 (( @@ -1132,7 +1147,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 (( @@ -1142,7 +1157,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 (( @@ -1153,7 +1168,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 (( @@ -1165,7 +1180,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 (( @@ -1173,16 +1188,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); @@ -1194,14 +1209,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 = + + virtual Administration_ptr create_proxy ( + Administration_ptr proxy, + CORBA::Environment &env = TAO_default_environment () ); }; @@ -1209,23 +1224,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 = + + Administration_ptr create_proxy ( + Administration_ptr proxy, + CORBA::Environment &env = TAO_default_environment () ); @@ -1241,14 +1256,14 @@ protected: }; typedef ACE_Singleton<TAO_ImplementationRepository_Administration_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_ImplementationRepository_Administration_PROXY_FACTORY_ADAPTER; - class TAO_ImplementationRepository_Administration_Smart_Proxy_Base : public virtual ImplementationRepository::Administration + class TAO_ImplementationRepository_Administration_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (ImplementationRepository, Administration) { public: - TAO_ImplementationRepository_Administration_Smart_Proxy_Base (ImplementationRepository::Administration_ptr proxy); + TAO_ImplementationRepository_Administration_Smart_Proxy_Base (::ImplementationRepository::Administration_ptr proxy); ~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 (( @@ -1260,7 +1275,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 (( @@ -1271,7 +1286,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 (( @@ -1280,7 +1295,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 (( @@ -1290,7 +1305,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 (( @@ -1302,7 +1317,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 (( @@ -1312,7 +1327,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 (( @@ -1323,7 +1338,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 (( @@ -1335,7 +1350,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 (( @@ -1343,7 +1358,7 @@ protected: )); private: - ImplementationRepository::Administration_var base_proxy_; + ::ImplementationRepository::Administration_var base_proxy_; }; @@ -1371,14 +1386,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); @@ -1408,7 +1423,7 @@ public: operator ServerInformationIterator_ptr &(); ServerInformationIterator_ptr &ptr (void); ServerInformationIterator_ptr operator-> (void); - + private: ServerInformationIterator_ptr &ptr_; }; @@ -1432,23 +1447,25 @@ 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) { - return (ImplementationRepository::ServerInformationIterator_ptr)0; + return (ServerInformationIterator_ptr)0; } + static void _tao_any_destructor (void*); + 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 (( @@ -1456,7 +1473,7 @@ public: )); virtual void destroy ( - CORBA::Environment &ACE_TRY_ENV = + CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ) ACE_THROW_SPEC (( @@ -1464,16 +1481,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); @@ -1485,14 +1502,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 = + + virtual ServerInformationIterator_ptr create_proxy ( + ServerInformationIterator_ptr proxy, + CORBA::Environment &env = TAO_default_environment () ); }; @@ -1500,23 +1517,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 = + + ServerInformationIterator_ptr create_proxy ( + ServerInformationIterator_ptr proxy, + CORBA::Environment &env = TAO_default_environment () ); @@ -1532,15 +1549,15 @@ protected: }; typedef ACE_Singleton<TAO_ImplementationRepository_ServerInformationIterator_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_ImplementationRepository_ServerInformationIterator_PROXY_FACTORY_ADAPTER; - class TAO_ImplementationRepository_ServerInformationIterator_Smart_Proxy_Base : public virtual ImplementationRepository::ServerInformationIterator + class TAO_ImplementationRepository_ServerInformationIterator_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (ImplementationRepository, ServerInformationIterator) { public: - TAO_ImplementationRepository_ServerInformationIterator_Smart_Proxy_Base (ImplementationRepository::ServerInformationIterator_ptr proxy); + TAO_ImplementationRepository_ServerInformationIterator_Smart_Proxy_Base (::ImplementationRepository::ServerInformationIterator_ptr proxy); ~TAO_ImplementationRepository_ServerInformationIterator_Smart_Proxy_Base (void); 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 (( @@ -1548,7 +1565,7 @@ protected: )); virtual void destroy ( - CORBA::Environment &ACE_TRY_ENV = + CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ) ACE_THROW_SPEC (( @@ -1556,7 +1573,7 @@ protected: )); private: - ImplementationRepository::ServerInformationIterator_var base_proxy_; + ::ImplementationRepository::ServerInformationIterator_var base_proxy_; }; @@ -1572,86 +1589,48 @@ 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 *&); // 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 *&); +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 *&); // 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 *&); +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 ); @@ -1661,10 +1640,8 @@ TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, ImplementationReposit #ifndef __ACE_INLINE__ -TAO_Export CORBA::Boolean -operator<< (TAO_OutputCDR &, const ImplementationRepository::ServerObject_ptr ); -TAO_Export CORBA::Boolean -operator>> (TAO_InputCDR &, ImplementationRepository::ServerObject_ptr &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const ImplementationRepository::ServerObject_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::ServerObject_ptr &); TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const ImplementationRepository::EnvironmentVariable &); TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::EnvironmentVariable &); @@ -1682,7 +1659,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 &); @@ -1703,10 +1680,8 @@ TAO_Export CORBA::Boolean operator>> ( #endif /* _TAO_CDR_OP_ImplementationRepository_ServerInformationList_H_ */ -TAO_Export CORBA::Boolean -operator<< (TAO_OutputCDR &, const ImplementationRepository::Administration_ptr ); -TAO_Export CORBA::Boolean -operator>> (TAO_InputCDR &, ImplementationRepository::Administration_ptr &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const ImplementationRepository::Administration_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::Administration_ptr &); TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const ImplementationRepository::Administration::AlreadyRegistered &); TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::Administration::AlreadyRegistered &); @@ -1731,10 +1706,8 @@ TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository:: TAO_Export ostream& operator<< (ostream &, const ImplementationRepository::Administration::NotFound &); # endif /* ACE_LACKS_IOSTREAM_TOTALLY */ -TAO_Export CORBA::Boolean -operator<< (TAO_OutputCDR &, const ImplementationRepository::ServerInformationIterator_ptr ); -TAO_Export CORBA::Boolean -operator>> (TAO_InputCDR &, ImplementationRepository::ServerInformationIterator_ptr &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const ImplementationRepository::ServerInformationIterator_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::ServerInformationIterator_ptr &); #endif /* __ACE_INLINE__ */ diff --git a/TAO/tao/ImplRepoC.i b/TAO/tao/ImplRepoC.i index 3a4bac9eea9..71caac39e89 100644 --- a/TAO/tao/ImplRepoC.i +++ b/TAO/tao/ImplRepoC.i @@ -30,23 +30,23 @@ ImplementationRepository::ServerObject::~ServerObject (void) // destructor ACE_INLINE ImplementationRepository::ServerObject_var::ServerObject_var (void) // default constructor - : ptr_ (ImplementationRepository::ServerObject::_nil ()) + : ptr_ (ServerObject::_nil ()) {} ACE_INLINE -ImplementationRepository::ServerObject_var::ServerObject_var (ImplementationRepository::ServerObject_ptr p) +ImplementationRepository::ServerObject_var::ServerObject_var (ServerObject_ptr p) : ptr_ (p) {} -ACE_INLINE ImplementationRepository::ServerObject_ptr +ACE_INLINE ::ImplementationRepository::ServerObject_ptr ImplementationRepository::ServerObject_var::ptr (void) const { return this->ptr_; } ACE_INLINE -ImplementationRepository::ServerObject_var::ServerObject_var (const ImplementationRepository::ServerObject_var &p) // copy constructor - : ptr_ (ImplementationRepository::ServerObject::_duplicate (p.ptr ())) +ImplementationRepository::ServerObject_var::ServerObject_var (const ::ImplementationRepository::ServerObject_var &p) // copy constructor + : ptr_ (ServerObject::_duplicate (p.ptr ())) {} ACE_INLINE @@ -56,7 +56,7 @@ ImplementationRepository::ServerObject_var::~ServerObject_var (void) // destruct } ACE_INLINE ImplementationRepository::ServerObject_var & -ImplementationRepository::ServerObject_var::operator= (ImplementationRepository::ServerObject_ptr p) +ImplementationRepository::ServerObject_var::operator= (ServerObject_ptr p) { CORBA::release (this->ptr_); this->ptr_ = p; @@ -64,60 +64,60 @@ ImplementationRepository::ServerObject_var::operator= (ImplementationRepository: } ACE_INLINE ImplementationRepository::ServerObject_var & -ImplementationRepository::ServerObject_var::operator= (const ImplementationRepository::ServerObject_var &p) +ImplementationRepository::ServerObject_var::operator= (const ::ImplementationRepository::ServerObject_var &p) { if (this != &p) { CORBA::release (this->ptr_); - this->ptr_ = ImplementationRepository::ServerObject::_duplicate (p.ptr ()); + this->ptr_ = ::ImplementationRepository::ServerObject::_duplicate (p.ptr ()); } return *this; } -ACE_INLINE -ImplementationRepository::ServerObject_var::operator const ImplementationRepository::ServerObject_ptr &() const // cast +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_; } -ACE_INLINE ImplementationRepository::ServerObject_ptr +ACE_INLINE ::ImplementationRepository::ServerObject_ptr ImplementationRepository::ServerObject_var::in (void) const { return this->ptr_; } -ACE_INLINE ImplementationRepository::ServerObject_ptr & +ACE_INLINE ::ImplementationRepository::ServerObject_ptr & ImplementationRepository::ServerObject_var::inout (void) { return this->ptr_; } -ACE_INLINE ImplementationRepository::ServerObject_ptr & +ACE_INLINE ::ImplementationRepository::ServerObject_ptr & ImplementationRepository::ServerObject_var::out (void) { CORBA::release (this->ptr_); - this->ptr_ = ImplementationRepository::ServerObject::_nil (); + this->ptr_ = ::ImplementationRepository::ServerObject::_nil (); return this->ptr_; } -ACE_INLINE ImplementationRepository::ServerObject_ptr +ACE_INLINE ::ImplementationRepository::ServerObject_ptr ImplementationRepository::ServerObject_var::_retn (void) { // yield ownership of managed obj reference - ImplementationRepository::ServerObject_ptr val = this->ptr_; - this->ptr_ = ImplementationRepository::ServerObject::_nil (); + ::ImplementationRepository::ServerObject_ptr val = this->ptr_; + this->ptr_ = ::ImplementationRepository::ServerObject::_nil (); return val; } @@ -133,59 +133,59 @@ ImplementationRepository::ServerObject_var::_retn (void) // ************************************************************* ACE_INLINE -ImplementationRepository::ServerObject_out::ServerObject_out (ImplementationRepository::ServerObject_ptr &p) +ImplementationRepository::ServerObject_out::ServerObject_out (ServerObject_ptr &p) : ptr_ (p) { - this->ptr_ = ImplementationRepository::ServerObject::_nil (); + this->ptr_ = ::ImplementationRepository::ServerObject::_nil (); } ACE_INLINE -ImplementationRepository::ServerObject_out::ServerObject_out (ImplementationRepository::ServerObject_var &p) // constructor from _var +ImplementationRepository::ServerObject_out::ServerObject_out (ServerObject_var &p) // constructor from _var : ptr_ (p.out ()) { CORBA::release (this->ptr_); - this->ptr_ = ImplementationRepository::ServerObject::_nil (); + this->ptr_ = ::ImplementationRepository::ServerObject::_nil (); } ACE_INLINE -ImplementationRepository::ServerObject_out::ServerObject_out (const ImplementationRepository::ServerObject_out &p) // copy constructor - : ptr_ (ACE_const_cast (ImplementationRepository::ServerObject_out&,p).ptr_) +ImplementationRepository::ServerObject_out::ServerObject_out (const ::ImplementationRepository::ServerObject_out &p) // copy constructor + : ptr_ (ACE_const_cast (ServerObject_out &, p).ptr_) {} -ACE_INLINE ImplementationRepository::ServerObject_out & -ImplementationRepository::ServerObject_out::operator= (const ImplementationRepository::ServerObject_out &p) +ACE_INLINE ::ImplementationRepository::ServerObject_out & +ImplementationRepository::ServerObject_out::operator= (const ::ImplementationRepository::ServerObject_out &p) { - this->ptr_ = ACE_const_cast (ImplementationRepository::ServerObject_out&,p).ptr_; + this->ptr_ = ACE_const_cast (ServerObject_out&, p).ptr_; return *this; } ACE_INLINE ImplementationRepository::ServerObject_out & -ImplementationRepository::ServerObject_out::operator= (const ImplementationRepository::ServerObject_var &p) +ImplementationRepository::ServerObject_out::operator= (const ::ImplementationRepository::ServerObject_var &p) { - this->ptr_ = ImplementationRepository::ServerObject::_duplicate (p.ptr ()); + this->ptr_ = ::ImplementationRepository::ServerObject::_duplicate (p.ptr ()); return *this; } ACE_INLINE ImplementationRepository::ServerObject_out & -ImplementationRepository::ServerObject_out::operator= (ImplementationRepository::ServerObject_ptr p) +ImplementationRepository::ServerObject_out::operator= (ServerObject_ptr p) { this->ptr_ = p; return *this; } -ACE_INLINE -ImplementationRepository::ServerObject_out::operator ImplementationRepository::ServerObject_ptr &() // cast +ACE_INLINE +ImplementationRepository::ServerObject_out::operator ::ImplementationRepository::ServerObject_ptr &() // cast { return this->ptr_; } -ACE_INLINE ImplementationRepository::ServerObject_ptr & +ACE_INLINE ::ImplementationRepository::ServerObject_ptr & 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_; @@ -204,15 +204,15 @@ ImplementationRepository::EnvironmentVariable_var::EnvironmentVariable_var (void {} ACE_INLINE -ImplementationRepository::EnvironmentVariable_var::EnvironmentVariable_var (ImplementationRepository::EnvironmentVariable *p) +ImplementationRepository::EnvironmentVariable_var::EnvironmentVariable_var (EnvironmentVariable *p) : ptr_ (p) {} ACE_INLINE -ImplementationRepository::EnvironmentVariable_var::EnvironmentVariable_var (const ImplementationRepository::EnvironmentVariable_var &p) // copy constructor +ImplementationRepository::EnvironmentVariable_var::EnvironmentVariable_var (const ::ImplementationRepository::EnvironmentVariable_var &p) // copy constructor { if (p.ptr_) - ACE_NEW (this->ptr_, ImplementationRepository::EnvironmentVariable (*p.ptr_)); + ACE_NEW (this->ptr_, ::ImplementationRepository::EnvironmentVariable (*p.ptr_)); else this->ptr_ = 0; } @@ -224,68 +224,75 @@ ImplementationRepository::EnvironmentVariable_var::~EnvironmentVariable_var (voi } ACE_INLINE ImplementationRepository::EnvironmentVariable_var & -ImplementationRepository::EnvironmentVariable_var::operator= (ImplementationRepository::EnvironmentVariable *p) +ImplementationRepository::EnvironmentVariable_var::operator= (EnvironmentVariable *p) { delete this->ptr_; this->ptr_ = p; return *this; } -ACE_INLINE ImplementationRepository::EnvironmentVariable_var & -ImplementationRepository::EnvironmentVariable_var::operator= (const ImplementationRepository::EnvironmentVariable_var &p) +ACE_INLINE ::ImplementationRepository::EnvironmentVariable_var & +ImplementationRepository::EnvironmentVariable_var::operator= (const ::ImplementationRepository::EnvironmentVariable_var &p) { if (this != &p) { delete this->ptr_; - ACE_NEW_RETURN (this->ptr_, ImplementationRepository::EnvironmentVariable (*p.ptr_), *this); + ACE_NEW_RETURN (this->ptr_, ::ImplementationRepository::EnvironmentVariable (*p.ptr_), *this); } return *this; } -ACE_INLINE const ImplementationRepository::EnvironmentVariable * +ACE_INLINE const ::ImplementationRepository::EnvironmentVariable * ImplementationRepository::EnvironmentVariable_var::operator-> (void) const { return this->ptr_; } -ACE_INLINE ImplementationRepository::EnvironmentVariable * +ACE_INLINE ::ImplementationRepository::EnvironmentVariable * ImplementationRepository::EnvironmentVariable_var::operator-> (void) { return this->ptr_; } ACE_INLINE -ImplementationRepository::EnvironmentVariable_var::operator const ImplementationRepository::EnvironmentVariable &() const // cast +ImplementationRepository::EnvironmentVariable_var::operator const ::ImplementationRepository::EnvironmentVariable &() const // cast { return *this->ptr_; } ACE_INLINE -ImplementationRepository::EnvironmentVariable_var::operator ImplementationRepository::EnvironmentVariable &() // cast +ImplementationRepository::EnvironmentVariable_var::operator ::ImplementationRepository::EnvironmentVariable &() // cast { return *this->ptr_; } ACE_INLINE -ImplementationRepository::EnvironmentVariable_var::operator ImplementationRepository::EnvironmentVariable &() const// cast +ImplementationRepository::EnvironmentVariable_var::operator ::ImplementationRepository::EnvironmentVariable &() const // cast { return *this->ptr_; } -ACE_INLINE const ImplementationRepository::EnvironmentVariable & +// variable-size types only +ACE_INLINE +ImplementationRepository::EnvironmentVariable_var::operator ::ImplementationRepository::EnvironmentVariable *&() // cast +{ + return this->ptr_; +} + +ACE_INLINE const ::ImplementationRepository::EnvironmentVariable & ImplementationRepository::EnvironmentVariable_var::in (void) const { return *this->ptr_; } -ACE_INLINE ImplementationRepository::EnvironmentVariable & +ACE_INLINE ::ImplementationRepository::EnvironmentVariable & ImplementationRepository::EnvironmentVariable_var::inout (void) { return *this->ptr_; } -// mapping for variable size -ACE_INLINE ImplementationRepository::EnvironmentVariable *& +// mapping for variable size +ACE_INLINE ::ImplementationRepository::EnvironmentVariable *& ImplementationRepository::EnvironmentVariable_var::out (void) { delete this->ptr_; @@ -293,15 +300,15 @@ ImplementationRepository::EnvironmentVariable_var::out (void) return this->ptr_; } -ACE_INLINE ImplementationRepository::EnvironmentVariable * +ACE_INLINE ::ImplementationRepository::EnvironmentVariable * ImplementationRepository::EnvironmentVariable_var::_retn (void) { - ImplementationRepository::EnvironmentVariable *tmp = this->ptr_; + ::ImplementationRepository::EnvironmentVariable *tmp = this->ptr_; this->ptr_ = 0; return tmp; } -ACE_INLINE ImplementationRepository::EnvironmentVariable * +ACE_INLINE ::ImplementationRepository::EnvironmentVariable * ImplementationRepository::EnvironmentVariable_var::ptr (void) const { return this->ptr_; @@ -312,14 +319,14 @@ ImplementationRepository::EnvironmentVariable_var::ptr (void) const // ************************************************************* ACE_INLINE -ImplementationRepository::EnvironmentVariable_out::EnvironmentVariable_out (ImplementationRepository::EnvironmentVariable *&p) +ImplementationRepository::EnvironmentVariable_out::EnvironmentVariable_out (::ImplementationRepository::EnvironmentVariable *&p) : ptr_ (p) { this->ptr_ = 0; } ACE_INLINE -ImplementationRepository::EnvironmentVariable_out::EnvironmentVariable_out (ImplementationRepository::EnvironmentVariable_var &p) // constructor from _var +ImplementationRepository::EnvironmentVariable_out::EnvironmentVariable_out (EnvironmentVariable_var &p) // constructor from _var : ptr_ (p.out ()) { delete this->ptr_; @@ -327,37 +334,37 @@ ImplementationRepository::EnvironmentVariable_out::EnvironmentVariable_out (Impl } ACE_INLINE -ImplementationRepository::EnvironmentVariable_out::EnvironmentVariable_out (const ImplementationRepository::EnvironmentVariable_out &p) // copy constructor - : ptr_ (ACE_const_cast (ImplementationRepository::EnvironmentVariable_out&,p).ptr_) +ImplementationRepository::EnvironmentVariable_out::EnvironmentVariable_out (const ::ImplementationRepository::EnvironmentVariable_out &p) // copy constructor + : ptr_ (ACE_const_cast (EnvironmentVariable_out&, p).ptr_) {} ACE_INLINE ImplementationRepository::EnvironmentVariable_out & -ImplementationRepository::EnvironmentVariable_out::operator= (const ImplementationRepository::EnvironmentVariable_out &p) +ImplementationRepository::EnvironmentVariable_out::operator= (const ::ImplementationRepository::EnvironmentVariable_out &p) { - this->ptr_ = ACE_const_cast (ImplementationRepository::EnvironmentVariable_out&,p).ptr_; + this->ptr_ = ACE_const_cast (EnvironmentVariable_out&, p).ptr_; return *this; } ACE_INLINE ImplementationRepository::EnvironmentVariable_out & -ImplementationRepository::EnvironmentVariable_out::operator= (ImplementationRepository::EnvironmentVariable *p) +ImplementationRepository::EnvironmentVariable_out::operator= (EnvironmentVariable *p) { this->ptr_ = p; return *this; } -ACE_INLINE -ImplementationRepository::EnvironmentVariable_out::operator ImplementationRepository::EnvironmentVariable *&() // cast +ACE_INLINE +ImplementationRepository::EnvironmentVariable_out::operator ::ImplementationRepository::EnvironmentVariable *&() // cast { return this->ptr_; } -ACE_INLINE ImplementationRepository::EnvironmentVariable *& +ACE_INLINE ::ImplementationRepository::EnvironmentVariable *& ImplementationRepository::EnvironmentVariable_out::ptr (void) // ptr { return this->ptr_; } -ACE_INLINE ImplementationRepository::EnvironmentVariable * +ACE_INLINE ::ImplementationRepository::EnvironmentVariable * ImplementationRepository::EnvironmentVariable_out::operator-> (void) { return this->ptr_; @@ -365,7 +372,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 +385,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)) + : TAO_Unbounded_Base_Sequence (maximum, _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,20 +411,20 @@ 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) + ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList (const _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList &rhs) // Copy constructor. : TAO_Unbounded_Base_Sequence (rhs) { if (rhs.buffer_ != 0) { - ImplementationRepository::EnvironmentVariable *tmp1 = ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::allocbuf (this->maximum_); + ImplementationRepository::EnvironmentVariable *tmp1 = _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,38 +432,38 @@ 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) + ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::operator= (const _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList &rhs) // Assignment operator. { if (this == &rhs) return *this; - + if (this->release_) { if (this->maximum_ < rhs.maximum_) { // free the old buffer ImplementationRepository::EnvironmentVariable *tmp = ACE_reinterpret_cast (ImplementationRepository::EnvironmentVariable *, this->buffer_); - ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::freebuf (tmp); - this->buffer_ = ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::allocbuf (rhs.maximum_); + _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::freebuf (tmp); + this->buffer_ = _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::allocbuf (rhs.maximum_); } } else - this->buffer_ = ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::allocbuf (rhs.maximum_); - + this->buffer_ = _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 +473,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 +482,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) { @@ -487,7 +494,7 @@ ImplementationRepository::EnvironmentVariable_out::operator-> (void) // We retain ownership. if (this->buffer_ == 0) { - result = ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::allocbuf (this->length_); + result = _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::allocbuf (this->length_); this->buffer_ = result; } else @@ -510,13 +517,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, @@ -528,16 +535,16 @@ ImplementationRepository::EnvironmentVariable_out::operator-> (void) if (this->buffer_ && this->release_ == 1) { ImplementationRepository::EnvironmentVariable *tmp = ACE_reinterpret_cast(ImplementationRepository::EnvironmentVariable*,this->buffer_); - ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::freebuf (tmp); + _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::freebuf (tmp); } 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_ @@ -552,15 +559,15 @@ ImplementationRepository::EnvironmentList_var::EnvironmentList_var (void) // def {} ACE_INLINE -ImplementationRepository::EnvironmentList_var::EnvironmentList_var (ImplementationRepository::EnvironmentList *p) +ImplementationRepository::EnvironmentList_var::EnvironmentList_var (EnvironmentList *p) : ptr_ (p) {} ACE_INLINE -ImplementationRepository::EnvironmentList_var::EnvironmentList_var (const ImplementationRepository::EnvironmentList_var &p) // copy constructor +ImplementationRepository::EnvironmentList_var::EnvironmentList_var (const ::ImplementationRepository::EnvironmentList_var &p) // copy constructor { if (p.ptr_) - ACE_NEW (this->ptr_, ImplementationRepository::EnvironmentList (*p.ptr_)); + ACE_NEW (this->ptr_, ::ImplementationRepository::EnvironmentList (*p.ptr_)); else this->ptr_ = 0; } @@ -572,7 +579,7 @@ ImplementationRepository::EnvironmentList_var::~EnvironmentList_var (void) // de } ACE_INLINE ImplementationRepository::EnvironmentList_var & -ImplementationRepository::EnvironmentList_var::operator= (ImplementationRepository::EnvironmentList *p) +ImplementationRepository::EnvironmentList_var::operator= (EnvironmentList *p) { delete this->ptr_; this->ptr_ = p; @@ -580,66 +587,73 @@ ImplementationRepository::EnvironmentList_var::operator= (ImplementationReposito } ACE_INLINE ImplementationRepository::EnvironmentList_var & -ImplementationRepository::EnvironmentList_var::operator= (const ImplementationRepository::EnvironmentList_var &p) // deep copy +ImplementationRepository::EnvironmentList_var::operator= (const ::ImplementationRepository::EnvironmentList_var &p) // deep copy { if (this != &p) { delete this->ptr_; - ACE_NEW_RETURN (this->ptr_, ImplementationRepository::EnvironmentList (*p.ptr_), *this); + ACE_NEW_RETURN (this->ptr_, ::ImplementationRepository::EnvironmentList (*p.ptr_), *this); } return *this; } -ACE_INLINE const ImplementationRepository::EnvironmentList * +ACE_INLINE const ::ImplementationRepository::EnvironmentList * ImplementationRepository::EnvironmentList_var::operator-> (void) const { return this->ptr_; } -ACE_INLINE ImplementationRepository::EnvironmentList * +ACE_INLINE ::ImplementationRepository::EnvironmentList * ImplementationRepository::EnvironmentList_var::operator-> (void) { return this->ptr_; } -ACE_INLINE -ImplementationRepository::EnvironmentList_var::operator const ImplementationRepository::EnvironmentList &() const // cast +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_; } +// variable-size types only +ACE_INLINE +ImplementationRepository::EnvironmentList_var::operator ::ImplementationRepository::EnvironmentList *&() // cast +{ + return this->ptr_; +} + ACE_INLINE ImplementationRepository::EnvironmentVariable & ImplementationRepository::EnvironmentList_var::operator[] (CORBA::ULong index) { return this->ptr_->operator[] (index); } -ACE_INLINE const ImplementationRepository::EnvironmentList & +ACE_INLINE const ::ImplementationRepository::EnvironmentList & ImplementationRepository::EnvironmentList_var::in (void) const { return *this->ptr_; } -ACE_INLINE ImplementationRepository::EnvironmentList & +ACE_INLINE ::ImplementationRepository::EnvironmentList & ImplementationRepository::EnvironmentList_var::inout (void) { return *this->ptr_; } -// mapping for variable size -ACE_INLINE ImplementationRepository::EnvironmentList *& +// mapping for variable size +ACE_INLINE ::ImplementationRepository::EnvironmentList *& ImplementationRepository::EnvironmentList_var::out (void) { delete this->ptr_; @@ -647,15 +661,15 @@ ImplementationRepository::EnvironmentList_var::out (void) return this->ptr_; } -ACE_INLINE ImplementationRepository::EnvironmentList * +ACE_INLINE ::ImplementationRepository::EnvironmentList * ImplementationRepository::EnvironmentList_var::_retn (void) { - ImplementationRepository::EnvironmentList *tmp = this->ptr_; + ::ImplementationRepository::EnvironmentList *tmp = this->ptr_; this->ptr_ = 0; return tmp; } -ACE_INLINE ImplementationRepository::EnvironmentList * +ACE_INLINE ::ImplementationRepository::EnvironmentList * ImplementationRepository::EnvironmentList_var::ptr (void) const { return this->ptr_; @@ -666,14 +680,14 @@ ImplementationRepository::EnvironmentList_var::ptr (void) const // ************************************************************* ACE_INLINE -ImplementationRepository::EnvironmentList_out::EnvironmentList_out (ImplementationRepository::EnvironmentList *&p) +ImplementationRepository::EnvironmentList_out::EnvironmentList_out (EnvironmentList *&p) : ptr_ (p) { this->ptr_ = 0; } ACE_INLINE -ImplementationRepository::EnvironmentList_out::EnvironmentList_out (ImplementationRepository::EnvironmentList_var &p) // constructor from _var +ImplementationRepository::EnvironmentList_out::EnvironmentList_out (EnvironmentList_var &p) // constructor from _var : ptr_ (p.out ()) { delete this->ptr_; @@ -681,37 +695,37 @@ ImplementationRepository::EnvironmentList_out::EnvironmentList_out (Implementati } ACE_INLINE -ImplementationRepository::EnvironmentList_out::EnvironmentList_out (const ImplementationRepository::EnvironmentList_out &p) // copy constructor - : ptr_ (ACE_const_cast (ImplementationRepository::EnvironmentList_out&,p).ptr_) +ImplementationRepository::EnvironmentList_out::EnvironmentList_out (const ::ImplementationRepository::EnvironmentList_out &p) // copy constructor + : ptr_ (ACE_const_cast (EnvironmentList_out&, p).ptr_) {} -ACE_INLINE ImplementationRepository::EnvironmentList_out & -ImplementationRepository::EnvironmentList_out::operator= (const ImplementationRepository::EnvironmentList_out &p) +ACE_INLINE ::ImplementationRepository::EnvironmentList_out & +ImplementationRepository::EnvironmentList_out::operator= (const ::ImplementationRepository::EnvironmentList_out &p) { - this->ptr_ = ACE_const_cast (ImplementationRepository::EnvironmentList_out&,p).ptr_; + this->ptr_ = ACE_const_cast (EnvironmentList_out&, p).ptr_; return *this; } -ACE_INLINE ImplementationRepository::EnvironmentList_out & -ImplementationRepository::EnvironmentList_out::operator= (ImplementationRepository::EnvironmentList *p) +ACE_INLINE ::ImplementationRepository::EnvironmentList_out & +ImplementationRepository::EnvironmentList_out::operator= (EnvironmentList *p) { this->ptr_ = p; return *this; } -ACE_INLINE -ImplementationRepository::EnvironmentList_out::operator ImplementationRepository::EnvironmentList *&() // cast +ACE_INLINE +ImplementationRepository::EnvironmentList_out::operator ::ImplementationRepository::EnvironmentList *&() // cast { return this->ptr_; } -ACE_INLINE ImplementationRepository::EnvironmentList *& +ACE_INLINE ::ImplementationRepository::EnvironmentList *& ImplementationRepository::EnvironmentList_out::ptr (void) // ptr { return this->ptr_; } -ACE_INLINE ImplementationRepository::EnvironmentList * +ACE_INLINE ::ImplementationRepository::EnvironmentList * ImplementationRepository::EnvironmentList_out::operator-> (void) { return this->ptr_; @@ -736,15 +750,15 @@ ImplementationRepository::StartupOptions_var::StartupOptions_var (void) // defau {} ACE_INLINE -ImplementationRepository::StartupOptions_var::StartupOptions_var (ImplementationRepository::StartupOptions *p) +ImplementationRepository::StartupOptions_var::StartupOptions_var (StartupOptions *p) : ptr_ (p) {} ACE_INLINE -ImplementationRepository::StartupOptions_var::StartupOptions_var (const ImplementationRepository::StartupOptions_var &p) // copy constructor +ImplementationRepository::StartupOptions_var::StartupOptions_var (const ::ImplementationRepository::StartupOptions_var &p) // copy constructor { if (p.ptr_) - ACE_NEW (this->ptr_, ImplementationRepository::StartupOptions (*p.ptr_)); + ACE_NEW (this->ptr_, ::ImplementationRepository::StartupOptions (*p.ptr_)); else this->ptr_ = 0; } @@ -756,68 +770,75 @@ ImplementationRepository::StartupOptions_var::~StartupOptions_var (void) // dest } ACE_INLINE ImplementationRepository::StartupOptions_var & -ImplementationRepository::StartupOptions_var::operator= (ImplementationRepository::StartupOptions *p) +ImplementationRepository::StartupOptions_var::operator= (StartupOptions *p) { delete this->ptr_; this->ptr_ = p; return *this; } -ACE_INLINE ImplementationRepository::StartupOptions_var & -ImplementationRepository::StartupOptions_var::operator= (const ImplementationRepository::StartupOptions_var &p) +ACE_INLINE ::ImplementationRepository::StartupOptions_var & +ImplementationRepository::StartupOptions_var::operator= (const ::ImplementationRepository::StartupOptions_var &p) { if (this != &p) { delete this->ptr_; - ACE_NEW_RETURN (this->ptr_, ImplementationRepository::StartupOptions (*p.ptr_), *this); + ACE_NEW_RETURN (this->ptr_, ::ImplementationRepository::StartupOptions (*p.ptr_), *this); } return *this; } -ACE_INLINE const ImplementationRepository::StartupOptions * +ACE_INLINE const ::ImplementationRepository::StartupOptions * ImplementationRepository::StartupOptions_var::operator-> (void) const { return this->ptr_; } -ACE_INLINE ImplementationRepository::StartupOptions * +ACE_INLINE ::ImplementationRepository::StartupOptions * ImplementationRepository::StartupOptions_var::operator-> (void) { return this->ptr_; } ACE_INLINE -ImplementationRepository::StartupOptions_var::operator const ImplementationRepository::StartupOptions &() const // cast +ImplementationRepository::StartupOptions_var::operator const ::ImplementationRepository::StartupOptions &() const // cast { return *this->ptr_; } ACE_INLINE -ImplementationRepository::StartupOptions_var::operator ImplementationRepository::StartupOptions &() // cast +ImplementationRepository::StartupOptions_var::operator ::ImplementationRepository::StartupOptions &() // cast { return *this->ptr_; } ACE_INLINE -ImplementationRepository::StartupOptions_var::operator ImplementationRepository::StartupOptions &() const// cast +ImplementationRepository::StartupOptions_var::operator ::ImplementationRepository::StartupOptions &() const // cast { return *this->ptr_; } -ACE_INLINE const ImplementationRepository::StartupOptions & +// variable-size types only +ACE_INLINE +ImplementationRepository::StartupOptions_var::operator ::ImplementationRepository::StartupOptions *&() // cast +{ + return this->ptr_; +} + +ACE_INLINE const ::ImplementationRepository::StartupOptions & ImplementationRepository::StartupOptions_var::in (void) const { return *this->ptr_; } -ACE_INLINE ImplementationRepository::StartupOptions & +ACE_INLINE ::ImplementationRepository::StartupOptions & ImplementationRepository::StartupOptions_var::inout (void) { return *this->ptr_; } -// mapping for variable size -ACE_INLINE ImplementationRepository::StartupOptions *& +// mapping for variable size +ACE_INLINE ::ImplementationRepository::StartupOptions *& ImplementationRepository::StartupOptions_var::out (void) { delete this->ptr_; @@ -825,15 +846,15 @@ ImplementationRepository::StartupOptions_var::out (void) return this->ptr_; } -ACE_INLINE ImplementationRepository::StartupOptions * +ACE_INLINE ::ImplementationRepository::StartupOptions * ImplementationRepository::StartupOptions_var::_retn (void) { - ImplementationRepository::StartupOptions *tmp = this->ptr_; + ::ImplementationRepository::StartupOptions *tmp = this->ptr_; this->ptr_ = 0; return tmp; } -ACE_INLINE ImplementationRepository::StartupOptions * +ACE_INLINE ::ImplementationRepository::StartupOptions * ImplementationRepository::StartupOptions_var::ptr (void) const { return this->ptr_; @@ -844,14 +865,14 @@ ImplementationRepository::StartupOptions_var::ptr (void) const // ************************************************************* ACE_INLINE -ImplementationRepository::StartupOptions_out::StartupOptions_out (ImplementationRepository::StartupOptions *&p) +ImplementationRepository::StartupOptions_out::StartupOptions_out (::ImplementationRepository::StartupOptions *&p) : ptr_ (p) { this->ptr_ = 0; } ACE_INLINE -ImplementationRepository::StartupOptions_out::StartupOptions_out (ImplementationRepository::StartupOptions_var &p) // constructor from _var +ImplementationRepository::StartupOptions_out::StartupOptions_out (StartupOptions_var &p) // constructor from _var : ptr_ (p.out ()) { delete this->ptr_; @@ -859,37 +880,37 @@ ImplementationRepository::StartupOptions_out::StartupOptions_out (Implementation } ACE_INLINE -ImplementationRepository::StartupOptions_out::StartupOptions_out (const ImplementationRepository::StartupOptions_out &p) // copy constructor - : ptr_ (ACE_const_cast (ImplementationRepository::StartupOptions_out&,p).ptr_) +ImplementationRepository::StartupOptions_out::StartupOptions_out (const ::ImplementationRepository::StartupOptions_out &p) // copy constructor + : ptr_ (ACE_const_cast (StartupOptions_out&, p).ptr_) {} ACE_INLINE ImplementationRepository::StartupOptions_out & -ImplementationRepository::StartupOptions_out::operator= (const ImplementationRepository::StartupOptions_out &p) +ImplementationRepository::StartupOptions_out::operator= (const ::ImplementationRepository::StartupOptions_out &p) { - this->ptr_ = ACE_const_cast (ImplementationRepository::StartupOptions_out&,p).ptr_; + this->ptr_ = ACE_const_cast (StartupOptions_out&, p).ptr_; return *this; } ACE_INLINE ImplementationRepository::StartupOptions_out & -ImplementationRepository::StartupOptions_out::operator= (ImplementationRepository::StartupOptions *p) +ImplementationRepository::StartupOptions_out::operator= (StartupOptions *p) { this->ptr_ = p; return *this; } -ACE_INLINE -ImplementationRepository::StartupOptions_out::operator ImplementationRepository::StartupOptions *&() // cast +ACE_INLINE +ImplementationRepository::StartupOptions_out::operator ::ImplementationRepository::StartupOptions *&() // cast { return this->ptr_; } -ACE_INLINE ImplementationRepository::StartupOptions *& +ACE_INLINE ::ImplementationRepository::StartupOptions *& ImplementationRepository::StartupOptions_out::ptr (void) // ptr { return this->ptr_; } -ACE_INLINE ImplementationRepository::StartupOptions * +ACE_INLINE ::ImplementationRepository::StartupOptions * ImplementationRepository::StartupOptions_out::operator-> (void) { return this->ptr_; @@ -905,15 +926,15 @@ ImplementationRepository::ServerInformation_var::ServerInformation_var (void) // {} ACE_INLINE -ImplementationRepository::ServerInformation_var::ServerInformation_var (ImplementationRepository::ServerInformation *p) +ImplementationRepository::ServerInformation_var::ServerInformation_var (ServerInformation *p) : ptr_ (p) {} ACE_INLINE -ImplementationRepository::ServerInformation_var::ServerInformation_var (const ImplementationRepository::ServerInformation_var &p) // copy constructor +ImplementationRepository::ServerInformation_var::ServerInformation_var (const ::ImplementationRepository::ServerInformation_var &p) // copy constructor { if (p.ptr_) - ACE_NEW (this->ptr_, ImplementationRepository::ServerInformation (*p.ptr_)); + ACE_NEW (this->ptr_, ::ImplementationRepository::ServerInformation (*p.ptr_)); else this->ptr_ = 0; } @@ -925,68 +946,75 @@ ImplementationRepository::ServerInformation_var::~ServerInformation_var (void) / } ACE_INLINE ImplementationRepository::ServerInformation_var & -ImplementationRepository::ServerInformation_var::operator= (ImplementationRepository::ServerInformation *p) +ImplementationRepository::ServerInformation_var::operator= (ServerInformation *p) { delete this->ptr_; this->ptr_ = p; return *this; } -ACE_INLINE ImplementationRepository::ServerInformation_var & -ImplementationRepository::ServerInformation_var::operator= (const ImplementationRepository::ServerInformation_var &p) +ACE_INLINE ::ImplementationRepository::ServerInformation_var & +ImplementationRepository::ServerInformation_var::operator= (const ::ImplementationRepository::ServerInformation_var &p) { if (this != &p) { delete this->ptr_; - ACE_NEW_RETURN (this->ptr_, ImplementationRepository::ServerInformation (*p.ptr_), *this); + ACE_NEW_RETURN (this->ptr_, ::ImplementationRepository::ServerInformation (*p.ptr_), *this); } return *this; } -ACE_INLINE const ImplementationRepository::ServerInformation * +ACE_INLINE const ::ImplementationRepository::ServerInformation * ImplementationRepository::ServerInformation_var::operator-> (void) const { return this->ptr_; } -ACE_INLINE ImplementationRepository::ServerInformation * +ACE_INLINE ::ImplementationRepository::ServerInformation * ImplementationRepository::ServerInformation_var::operator-> (void) { return this->ptr_; } ACE_INLINE -ImplementationRepository::ServerInformation_var::operator const ImplementationRepository::ServerInformation &() const // cast +ImplementationRepository::ServerInformation_var::operator const ::ImplementationRepository::ServerInformation &() const // cast { return *this->ptr_; } ACE_INLINE -ImplementationRepository::ServerInformation_var::operator ImplementationRepository::ServerInformation &() // cast +ImplementationRepository::ServerInformation_var::operator ::ImplementationRepository::ServerInformation &() // cast { return *this->ptr_; } ACE_INLINE -ImplementationRepository::ServerInformation_var::operator ImplementationRepository::ServerInformation &() const// cast +ImplementationRepository::ServerInformation_var::operator ::ImplementationRepository::ServerInformation &() const // cast { return *this->ptr_; } -ACE_INLINE const ImplementationRepository::ServerInformation & +// variable-size types only +ACE_INLINE +ImplementationRepository::ServerInformation_var::operator ::ImplementationRepository::ServerInformation *&() // cast +{ + return this->ptr_; +} + +ACE_INLINE const ::ImplementationRepository::ServerInformation & ImplementationRepository::ServerInformation_var::in (void) const { return *this->ptr_; } -ACE_INLINE ImplementationRepository::ServerInformation & +ACE_INLINE ::ImplementationRepository::ServerInformation & ImplementationRepository::ServerInformation_var::inout (void) { return *this->ptr_; } -// mapping for variable size -ACE_INLINE ImplementationRepository::ServerInformation *& +// mapping for variable size +ACE_INLINE ::ImplementationRepository::ServerInformation *& ImplementationRepository::ServerInformation_var::out (void) { delete this->ptr_; @@ -994,15 +1022,15 @@ ImplementationRepository::ServerInformation_var::out (void) return this->ptr_; } -ACE_INLINE ImplementationRepository::ServerInformation * +ACE_INLINE ::ImplementationRepository::ServerInformation * ImplementationRepository::ServerInformation_var::_retn (void) { - ImplementationRepository::ServerInformation *tmp = this->ptr_; + ::ImplementationRepository::ServerInformation *tmp = this->ptr_; this->ptr_ = 0; return tmp; } -ACE_INLINE ImplementationRepository::ServerInformation * +ACE_INLINE ::ImplementationRepository::ServerInformation * ImplementationRepository::ServerInformation_var::ptr (void) const { return this->ptr_; @@ -1013,14 +1041,14 @@ ImplementationRepository::ServerInformation_var::ptr (void) const // ************************************************************* ACE_INLINE -ImplementationRepository::ServerInformation_out::ServerInformation_out (ImplementationRepository::ServerInformation *&p) +ImplementationRepository::ServerInformation_out::ServerInformation_out (::ImplementationRepository::ServerInformation *&p) : ptr_ (p) { this->ptr_ = 0; } ACE_INLINE -ImplementationRepository::ServerInformation_out::ServerInformation_out (ImplementationRepository::ServerInformation_var &p) // constructor from _var +ImplementationRepository::ServerInformation_out::ServerInformation_out (ServerInformation_var &p) // constructor from _var : ptr_ (p.out ()) { delete this->ptr_; @@ -1028,37 +1056,37 @@ ImplementationRepository::ServerInformation_out::ServerInformation_out (Implemen } ACE_INLINE -ImplementationRepository::ServerInformation_out::ServerInformation_out (const ImplementationRepository::ServerInformation_out &p) // copy constructor - : ptr_ (ACE_const_cast (ImplementationRepository::ServerInformation_out&,p).ptr_) +ImplementationRepository::ServerInformation_out::ServerInformation_out (const ::ImplementationRepository::ServerInformation_out &p) // copy constructor + : ptr_ (ACE_const_cast (ServerInformation_out&, p).ptr_) {} ACE_INLINE ImplementationRepository::ServerInformation_out & -ImplementationRepository::ServerInformation_out::operator= (const ImplementationRepository::ServerInformation_out &p) +ImplementationRepository::ServerInformation_out::operator= (const ::ImplementationRepository::ServerInformation_out &p) { - this->ptr_ = ACE_const_cast (ImplementationRepository::ServerInformation_out&,p).ptr_; + this->ptr_ = ACE_const_cast (ServerInformation_out&, p).ptr_; return *this; } ACE_INLINE ImplementationRepository::ServerInformation_out & -ImplementationRepository::ServerInformation_out::operator= (ImplementationRepository::ServerInformation *p) +ImplementationRepository::ServerInformation_out::operator= (ServerInformation *p) { this->ptr_ = p; return *this; } -ACE_INLINE -ImplementationRepository::ServerInformation_out::operator ImplementationRepository::ServerInformation *&() // cast +ACE_INLINE +ImplementationRepository::ServerInformation_out::operator ::ImplementationRepository::ServerInformation *&() // cast { return this->ptr_; } -ACE_INLINE ImplementationRepository::ServerInformation *& +ACE_INLINE ::ImplementationRepository::ServerInformation *& ImplementationRepository::ServerInformation_out::ptr (void) // ptr { return this->ptr_; } -ACE_INLINE ImplementationRepository::ServerInformation * +ACE_INLINE ::ImplementationRepository::ServerInformation * ImplementationRepository::ServerInformation_out::operator-> (void) { return this->ptr_; @@ -1066,7 +1094,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 +1107,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)) + : TAO_Unbounded_Base_Sequence (maximum, _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,20 +1133,20 @@ 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) + ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList (const _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList &rhs) // Copy constructor. : TAO_Unbounded_Base_Sequence (rhs) { if (rhs.buffer_ != 0) { - ImplementationRepository::ServerInformation *tmp1 = ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::allocbuf (this->maximum_); + ImplementationRepository::ServerInformation *tmp1 = _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,38 +1154,38 @@ 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) + ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::operator= (const _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList &rhs) // Assignment operator. { if (this == &rhs) return *this; - + if (this->release_) { if (this->maximum_ < rhs.maximum_) { // free the old buffer ImplementationRepository::ServerInformation *tmp = ACE_reinterpret_cast (ImplementationRepository::ServerInformation *, this->buffer_); - ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::freebuf (tmp); - this->buffer_ = ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::allocbuf (rhs.maximum_); + _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::freebuf (tmp); + this->buffer_ = _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::allocbuf (rhs.maximum_); } } else - this->buffer_ = ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::allocbuf (rhs.maximum_); - + this->buffer_ = _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 +1195,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 +1204,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) { @@ -1188,7 +1216,7 @@ ImplementationRepository::ServerInformation_out::operator-> (void) // We retain ownership. if (this->buffer_ == 0) { - result = ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::allocbuf (this->length_); + result = _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::allocbuf (this->length_); this->buffer_ = result; } else @@ -1211,13 +1239,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, @@ -1229,16 +1257,16 @@ ImplementationRepository::ServerInformation_out::operator-> (void) if (this->buffer_ && this->release_ == 1) { ImplementationRepository::ServerInformation *tmp = ACE_reinterpret_cast(ImplementationRepository::ServerInformation*,this->buffer_); - ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::freebuf (tmp); + _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::freebuf (tmp); } 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_ @@ -1253,15 +1281,15 @@ ImplementationRepository::ServerInformationList_var::ServerInformationList_var ( {} ACE_INLINE -ImplementationRepository::ServerInformationList_var::ServerInformationList_var (ImplementationRepository::ServerInformationList *p) +ImplementationRepository::ServerInformationList_var::ServerInformationList_var (ServerInformationList *p) : ptr_ (p) {} ACE_INLINE -ImplementationRepository::ServerInformationList_var::ServerInformationList_var (const ImplementationRepository::ServerInformationList_var &p) // copy constructor +ImplementationRepository::ServerInformationList_var::ServerInformationList_var (const ::ImplementationRepository::ServerInformationList_var &p) // copy constructor { if (p.ptr_) - ACE_NEW (this->ptr_, ImplementationRepository::ServerInformationList (*p.ptr_)); + ACE_NEW (this->ptr_, ::ImplementationRepository::ServerInformationList (*p.ptr_)); else this->ptr_ = 0; } @@ -1273,7 +1301,7 @@ ImplementationRepository::ServerInformationList_var::~ServerInformationList_var } ACE_INLINE ImplementationRepository::ServerInformationList_var & -ImplementationRepository::ServerInformationList_var::operator= (ImplementationRepository::ServerInformationList *p) +ImplementationRepository::ServerInformationList_var::operator= (ServerInformationList *p) { delete this->ptr_; this->ptr_ = p; @@ -1281,66 +1309,73 @@ ImplementationRepository::ServerInformationList_var::operator= (ImplementationRe } ACE_INLINE ImplementationRepository::ServerInformationList_var & -ImplementationRepository::ServerInformationList_var::operator= (const ImplementationRepository::ServerInformationList_var &p) // deep copy +ImplementationRepository::ServerInformationList_var::operator= (const ::ImplementationRepository::ServerInformationList_var &p) // deep copy { if (this != &p) { delete this->ptr_; - ACE_NEW_RETURN (this->ptr_, ImplementationRepository::ServerInformationList (*p.ptr_), *this); + ACE_NEW_RETURN (this->ptr_, ::ImplementationRepository::ServerInformationList (*p.ptr_), *this); } return *this; } -ACE_INLINE const ImplementationRepository::ServerInformationList * +ACE_INLINE const ::ImplementationRepository::ServerInformationList * ImplementationRepository::ServerInformationList_var::operator-> (void) const { return this->ptr_; } -ACE_INLINE ImplementationRepository::ServerInformationList * +ACE_INLINE ::ImplementationRepository::ServerInformationList * ImplementationRepository::ServerInformationList_var::operator-> (void) { return this->ptr_; } -ACE_INLINE -ImplementationRepository::ServerInformationList_var::operator const ImplementationRepository::ServerInformationList &() const // cast +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_; } +// variable-size types only +ACE_INLINE +ImplementationRepository::ServerInformationList_var::operator ::ImplementationRepository::ServerInformationList *&() // cast +{ + return this->ptr_; +} + ACE_INLINE ImplementationRepository::ServerInformation & ImplementationRepository::ServerInformationList_var::operator[] (CORBA::ULong index) { return this->ptr_->operator[] (index); } -ACE_INLINE const ImplementationRepository::ServerInformationList & +ACE_INLINE const ::ImplementationRepository::ServerInformationList & ImplementationRepository::ServerInformationList_var::in (void) const { return *this->ptr_; } -ACE_INLINE ImplementationRepository::ServerInformationList & +ACE_INLINE ::ImplementationRepository::ServerInformationList & ImplementationRepository::ServerInformationList_var::inout (void) { return *this->ptr_; } -// mapping for variable size -ACE_INLINE ImplementationRepository::ServerInformationList *& +// mapping for variable size +ACE_INLINE ::ImplementationRepository::ServerInformationList *& ImplementationRepository::ServerInformationList_var::out (void) { delete this->ptr_; @@ -1348,15 +1383,15 @@ ImplementationRepository::ServerInformationList_var::out (void) return this->ptr_; } -ACE_INLINE ImplementationRepository::ServerInformationList * +ACE_INLINE ::ImplementationRepository::ServerInformationList * ImplementationRepository::ServerInformationList_var::_retn (void) { - ImplementationRepository::ServerInformationList *tmp = this->ptr_; + ::ImplementationRepository::ServerInformationList *tmp = this->ptr_; this->ptr_ = 0; return tmp; } -ACE_INLINE ImplementationRepository::ServerInformationList * +ACE_INLINE ::ImplementationRepository::ServerInformationList * ImplementationRepository::ServerInformationList_var::ptr (void) const { return this->ptr_; @@ -1367,14 +1402,14 @@ ImplementationRepository::ServerInformationList_var::ptr (void) const // ************************************************************* ACE_INLINE -ImplementationRepository::ServerInformationList_out::ServerInformationList_out (ImplementationRepository::ServerInformationList *&p) +ImplementationRepository::ServerInformationList_out::ServerInformationList_out (ServerInformationList *&p) : ptr_ (p) { this->ptr_ = 0; } ACE_INLINE -ImplementationRepository::ServerInformationList_out::ServerInformationList_out (ImplementationRepository::ServerInformationList_var &p) // constructor from _var +ImplementationRepository::ServerInformationList_out::ServerInformationList_out (ServerInformationList_var &p) // constructor from _var : ptr_ (p.out ()) { delete this->ptr_; @@ -1382,37 +1417,37 @@ ImplementationRepository::ServerInformationList_out::ServerInformationList_out ( } ACE_INLINE -ImplementationRepository::ServerInformationList_out::ServerInformationList_out (const ImplementationRepository::ServerInformationList_out &p) // copy constructor - : ptr_ (ACE_const_cast (ImplementationRepository::ServerInformationList_out&,p).ptr_) +ImplementationRepository::ServerInformationList_out::ServerInformationList_out (const ::ImplementationRepository::ServerInformationList_out &p) // copy constructor + : ptr_ (ACE_const_cast (ServerInformationList_out&, p).ptr_) {} -ACE_INLINE ImplementationRepository::ServerInformationList_out & -ImplementationRepository::ServerInformationList_out::operator= (const ImplementationRepository::ServerInformationList_out &p) +ACE_INLINE ::ImplementationRepository::ServerInformationList_out & +ImplementationRepository::ServerInformationList_out::operator= (const ::ImplementationRepository::ServerInformationList_out &p) { - this->ptr_ = ACE_const_cast (ImplementationRepository::ServerInformationList_out&,p).ptr_; + this->ptr_ = ACE_const_cast (ServerInformationList_out&, p).ptr_; return *this; } -ACE_INLINE ImplementationRepository::ServerInformationList_out & -ImplementationRepository::ServerInformationList_out::operator= (ImplementationRepository::ServerInformationList *p) +ACE_INLINE ::ImplementationRepository::ServerInformationList_out & +ImplementationRepository::ServerInformationList_out::operator= (ServerInformationList *p) { this->ptr_ = p; return *this; } -ACE_INLINE -ImplementationRepository::ServerInformationList_out::operator ImplementationRepository::ServerInformationList *&() // cast +ACE_INLINE +ImplementationRepository::ServerInformationList_out::operator ::ImplementationRepository::ServerInformationList *&() // cast { return this->ptr_; } -ACE_INLINE ImplementationRepository::ServerInformationList *& +ACE_INLINE ::ImplementationRepository::ServerInformationList *& ImplementationRepository::ServerInformationList_out::ptr (void) // ptr { return this->ptr_; } -ACE_INLINE ImplementationRepository::ServerInformationList * +ACE_INLINE ::ImplementationRepository::ServerInformationList * ImplementationRepository::ServerInformationList_out::operator-> (void) { return this->ptr_; @@ -1450,23 +1485,23 @@ ImplementationRepository::Administration::~Administration (void) // destructor ACE_INLINE ImplementationRepository::Administration_var::Administration_var (void) // default constructor - : ptr_ (ImplementationRepository::Administration::_nil ()) + : ptr_ (Administration::_nil ()) {} ACE_INLINE -ImplementationRepository::Administration_var::Administration_var (ImplementationRepository::Administration_ptr p) +ImplementationRepository::Administration_var::Administration_var (Administration_ptr p) : ptr_ (p) {} -ACE_INLINE ImplementationRepository::Administration_ptr +ACE_INLINE ::ImplementationRepository::Administration_ptr ImplementationRepository::Administration_var::ptr (void) const { return this->ptr_; } ACE_INLINE -ImplementationRepository::Administration_var::Administration_var (const ImplementationRepository::Administration_var &p) // copy constructor - : ptr_ (ImplementationRepository::Administration::_duplicate (p.ptr ())) +ImplementationRepository::Administration_var::Administration_var (const ::ImplementationRepository::Administration_var &p) // copy constructor + : ptr_ (Administration::_duplicate (p.ptr ())) {} ACE_INLINE @@ -1476,7 +1511,7 @@ ImplementationRepository::Administration_var::~Administration_var (void) // dest } ACE_INLINE ImplementationRepository::Administration_var & -ImplementationRepository::Administration_var::operator= (ImplementationRepository::Administration_ptr p) +ImplementationRepository::Administration_var::operator= (Administration_ptr p) { CORBA::release (this->ptr_); this->ptr_ = p; @@ -1484,60 +1519,60 @@ ImplementationRepository::Administration_var::operator= (ImplementationRepositor } ACE_INLINE ImplementationRepository::Administration_var & -ImplementationRepository::Administration_var::operator= (const ImplementationRepository::Administration_var &p) +ImplementationRepository::Administration_var::operator= (const ::ImplementationRepository::Administration_var &p) { if (this != &p) { CORBA::release (this->ptr_); - this->ptr_ = ImplementationRepository::Administration::_duplicate (p.ptr ()); + this->ptr_ = ::ImplementationRepository::Administration::_duplicate (p.ptr ()); } return *this; } -ACE_INLINE -ImplementationRepository::Administration_var::operator const ImplementationRepository::Administration_ptr &() const // cast +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_; } -ACE_INLINE ImplementationRepository::Administration_ptr +ACE_INLINE ::ImplementationRepository::Administration_ptr ImplementationRepository::Administration_var::in (void) const { return this->ptr_; } -ACE_INLINE ImplementationRepository::Administration_ptr & +ACE_INLINE ::ImplementationRepository::Administration_ptr & ImplementationRepository::Administration_var::inout (void) { return this->ptr_; } -ACE_INLINE ImplementationRepository::Administration_ptr & +ACE_INLINE ::ImplementationRepository::Administration_ptr & ImplementationRepository::Administration_var::out (void) { CORBA::release (this->ptr_); - this->ptr_ = ImplementationRepository::Administration::_nil (); + this->ptr_ = ::ImplementationRepository::Administration::_nil (); return this->ptr_; } -ACE_INLINE ImplementationRepository::Administration_ptr +ACE_INLINE ::ImplementationRepository::Administration_ptr ImplementationRepository::Administration_var::_retn (void) { // yield ownership of managed obj reference - ImplementationRepository::Administration_ptr val = this->ptr_; - this->ptr_ = ImplementationRepository::Administration::_nil (); + ::ImplementationRepository::Administration_ptr val = this->ptr_; + this->ptr_ = ::ImplementationRepository::Administration::_nil (); return val; } @@ -1553,59 +1588,59 @@ ImplementationRepository::Administration_var::_retn (void) // ************************************************************* ACE_INLINE -ImplementationRepository::Administration_out::Administration_out (ImplementationRepository::Administration_ptr &p) +ImplementationRepository::Administration_out::Administration_out (Administration_ptr &p) : ptr_ (p) { - this->ptr_ = ImplementationRepository::Administration::_nil (); + this->ptr_ = ::ImplementationRepository::Administration::_nil (); } ACE_INLINE -ImplementationRepository::Administration_out::Administration_out (ImplementationRepository::Administration_var &p) // constructor from _var +ImplementationRepository::Administration_out::Administration_out (Administration_var &p) // constructor from _var : ptr_ (p.out ()) { CORBA::release (this->ptr_); - this->ptr_ = ImplementationRepository::Administration::_nil (); + this->ptr_ = ::ImplementationRepository::Administration::_nil (); } ACE_INLINE -ImplementationRepository::Administration_out::Administration_out (const ImplementationRepository::Administration_out &p) // copy constructor - : ptr_ (ACE_const_cast (ImplementationRepository::Administration_out&,p).ptr_) +ImplementationRepository::Administration_out::Administration_out (const ::ImplementationRepository::Administration_out &p) // copy constructor + : ptr_ (ACE_const_cast (Administration_out &, p).ptr_) {} -ACE_INLINE ImplementationRepository::Administration_out & -ImplementationRepository::Administration_out::operator= (const ImplementationRepository::Administration_out &p) +ACE_INLINE ::ImplementationRepository::Administration_out & +ImplementationRepository::Administration_out::operator= (const ::ImplementationRepository::Administration_out &p) { - this->ptr_ = ACE_const_cast (ImplementationRepository::Administration_out&,p).ptr_; + this->ptr_ = ACE_const_cast (Administration_out&, p).ptr_; return *this; } ACE_INLINE ImplementationRepository::Administration_out & -ImplementationRepository::Administration_out::operator= (const ImplementationRepository::Administration_var &p) +ImplementationRepository::Administration_out::operator= (const ::ImplementationRepository::Administration_var &p) { - this->ptr_ = ImplementationRepository::Administration::_duplicate (p.ptr ()); + this->ptr_ = ::ImplementationRepository::Administration::_duplicate (p.ptr ()); return *this; } ACE_INLINE ImplementationRepository::Administration_out & -ImplementationRepository::Administration_out::operator= (ImplementationRepository::Administration_ptr p) +ImplementationRepository::Administration_out::operator= (Administration_ptr p) { this->ptr_ = p; return *this; } -ACE_INLINE -ImplementationRepository::Administration_out::operator ImplementationRepository::Administration_ptr &() // cast +ACE_INLINE +ImplementationRepository::Administration_out::operator ::ImplementationRepository::Administration_ptr &() // cast { return this->ptr_; } -ACE_INLINE ImplementationRepository::Administration_ptr & +ACE_INLINE ::ImplementationRepository::Administration_ptr & 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_; @@ -1649,23 +1684,23 @@ ImplementationRepository::ServerInformationIterator::~ServerInformationIterator ACE_INLINE ImplementationRepository::ServerInformationIterator_var::ServerInformationIterator_var (void) // default constructor - : ptr_ (ImplementationRepository::ServerInformationIterator::_nil ()) + : ptr_ (ServerInformationIterator::_nil ()) {} ACE_INLINE -ImplementationRepository::ServerInformationIterator_var::ServerInformationIterator_var (ImplementationRepository::ServerInformationIterator_ptr p) +ImplementationRepository::ServerInformationIterator_var::ServerInformationIterator_var (ServerInformationIterator_ptr p) : ptr_ (p) {} -ACE_INLINE ImplementationRepository::ServerInformationIterator_ptr +ACE_INLINE ::ImplementationRepository::ServerInformationIterator_ptr ImplementationRepository::ServerInformationIterator_var::ptr (void) const { return this->ptr_; } ACE_INLINE -ImplementationRepository::ServerInformationIterator_var::ServerInformationIterator_var (const ImplementationRepository::ServerInformationIterator_var &p) // copy constructor - : ptr_ (ImplementationRepository::ServerInformationIterator::_duplicate (p.ptr ())) +ImplementationRepository::ServerInformationIterator_var::ServerInformationIterator_var (const ::ImplementationRepository::ServerInformationIterator_var &p) // copy constructor + : ptr_ (ServerInformationIterator::_duplicate (p.ptr ())) {} ACE_INLINE @@ -1675,7 +1710,7 @@ ImplementationRepository::ServerInformationIterator_var::~ServerInformationItera } ACE_INLINE ImplementationRepository::ServerInformationIterator_var & -ImplementationRepository::ServerInformationIterator_var::operator= (ImplementationRepository::ServerInformationIterator_ptr p) +ImplementationRepository::ServerInformationIterator_var::operator= (ServerInformationIterator_ptr p) { CORBA::release (this->ptr_); this->ptr_ = p; @@ -1683,60 +1718,60 @@ ImplementationRepository::ServerInformationIterator_var::operator= (Implementati } ACE_INLINE ImplementationRepository::ServerInformationIterator_var & -ImplementationRepository::ServerInformationIterator_var::operator= (const ImplementationRepository::ServerInformationIterator_var &p) +ImplementationRepository::ServerInformationIterator_var::operator= (const ::ImplementationRepository::ServerInformationIterator_var &p) { if (this != &p) { CORBA::release (this->ptr_); - this->ptr_ = ImplementationRepository::ServerInformationIterator::_duplicate (p.ptr ()); + this->ptr_ = ::ImplementationRepository::ServerInformationIterator::_duplicate (p.ptr ()); } return *this; } -ACE_INLINE -ImplementationRepository::ServerInformationIterator_var::operator const ImplementationRepository::ServerInformationIterator_ptr &() const // cast +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_; } -ACE_INLINE ImplementationRepository::ServerInformationIterator_ptr +ACE_INLINE ::ImplementationRepository::ServerInformationIterator_ptr ImplementationRepository::ServerInformationIterator_var::in (void) const { return this->ptr_; } -ACE_INLINE ImplementationRepository::ServerInformationIterator_ptr & +ACE_INLINE ::ImplementationRepository::ServerInformationIterator_ptr & ImplementationRepository::ServerInformationIterator_var::inout (void) { return this->ptr_; } -ACE_INLINE ImplementationRepository::ServerInformationIterator_ptr & +ACE_INLINE ::ImplementationRepository::ServerInformationIterator_ptr & ImplementationRepository::ServerInformationIterator_var::out (void) { CORBA::release (this->ptr_); - this->ptr_ = ImplementationRepository::ServerInformationIterator::_nil (); + this->ptr_ = ::ImplementationRepository::ServerInformationIterator::_nil (); return this->ptr_; } -ACE_INLINE ImplementationRepository::ServerInformationIterator_ptr +ACE_INLINE ::ImplementationRepository::ServerInformationIterator_ptr ImplementationRepository::ServerInformationIterator_var::_retn (void) { // yield ownership of managed obj reference - ImplementationRepository::ServerInformationIterator_ptr val = this->ptr_; - this->ptr_ = ImplementationRepository::ServerInformationIterator::_nil (); + ::ImplementationRepository::ServerInformationIterator_ptr val = this->ptr_; + this->ptr_ = ::ImplementationRepository::ServerInformationIterator::_nil (); return val; } @@ -1752,59 +1787,59 @@ ImplementationRepository::ServerInformationIterator_var::_retn (void) // ************************************************************* ACE_INLINE -ImplementationRepository::ServerInformationIterator_out::ServerInformationIterator_out (ImplementationRepository::ServerInformationIterator_ptr &p) +ImplementationRepository::ServerInformationIterator_out::ServerInformationIterator_out (ServerInformationIterator_ptr &p) : ptr_ (p) { - this->ptr_ = ImplementationRepository::ServerInformationIterator::_nil (); + this->ptr_ = ::ImplementationRepository::ServerInformationIterator::_nil (); } ACE_INLINE -ImplementationRepository::ServerInformationIterator_out::ServerInformationIterator_out (ImplementationRepository::ServerInformationIterator_var &p) // constructor from _var +ImplementationRepository::ServerInformationIterator_out::ServerInformationIterator_out (ServerInformationIterator_var &p) // constructor from _var : ptr_ (p.out ()) { CORBA::release (this->ptr_); - this->ptr_ = ImplementationRepository::ServerInformationIterator::_nil (); + this->ptr_ = ::ImplementationRepository::ServerInformationIterator::_nil (); } ACE_INLINE -ImplementationRepository::ServerInformationIterator_out::ServerInformationIterator_out (const ImplementationRepository::ServerInformationIterator_out &p) // copy constructor - : ptr_ (ACE_const_cast (ImplementationRepository::ServerInformationIterator_out&,p).ptr_) +ImplementationRepository::ServerInformationIterator_out::ServerInformationIterator_out (const ::ImplementationRepository::ServerInformationIterator_out &p) // copy constructor + : ptr_ (ACE_const_cast (ServerInformationIterator_out &, p).ptr_) {} -ACE_INLINE ImplementationRepository::ServerInformationIterator_out & -ImplementationRepository::ServerInformationIterator_out::operator= (const ImplementationRepository::ServerInformationIterator_out &p) +ACE_INLINE ::ImplementationRepository::ServerInformationIterator_out & +ImplementationRepository::ServerInformationIterator_out::operator= (const ::ImplementationRepository::ServerInformationIterator_out &p) { - this->ptr_ = ACE_const_cast (ImplementationRepository::ServerInformationIterator_out&,p).ptr_; + this->ptr_ = ACE_const_cast (ServerInformationIterator_out&, p).ptr_; return *this; } ACE_INLINE ImplementationRepository::ServerInformationIterator_out & -ImplementationRepository::ServerInformationIterator_out::operator= (const ImplementationRepository::ServerInformationIterator_var &p) +ImplementationRepository::ServerInformationIterator_out::operator= (const ::ImplementationRepository::ServerInformationIterator_var &p) { - this->ptr_ = ImplementationRepository::ServerInformationIterator::_duplicate (p.ptr ()); + this->ptr_ = ::ImplementationRepository::ServerInformationIterator::_duplicate (p.ptr ()); return *this; } ACE_INLINE ImplementationRepository::ServerInformationIterator_out & -ImplementationRepository::ServerInformationIterator_out::operator= (ImplementationRepository::ServerInformationIterator_ptr p) +ImplementationRepository::ServerInformationIterator_out::operator= (ServerInformationIterator_ptr p) { this->ptr_ = p; return *this; } -ACE_INLINE -ImplementationRepository::ServerInformationIterator_out::operator ImplementationRepository::ServerInformationIterator_ptr &() // cast +ACE_INLINE +ImplementationRepository::ServerInformationIterator_out::operator ::ImplementationRepository::ServerInformationIterator_ptr &() // cast { return this->ptr_; } -ACE_INLINE ImplementationRepository::ServerInformationIterator_ptr & +ACE_INLINE ::ImplementationRepository::ServerInformationIterator_ptr & 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 +1906,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 +1918,7 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, ImplementationReposito return 1; else return 0; - + } @@ -1929,7 +1964,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 +1978,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 +1992,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 +2006,7 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, ImplementationReposito return 1; else return 0; - + } @@ -2019,7 +2054,7 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const ImplementationR return 0; } -ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::Administration::AlreadyRegistered &) +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &,ImplementationRepository::Administration::AlreadyRegistered&) { return 1; } @@ -2061,14 +2096,15 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const ImplementationR return 0; } -ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, ImplementationRepository::Administration::CannotActivate &_tao_aggregate) +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm,ImplementationRepository::Administration::CannotActivate &_tao_aggregate) { // now marshal the members if ( - (strm >> _tao_aggregate.reason.out ()) - ) + (strm >> _tao_aggregate.reason.out ()) + ) return 1; - return 0; + else + return 0; } #if !defined (ACE_LACKS_IOSTREAM_TOTALLY) @@ -2100,7 +2136,7 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const ImplementationR return 0; } -ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &, ImplementationRepository::Administration::NotFound &) +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &,ImplementationRepository::Administration::NotFound&) { return 1; } @@ -2211,3 +2247,4 @@ operator>> ( ACE_ENDTRY; return 0; } + diff --git a/TAO/tao/ImplRepoS.cpp b/TAO/tao/ImplRepoS.cpp index 6aa24408240..a8233956b48 100644 --- a/TAO/tao/ImplRepoS.cpp +++ b/TAO/tao/ImplRepoS.cpp @@ -20,9 +20,9 @@ private: public: const TAO_operation_db_entry * lookup (const char *str, unsigned int len); }; -/* starting time is 3:08:21 */ +/* starting time is 12:16:37 */ /* C++ code produced by gperf version 2.8 (ACE version) */ -/* Command-line: gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_ImplementationRepository_ServerObject_Perfect_Hash_OpTable -N lookup */ +/* Command-line: /home/coryan/subsets/ACE_wrappers/build/Linux/bin/gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_ImplementationRepository_ServerObject_Perfect_Hash_OpTable -N lookup */ unsigned int TAO_ImplementationRepository_ServerObject_Perfect_Hash_OpTable::hash (const char *str, unsigned int len) { @@ -113,7 +113,7 @@ TAO_ImplementationRepository_ServerObject_Perfect_Hash_OpTable::lookup (const ch } return 0; } -/* ending time is 3:08:21 */ +/* ending time is 12:16:37 */ static TAO_ImplementationRepository_ServerObject_Perfect_Hash_OpTable tao_ImplementationRepository_ServerObject_optable; ImplementationRepository::ServerObject_ptr _TAO_collocation_POA_ImplementationRepository_ServerObject_Stub_Factory ( @@ -248,7 +248,7 @@ void POA_ImplementationRepository::ServerObject::ping_skel ( _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; -} + } void POA_ImplementationRepository::ServerObject::shutdown_skel ( CORBA::ServerRequest &_tao_server_request, @@ -327,7 +327,7 @@ void POA_ImplementationRepository::ServerObject::shutdown_skel ( _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; -} + } void POA_ImplementationRepository::ServerObject::_is_a_skel ( CORBA::ServerRequest &_tao_server_request, @@ -424,7 +424,7 @@ POA_ImplementationRepository::ServerObject::_this (CORBA_Environment &ACE_TRY_EN { case TAO_ORB_Core::THRU_POA: { - ImplementationRepository::ServerObject_ptr retval = 0; + ::ImplementationRepository::ServerObject_ptr retval = 0; ACE_NEW_RETURN ( retval, POA_ImplementationRepository::_tao_thru_poa_collocated_ServerObject (stub), @@ -443,15 +443,14 @@ POA_ImplementationRepository::ServerObject::_this (CORBA_Environment &ACE_TRY_EN CORBA::Object_ptr tmp = CORBA::Object::_nil (); ACE_NEW_RETURN (tmp, CORBA::Object (stub), 0); CORBA::Object_var obj = tmp; - return ImplementationRepository::ServerObject::_unchecked_narrow (obj.in ()); + return ::ImplementationRepository::ServerObject::_unchecked_narrow (obj.in ()); } } POA_ImplementationRepository::_tao_thru_poa_collocated_ServerObject::_tao_thru_poa_collocated_ServerObject ( TAO_Stub *stub ) - : ACE_NESTED_CLASS (ImplementationRepository,ServerObject) (), - CORBA_Object (stub, 0, 1) + : CORBA_Object (stub, 0, 1) { } @@ -565,9 +564,9 @@ private: public: const TAO_operation_db_entry * lookup (const char *str, unsigned int len); }; -/* starting time is 3:08:22 */ +/* starting time is 12:16:37 */ /* C++ code produced by gperf version 2.8 (ACE version) */ -/* Command-line: gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_ImplementationRepository_Administration_Perfect_Hash_OpTable -N lookup */ +/* Command-line: /home/coryan/subsets/ACE_wrappers/build/Linux/bin/gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_ImplementationRepository_Administration_Perfect_Hash_OpTable -N lookup */ unsigned int TAO_ImplementationRepository_Administration_Perfect_Hash_OpTable::hash (const char *str, unsigned int len) { @@ -673,7 +672,7 @@ TAO_ImplementationRepository_Administration_Perfect_Hash_OpTable::lookup (const } return 0; } -/* ending time is 3:08:22 */ +/* ending time is 12:16:37 */ static TAO_ImplementationRepository_Administration_Perfect_Hash_OpTable tao_ImplementationRepository_Administration_optable; ImplementationRepository::Administration_ptr _TAO_collocation_POA_ImplementationRepository_Administration_Stub_Factory ( @@ -816,7 +815,7 @@ void POA_ImplementationRepository::Administration::activate_server_skel ( _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; -} + } void POA_ImplementationRepository::Administration::register_server_skel ( CORBA::ServerRequest &_tao_server_request, @@ -906,7 +905,7 @@ void POA_ImplementationRepository::Administration::register_server_skel ( _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; -} + } void POA_ImplementationRepository::Administration::reregister_server_skel ( CORBA::ServerRequest &_tao_server_request, @@ -996,7 +995,7 @@ void POA_ImplementationRepository::Administration::reregister_server_skel ( _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; -} + } void POA_ImplementationRepository::Administration::remove_server_skel ( CORBA::ServerRequest &_tao_server_request, @@ -1083,7 +1082,7 @@ void POA_ImplementationRepository::Administration::remove_server_skel ( _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; -} + } void POA_ImplementationRepository::Administration::shutdown_server_skel ( CORBA::ServerRequest &_tao_server_request, @@ -1170,7 +1169,7 @@ void POA_ImplementationRepository::Administration::shutdown_server_skel ( _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; -} + } void POA_ImplementationRepository::Administration::server_is_running_skel ( CORBA::ServerRequest &_tao_server_request, @@ -1264,7 +1263,6 @@ void POA_ImplementationRepository::Administration::server_is_running_skel ( _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; - ACE_CHECK; TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); if (!( (_tao_out << _tao_retval.in ()) @@ -1358,7 +1356,7 @@ void POA_ImplementationRepository::Administration::server_is_shutting_down_skel _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; -} + } void POA_ImplementationRepository::Administration::find_skel ( CORBA::ServerRequest &_tao_server_request, @@ -1447,7 +1445,6 @@ void POA_ImplementationRepository::Administration::find_skel ( _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; - ACE_CHECK; TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); if (!( (_tao_out << info.in ()) @@ -1545,7 +1542,6 @@ void POA_ImplementationRepository::Administration::list_skel ( _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; - ACE_CHECK; TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); if (!( (_tao_out << server_list.in ()) && @@ -1650,7 +1646,7 @@ POA_ImplementationRepository::Administration::_this (CORBA_Environment &ACE_TRY_ { case TAO_ORB_Core::THRU_POA: { - ImplementationRepository::Administration_ptr retval = 0; + ::ImplementationRepository::Administration_ptr retval = 0; ACE_NEW_RETURN ( retval, POA_ImplementationRepository::_tao_thru_poa_collocated_Administration (stub), @@ -1669,15 +1665,14 @@ POA_ImplementationRepository::Administration::_this (CORBA_Environment &ACE_TRY_ CORBA::Object_ptr tmp = CORBA::Object::_nil (); ACE_NEW_RETURN (tmp, CORBA::Object (stub), 0); CORBA::Object_var obj = tmp; - return ImplementationRepository::Administration::_unchecked_narrow (obj.in ()); + return ::ImplementationRepository::Administration::_unchecked_narrow (obj.in ()); } } POA_ImplementationRepository::_tao_thru_poa_collocated_Administration::_tao_thru_poa_collocated_Administration ( TAO_Stub *stub ) - : ACE_NESTED_CLASS (ImplementationRepository,Administration) (), - CORBA_Object (stub, 0, 1) + : CORBA_Object (stub, 0, 1) { } @@ -2022,9 +2017,9 @@ private: public: const TAO_operation_db_entry * lookup (const char *str, unsigned int len); }; -/* starting time is 3:08:22 */ +/* starting time is 12:16:37 */ /* C++ code produced by gperf version 2.8 (ACE version) */ -/* Command-line: gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_ImplementationRepository_ServerInformationIterator_Perfect_Hash_OpTable -N lookup */ +/* Command-line: /home/coryan/subsets/ACE_wrappers/build/Linux/bin/gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_ImplementationRepository_ServerInformationIterator_Perfect_Hash_OpTable -N lookup */ unsigned int TAO_ImplementationRepository_ServerInformationIterator_Perfect_Hash_OpTable::hash (const char *str, unsigned int len) { @@ -2114,7 +2109,7 @@ TAO_ImplementationRepository_ServerInformationIterator_Perfect_Hash_OpTable::loo } return 0; } -/* ending time is 3:08:22 */ +/* ending time is 12:16:37 */ static TAO_ImplementationRepository_ServerInformationIterator_Perfect_Hash_OpTable tao_ImplementationRepository_ServerInformationIterator_optable; ImplementationRepository::ServerInformationIterator_ptr _TAO_collocation_POA_ImplementationRepository_ServerInformationIterator_Stub_Factory ( @@ -2260,7 +2255,6 @@ void POA_ImplementationRepository::ServerInformationIterator::next_n_skel ( _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; - ACE_CHECK; TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); if (!( (_tao_out << CORBA::Any::from_boolean (_tao_retval)) && @@ -2347,7 +2341,7 @@ void POA_ImplementationRepository::ServerInformationIterator::destroy_skel ( _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; -} + } void POA_ImplementationRepository::ServerInformationIterator::_is_a_skel ( CORBA::ServerRequest &_tao_server_request, @@ -2444,7 +2438,7 @@ POA_ImplementationRepository::ServerInformationIterator::_this (CORBA_Environmen { case TAO_ORB_Core::THRU_POA: { - ImplementationRepository::ServerInformationIterator_ptr retval = 0; + ::ImplementationRepository::ServerInformationIterator_ptr retval = 0; ACE_NEW_RETURN ( retval, POA_ImplementationRepository::_tao_thru_poa_collocated_ServerInformationIterator (stub), @@ -2463,15 +2457,14 @@ POA_ImplementationRepository::ServerInformationIterator::_this (CORBA_Environmen CORBA::Object_ptr tmp = CORBA::Object::_nil (); ACE_NEW_RETURN (tmp, CORBA::Object (stub), 0); CORBA::Object_var obj = tmp; - return ImplementationRepository::ServerInformationIterator::_unchecked_narrow (obj.in ()); + return ::ImplementationRepository::ServerInformationIterator::_unchecked_narrow (obj.in ()); } } POA_ImplementationRepository::_tao_thru_poa_collocated_ServerInformationIterator::_tao_thru_poa_collocated_ServerInformationIterator ( TAO_Stub *stub ) - : ACE_NESTED_CLASS (ImplementationRepository,ServerInformationIterator) (), - CORBA_Object (stub, 0, 1) + : CORBA_Object (stub, 0, 1) { } diff --git a/TAO/tao/ImplRepoS.h b/TAO/tao/ImplRepoS.h index d8291e2932d..c498ab50d65 100644 --- a/TAO/tao/ImplRepoS.h +++ b/TAO/tao/ImplRepoS.h @@ -11,7 +11,7 @@ #include "ace/pre.h" #define _TAO_IDL_IMPLREPOS_H_ -#include "tao/ImplRepoC.h" +#include "ImplRepoC.h" #if !defined (ACE_LACKS_PRAGMA_ONCE) @@ -72,7 +72,7 @@ TAO_NAMESPACE POA_ImplementationRepository TAO_default_environment () ); - ImplementationRepository::ServerObject *_this ( + ::ImplementationRepository::ServerObject *_this ( CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ); @@ -118,7 +118,7 @@ TAO_NAMESPACE POA_ImplementationRepository #if !defined (_IMPLEMENTATIONREPOSITORY_SERVEROBJECT___THRU_POA_COLLOCATED_SH_) #define _IMPLEMENTATIONREPOSITORY_SERVEROBJECT___THRU_POA_COLLOCATED_SH_ - class TAO_Export _tao_thru_poa_collocated_ServerObject : public virtual ImplementationRepository::ServerObject + class TAO_Export _tao_thru_poa_collocated_ServerObject : public virtual ::ImplementationRepository::ServerObject { public: _tao_thru_poa_collocated_ServerObject ( @@ -262,7 +262,7 @@ private: TAO_default_environment () ); - ImplementationRepository::Administration *_this ( + ::ImplementationRepository::Administration *_this ( CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ); @@ -444,7 +444,7 @@ private: #if !defined (_IMPLEMENTATIONREPOSITORY_ADMINISTRATION___THRU_POA_COLLOCATED_SH_) #define _IMPLEMENTATIONREPOSITORY_ADMINISTRATION___THRU_POA_COLLOCATED_SH_ - class TAO_Export _tao_thru_poa_collocated_Administration : public virtual ImplementationRepository::Administration + class TAO_Export _tao_thru_poa_collocated_Administration : public virtual ::ImplementationRepository::Administration { public: _tao_thru_poa_collocated_Administration ( @@ -748,7 +748,7 @@ private: TAO_default_environment () ); - ImplementationRepository::ServerInformationIterator *_this ( + ::ImplementationRepository::ServerInformationIterator *_this ( CORBA::Environment &ACE_TRY_ENV = TAO_default_environment () ); @@ -796,7 +796,7 @@ private: #if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR___THRU_POA_COLLOCATED_SH_) #define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONITERATOR___THRU_POA_COLLOCATED_SH_ - class TAO_Export _tao_thru_poa_collocated_ServerInformationIterator : public virtual ImplementationRepository::ServerInformationIterator + class TAO_Export _tao_thru_poa_collocated_ServerInformationIterator : public virtual ::ImplementationRepository::ServerInformationIterator { public: _tao_thru_poa_collocated_ServerInformationIterator ( diff --git a/TAO/tao/InterceptorC.cpp b/TAO/tao/InterceptorC.cpp index 41fdfe74349..8f6c69e5fd2 100644 --- a/TAO/tao/InterceptorC.cpp +++ b/TAO/tao/InterceptorC.cpp @@ -15,6 +15,7 @@ #endif /* !defined INLINE */ #if defined (TAO_HAS_INTERCEPTORS) + PortableInterceptor::Cookie_ptr PortableInterceptor::Cookie::_narrow ( CORBA::Object_ptr obj, CORBA::Environment &ACE_TRY_ENV @@ -57,6 +58,12 @@ PortableInterceptor::Cookie::_duplicate (PortableInterceptor::Cookie_ptr obj) return obj; } +void PortableInterceptor::Cookie::_tao_any_destructor (void *x) +{ + PortableInterceptor::Cookie *tmp = ACE_static_cast (PortableInterceptor::Cookie*,x); + CORBA::release (tmp); +} + CORBA::Boolean PortableInterceptor::Cookie::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV) { if ( @@ -205,6 +212,11 @@ PortableInterceptor::Cookies::Cookies (const Cookies &seq) // copy ctor PortableInterceptor::Cookies::~Cookies (void) // dtor {} +void PortableInterceptor::Cookies::_tao_any_destructor (void *x) +{ + PortableInterceptor::Cookies *tmp = ACE_static_cast(PortableInterceptor::Cookies*,x); + delete tmp; +} #endif /* end #if !defined */ @@ -272,6 +284,12 @@ PortableInterceptor::Interceptor::_duplicate (PortableInterceptor::Interceptor_p return obj; } +void PortableInterceptor::Interceptor::_tao_any_destructor (void* x) +{ + PortableInterceptor::Interceptor *tmp = ACE_static_cast(PortableInterceptor::Interceptor*,x); + CORBA::release (tmp); +} + CORBA::Boolean PortableInterceptor::Interceptor::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV) { if ( @@ -340,6 +358,12 @@ PortableInterceptor::ServerRequestInterceptor::_duplicate (PortableInterceptor:: return obj; } +void PortableInterceptor::ServerRequestInterceptor::_tao_any_destructor (void *x) +{ + PortableInterceptor::ServerRequestInterceptor *tmp = ACE_static_cast (PortableInterceptor::ServerRequestInterceptor*,x); + CORBA::release (tmp); +} + CORBA::Boolean PortableInterceptor::ServerRequestInterceptor::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV) { if ( @@ -409,6 +433,12 @@ PortableInterceptor::ClientRequestInterceptor::_duplicate (PortableInterceptor:: return obj; } +void PortableInterceptor::ClientRequestInterceptor::_tao_any_destructor (void *x) +{ + PortableInterceptor::ClientRequestInterceptor *tmp = ACE_static_cast (PortableInterceptor::ClientRequestInterceptor*,x); + CORBA::release (tmp); +} + CORBA::Boolean PortableInterceptor::ClientRequestInterceptor::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV) { if ( @@ -436,49 +466,28 @@ TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) TAO_NAMESPACE_BEGIN (PortableInterceptor) TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ClientRequestInterceptor, &_tc_TAO_tc_PortableInterceptor_ClientRequestInterceptor) TAO_NAMESPACE_END + void operator<<= (CORBA::Any &_tao_any, PortableInterceptor::Cookie_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 = PortableInterceptor::Cookie::_duplicate (_tao_elem); - TAO_OutputCDR stream; - if (stream << *_tao_obj_ptr) + TAO_OutputCDR stream; + if (stream << _tao_elem) { _tao_any._tao_replace ( - PortableInterceptor::_tc_Cookie, + PortableInterceptor::_tc_Cookie, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_obj_ptr; } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; } 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->equivalent (PortableInterceptor::_tc_Cookie, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -491,24 +500,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableInterceptor::Coo { _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)->_tao_replace ( PortableInterceptor::_tc_Cookie, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + PortableInterceptor::Cookie::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = PortableInterceptor::Cookie::_nil (); return 0; } @@ -530,40 +532,19 @@ void operator<<= ( const PortableInterceptor::Cookies &_tao_elem ) // copying { - PortableInterceptor::Cookies *_tao_any_val; - ACE_NEW (_tao_any_val, PortableInterceptor::Cookies (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - if (stream << *_tao_any_val) + if (stream << _tao_elem) { _tao_any._tao_replace ( PortableInterceptor::_tc_Cookies, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_any_val; - } - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; } void operator<<= (CORBA::Any &_tao_any, PortableInterceptor::Cookies *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -572,16 +553,8 @@ void operator<<= (CORBA::Any &_tao_any, PortableInterceptor::Cookies *_tao_elem) stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + PortableInterceptor::Cookies::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableInterceptor::Cookies *&_tao_elem) @@ -613,9 +586,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableInterceptor::Coo PortableInterceptor::_tc_Cookies, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + PortableInterceptor::Cookies::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -629,7 +601,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableInterceptor::Coo { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -637,98 +609,30 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableInterceptor::Coo 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; + return _tao_any >>= ACE_const_cast(PortableInterceptor::Cookies*&,_tao_elem); } void operator<<= (CORBA::Any &_tao_any, PortableInterceptor::Interceptor_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 = PortableInterceptor::Interceptor::_duplicate (_tao_elem); - 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 + TAO_OutputCDR stream; + if (stream << _tao_elem) { - delete _tao_obj_ptr; + _tao_any._tao_replace ( + PortableInterceptor::_tc_Interceptor, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); } - ACE_ENDTRY; } 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->equivalent (PortableInterceptor::_tc_Interceptor, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -741,24 +645,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableInterceptor::Int { _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)->_tao_replace ( PortableInterceptor::_tc_Interceptor, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + PortableInterceptor::Interceptor::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = PortableInterceptor::Interceptor::_nil (); return 0; } @@ -777,47 +674,25 @@ template class TAO_Object_Manager<PortableInterceptor::Interceptor,PortableInter void operator<<= (CORBA::Any &_tao_any, PortableInterceptor::ServerRequestInterceptor_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 = PortableInterceptor::ServerRequestInterceptor::_duplicate (_tao_elem); TAO_OutputCDR stream; - if (stream << *_tao_obj_ptr) + if (stream << _tao_elem) { _tao_any._tao_replace ( - PortableInterceptor::_tc_ServerRequestInterceptor, + PortableInterceptor::_tc_ServerRequestInterceptor, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; } 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->equivalent (PortableInterceptor::_tc_ServerRequestInterceptor, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -830,24 +705,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableInterceptor::Ser { _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)->_tao_replace ( PortableInterceptor::_tc_ServerRequestInterceptor, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + PortableInterceptor::ServerRequestInterceptor::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = PortableInterceptor::ServerRequestInterceptor::_nil (); return 0; } @@ -866,47 +734,25 @@ template class TAO_Object_Manager<PortableInterceptor::ServerRequestInterceptor, void operator<<= (CORBA::Any &_tao_any, PortableInterceptor::ClientRequestInterceptor_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 = PortableInterceptor::ClientRequestInterceptor::_duplicate (_tao_elem); TAO_OutputCDR stream; - if (stream << *_tao_obj_ptr) + if (stream << _tao_elem) { _tao_any._tao_replace ( - PortableInterceptor::_tc_ClientRequestInterceptor, + PortableInterceptor::_tc_ClientRequestInterceptor, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_obj_ptr; } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; } 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->equivalent (PortableInterceptor::_tc_ClientRequestInterceptor, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -919,24 +765,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableInterceptor::Cli { _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)->_tao_replace ( PortableInterceptor::_tc_ClientRequestInterceptor, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + PortableInterceptor::ClientRequestInterceptor::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = PortableInterceptor::ClientRequestInterceptor::_nil (); return 0; } @@ -982,7 +821,7 @@ CORBA::Boolean operator>> ( // set the length of the sequence _tao_sequence.length (_tao_seq_len); // If length is 0 we return true. - if (0 >= _tao_seq_len) + if (0 >= _tao_seq_len) return 1; // retrieve all the elements CORBA::Boolean _tao_marshal_flag = 1; diff --git a/TAO/tao/InterceptorC.h b/TAO/tao/InterceptorC.h index 10ffc404bc7..d4596b5e025 100644 --- a/TAO/tao/InterceptorC.h +++ b/TAO/tao/InterceptorC.h @@ -127,6 +127,7 @@ class TAO_Export Cookie : public virtual ACE_CORBA_1 (Object) { return (PortableInterceptor::Cookie_ptr)0; } + static void _tao_any_destructor (void*); virtual char * myname ( CORBA::Environment &ACE_TRY_ENV = @@ -226,6 +227,8 @@ class TAO_Export Cookie : public virtual ACE_CORBA_1 (Object) ); Cookies (const Cookies &); // copy ctor ~Cookies (void); // dtor + + static void _tao_any_destructor (void*); }; typedef Cookies *Cookies_ptr; @@ -386,6 +389,7 @@ class TAO_Export Interceptor : public virtual ACE_CORBA_1 (Object) { return (PortableInterceptor::Interceptor_ptr)0; } + static void _tao_any_destructor (void*); virtual char * name ( CORBA::Environment &ACE_TRY_ENV = @@ -504,6 +508,7 @@ class TAO_Export ServerRequestInterceptor: public virtual Interceptor { return (PortableInterceptor::ServerRequestInterceptor_ptr)0; } + static void _tao_any_destructor (void*); virtual void preinvoke ( CORBA::ULong request_id, @@ -651,6 +656,7 @@ class TAO_Export ClientRequestInterceptor: public virtual Interceptor { return (PortableInterceptor::ClientRequestInterceptor_ptr)0; } + static void _tao_any_destructor (void*); virtual void preinvoke ( CORBA::ULong request_id, @@ -715,32 +721,32 @@ class TAO_Export ClientRequestInterceptor: public virtual Interceptor TAO_NAMESPACE_CLOSE // module PortableInterceptor // Any operators for interface PortableInterceptor::Cookie -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, PortableInterceptor::Cookie_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableInterceptor::Cookie *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const PortableInterceptor::Cookies &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, PortableInterceptor::Cookies*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableInterceptor::Cookies *&); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const PortableInterceptor::Cookies *&); // Any operators for interface PortableInterceptor::Interceptor -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, PortableInterceptor::Interceptor_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableInterceptor::Interceptor *&); // Any operators for interface PortableInterceptor::ServerRequestInterceptor -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, PortableInterceptor::ServerRequestInterceptor_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableInterceptor::ServerRequestInterceptor *&); // Any operators for interface PortableInterceptor::ClientRequestInterceptor -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, PortableInterceptor::ClientRequestInterceptor_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableInterceptor::ClientRequestInterceptor *&); #ifndef __ACE_INLINE__ diff --git a/TAO/tao/InterfaceC.cpp b/TAO/tao/InterfaceC.cpp index f2ca479ac4d..378b92620d6 100644 --- a/TAO/tao/InterfaceC.cpp +++ b/TAO/tao/InterfaceC.cpp @@ -13789,31 +13789,16 @@ 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) { - CORBA::DefinitionKind *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA::DefinitionKind (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_tao_any_val; + stream << _tao_elem; _tao_any._tao_replace ( CORBA::_tc_DefinitionKind, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - // free allocated storage - delete _tao_any_val; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::DefinitionKind &_tao_elem) @@ -13848,47 +13833,31 @@ CORBA::IRObject_ptr (*_TAO_collocation_CORBA_IRObject_Stub_Factory_function_poin ) = 0; void operator<<= (CORBA::Any &_tao_any, CORBA::IRObject_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::IRObject::_duplicate (_tao_elem); TAO_OutputCDR stream; - if (stream << *_tao_obj_ptr) + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_IRObject, + CORBA::_tc_IRObject, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void CORBA::IRObject::_tao_any_destructor (void *x) +{ + CORBA::IRObject *tmp = ACE_static_cast(CORBA::IRObject*,x); + CORBA::release (tmp); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::IRObject_ptr &_tao_elem) { - CORBA::Object_ptr *tmp = 0; - ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = CORBA::IRObject::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (CORBA::_tc_IRObject, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -13901,24 +13870,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::IRObject_ptr &_ta { _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)->_tao_replace ( CORBA::_tc_IRObject, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + CORBA::IRObject::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = CORBA::IRObject::_nil (); return 0; } @@ -13941,47 +13903,31 @@ CORBA::Contained_ptr (*_TAO_collocation_CORBA_Contained_Stub_Factory_function_po ) = 0; void operator<<= (CORBA::Any &_tao_any, CORBA::Contained_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::Contained::_duplicate (_tao_elem); TAO_OutputCDR stream; - if (stream << *_tao_obj_ptr) + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_Contained, + CORBA::_tc_Contained, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_obj_ptr; } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void CORBA::Contained::_tao_any_destructor (void *x) +{ + CORBA::Contained *tmp = ACE_static_cast(CORBA::Contained*,x); + CORBA::release (tmp); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Contained_ptr &_tao_elem) { - CORBA::Object_ptr *tmp = 0; - ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = CORBA::Contained::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (CORBA::_tc_Contained, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -13994,24 +13940,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Contained_ptr &_t { _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)->_tao_replace ( CORBA::_tc_Contained, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + CORBA::Contained::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = CORBA::Contained::_nil (); return 0; } @@ -14031,34 +13970,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Contained_ptr &_t void operator<<= (CORBA::Any &_tao_any, const CORBA::Contained::Description &_tao_elem) // copying { - CORBA::Contained::Description *_any_val = 0; - ACE_NEW (_any_val, CORBA::Contained::Description (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_any_val; + stream << _tao_elem; _tao_any._tao_replace ( CORBA::Contained::_tc_Description, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _any_val; - } - ACE_ENDTRY; +} + +void CORBA::Contained::Description::_tao_any_destructor (void *x) +{ + CORBA::Contained::Description *tmp = ACE_const_cast(CORBA::Contained::Description*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, CORBA::Contained::Description *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -14067,16 +13995,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::Contained::Description *_tao_elem stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::Contained::Description::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Contained::Description *&_tao_elem) @@ -14108,9 +14028,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Contained::Descri CORBA::Contained::_tc_Description, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::Contained::Description::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -14124,7 +14043,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Contained::Descri { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -14132,53 +14051,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Contained::Descri 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; + return _tao_any >>= ACE_const_cast(CORBA::Contained::Description*&,_tao_elem); } void operator<<= ( @@ -14186,40 +14059,25 @@ void operator<<= ( const CORBA::InterfaceDefSeq &_tao_elem ) // copying { - CORBA::InterfaceDefSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA::InterfaceDefSeq (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - if (stream << *_tao_any_val) + if (stream << _tao_elem) { _tao_any._tao_replace ( CORBA::_tc_InterfaceDefSeq, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_any_val; - } - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void CORBA::InterfaceDefSeq::_tao_any_destructor (void *x) +{ + CORBA::InterfaceDefSeq *tmp = ACE_const_cast(CORBA::InterfaceDefSeq*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, CORBA::InterfaceDefSeq *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -14228,16 +14086,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::InterfaceDefSeq *_tao_elem) // no stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::InterfaceDefSeq::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InterfaceDefSeq *&_tao_elem) @@ -14269,9 +14119,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InterfaceDefSeq * CORBA::_tc_InterfaceDefSeq, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::InterfaceDefSeq::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -14285,7 +14134,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InterfaceDefSeq * { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -14293,53 +14142,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InterfaceDefSeq * 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; + return _tao_any >>= ACE_const_cast(CORBA::InterfaceDefSeq*&,_tao_elem); } void operator<<= ( @@ -14347,40 +14150,25 @@ void operator<<= ( const CORBA::ValueDefSeq &_tao_elem ) // copying { - CORBA::ValueDefSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA::ValueDefSeq (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - if (stream << *_tao_any_val) + if (stream << _tao_elem) { _tao_any._tao_replace ( CORBA::_tc_ValueDefSeq, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_any_val; - } - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void CORBA::ValueDefSeq::_tao_any_destructor (void *x) +{ + CORBA::ValueDefSeq *tmp = ACE_static_cast(CORBA::ValueDefSeq*,x); + delete x; } void operator<<= (CORBA::Any &_tao_any, CORBA::ValueDefSeq *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -14389,16 +14177,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::ValueDefSeq *_tao_elem) // non co stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::ValueDefSeq::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueDefSeq *&_tao_elem) @@ -14430,9 +14210,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueDefSeq *&_ta CORBA::_tc_ValueDefSeq, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::ValueDefSeq::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -14446,7 +14225,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueDefSeq *&_ta { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -14454,53 +14233,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueDefSeq *&_ta 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; + return _tao_any >>= ACE_const_cast(CORBA::ValueDefSeq*&,_tao_elem); } void operator<<= ( @@ -14508,40 +14241,25 @@ void operator<<= ( const CORBA::ContainedSeq &_tao_elem ) // copying { - CORBA::ContainedSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA::ContainedSeq (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - if (stream << *_tao_any_val) + if (stream << _tao_elem) { _tao_any._tao_replace ( CORBA::_tc_ContainedSeq, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_any_val; } - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void CORBA::ContainedSeq::_tao_any_destructor (void *x) +{ + CORBA::ContainedSeq *tmp = ACE_static_cast(CORBA::ContainedSeq*,x); + delete x; } void operator<<= (CORBA::Any &_tao_any, CORBA::ContainedSeq *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -14550,16 +14268,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::ContainedSeq *_tao_elem) // non c stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::ContainedSeq::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ContainedSeq *&_tao_elem) @@ -14591,9 +14301,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ContainedSeq *&_t CORBA::_tc_ContainedSeq, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::ContainedSeq::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -14607,7 +14316,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ContainedSeq *&_t { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -14615,85 +14324,28 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ContainedSeq *&_t 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; + return _tao_any >>= ACE_const_cast(CORBA::ContainedSeq*&,_tao_elem); } void operator<<= (CORBA::Any &_tao_any, const CORBA::StructMember &_tao_elem) // copying { - CORBA::StructMember *_any_val = 0; - ACE_NEW (_any_val, CORBA::StructMember (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_any_val; + stream << _tao_elem; _tao_any._tao_replace ( CORBA::_tc_StructMember, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _any_val; - } - ACE_ENDTRY; +} + +void CORBA::StructMember::_tao_any_destructor (void *x) +{ + CORBA::StructMember *tmp = ACE_static_cast(CORBA::StructMember*,x); + delete x; } void operator<<= (CORBA::Any &_tao_any, CORBA::StructMember *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -14702,16 +14354,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::StructMember *_tao_elem) // non c stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::StructMember::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::StructMember *&_tao_elem) @@ -14743,9 +14387,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::StructMember *&_t CORBA::_tc_StructMember, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::StructMember::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -14759,7 +14402,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::StructMember *&_t { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -14767,53 +14410,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::StructMember *&_t 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; + return _tao_any >>= ACE_const_cast(CORBA::StructMember *&,_tao_elem); } void operator<<= ( @@ -14821,40 +14418,25 @@ void operator<<= ( const CORBA::StructMemberSeq &_tao_elem ) // copying { - CORBA::StructMemberSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA::StructMemberSeq (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - if (stream << *_tao_any_val) + if (stream << _tao_elem) { _tao_any._tao_replace ( CORBA::_tc_StructMemberSeq, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_any_val; } - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void CORBA::StructMemberSeq::_tao_any_destructor (void *x) +{ + CORBA::StructMemberSeq *tmp = ACE_static_cast(CORBA::StructMemberSeq*,x); + delete x; } void operator<<= (CORBA::Any &_tao_any, CORBA::StructMemberSeq *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -14863,16 +14445,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::StructMemberSeq *_tao_elem) // no stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::StructMemberSeq::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::StructMemberSeq *&_tao_elem) @@ -14904,9 +14478,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::StructMemberSeq * CORBA::_tc_StructMemberSeq, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::StructMemberSeq::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -14920,7 +14493,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::StructMemberSeq * { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -14928,85 +14501,28 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::StructMemberSeq * 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; + return _tao_any >>= ACE_const_cast(CORBA::StructMemberSeq*&,_tao_elem); } void operator<<= (CORBA::Any &_tao_any, const CORBA::Initializer &_tao_elem) // copying { - CORBA::Initializer *_any_val = 0; - ACE_NEW (_any_val, CORBA::Initializer (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_any_val; + stream << _tao_elem; _tao_any._tao_replace ( CORBA::_tc_Initializer, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _any_val; - } - ACE_ENDTRY; +} + +void CORBA::Initializer::_tao_any_destructor (void *x) +{ + CORBA::Initializer *tmp = ACE_static_cast(CORBA::Initializer*,x); + delete x; } void operator<<= (CORBA::Any &_tao_any, CORBA::Initializer *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -15015,16 +14531,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::Initializer *_tao_elem) // non co stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::Initializer::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Initializer *&_tao_elem) @@ -15056,9 +14564,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Initializer *&_ta CORBA::_tc_Initializer, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::Initializer::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -15072,7 +14579,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Initializer *&_ta { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -15080,53 +14587,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Initializer *&_ta 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; + return _tao_any >>= ACE_const_cast(CORBA::Initializer*&,_tao_elem); } void operator<<= ( @@ -15134,40 +14595,26 @@ void operator<<= ( const CORBA::InitializerSeq &_tao_elem ) // copying { - CORBA::InitializerSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA::InitializerSeq (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - if (stream << *_tao_any_val) + if (stream << _tao_elem) { _tao_any._tao_replace ( CORBA::_tc_InitializerSeq, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_any_val; } - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void CORBA::InitializerSeq::_tao_any_destructor (void *x) +{ + CORBA::InitializerSeq *tmp = + ACE_static_cast(CORBA::InitializerSeq*,x); + delete x; } void operator<<= (CORBA::Any &_tao_any, CORBA::InitializerSeq *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -15176,16 +14623,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::InitializerSeq *_tao_elem) // non stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::InitializerSeq::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InitializerSeq *&_tao_elem) @@ -15217,9 +14656,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InitializerSeq *& CORBA::_tc_InitializerSeq, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::InitializerSeq::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -15233,7 +14671,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InitializerSeq *& { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -15241,85 +14679,28 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InitializerSeq *& 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; + return _tao_any >>= ACE_const_cast(CORBA::InitializerSeq*&,_tao_elem); } void operator<<= (CORBA::Any &_tao_any, const CORBA::UnionMember &_tao_elem) // copying { - CORBA::UnionMember *_any_val = 0; - ACE_NEW (_any_val, CORBA::UnionMember (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_any_val; + stream << _tao_elem; _tao_any._tao_replace ( CORBA::_tc_UnionMember, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _any_val; - } - ACE_ENDTRY; +} + +void CORBA::UnionMember::_tao_any_destructor (void *x) +{ + CORBA::UnionMember *tmp = ACE_static_cast(CORBA::UnionMember*,x); + delete x; } void operator<<= (CORBA::Any &_tao_any, CORBA::UnionMember *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -15328,16 +14709,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::UnionMember *_tao_elem) // non co stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::UnionMember::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::UnionMember *&_tao_elem) @@ -15369,9 +14742,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::UnionMember *&_ta CORBA::_tc_UnionMember, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::UnionMember::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -15385,7 +14757,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::UnionMember *&_ta { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -15393,53 +14765,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::UnionMember *&_ta 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; + return _tao_any >>= ACE_const_cast(CORBA::UnionMember*&,_tao_elem); } void operator<<= ( @@ -15447,40 +14773,25 @@ void operator<<= ( const CORBA::UnionMemberSeq &_tao_elem ) // copying { - CORBA::UnionMemberSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA::UnionMemberSeq (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - if (stream << *_tao_any_val) + if (stream << _tao_elem) { _tao_any._tao_replace ( CORBA::_tc_UnionMemberSeq, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_any_val; } - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void CORBA::UnionMemberSeq::_tao_any_destructor (void *x) +{ + CORBA::UnionMemberSeq *tmp = ACE_static_cast(CORBA::UnionMemberSeq*,x); + delete x; } void operator<<= (CORBA::Any &_tao_any, CORBA::UnionMemberSeq *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -15489,16 +14800,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::UnionMemberSeq *_tao_elem) // non stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::UnionMemberSeq::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::UnionMemberSeq *&_tao_elem) @@ -15530,9 +14833,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::UnionMemberSeq *& CORBA::_tc_UnionMemberSeq, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::UnionMemberSeq::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -15546,7 +14848,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::UnionMemberSeq *& { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -15554,53 +14856,13 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::UnionMemberSeq *& 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; + return _tao_any >>= ACE_const_cast(CORBA::UnionMemberSeq*&,_tao_elem); +} + +void CORBA::EnumMemberSeq::_tao_any_destructor (void *x) +{ + CORBA::EnumMemberSeq *tmp = ACE_static_cast(CORBA::EnumMemberSeq*,x); + delete x; } void operator<<= ( @@ -15608,40 +14870,19 @@ void operator<<= ( const CORBA::EnumMemberSeq &_tao_elem ) // copying { - CORBA::EnumMemberSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA::EnumMemberSeq (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - if (stream << *_tao_any_val) + if (stream << _tao_elem) { _tao_any._tao_replace ( CORBA::_tc_EnumMemberSeq, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_any_val; - } - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; } void operator<<= (CORBA::Any &_tao_any, CORBA::EnumMemberSeq *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -15650,16 +14891,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::EnumMemberSeq *_tao_elem) // non stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::EnumMemberSeq::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::EnumMemberSeq *&_tao_elem) @@ -15691,9 +14924,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::EnumMemberSeq *&_ CORBA::_tc_EnumMemberSeq, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::EnumMemberSeq::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -15707,7 +14939,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::EnumMemberSeq *&_ { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -15715,53 +14947,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::EnumMemberSeq *&_ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::EnumMemberSeq *&_tao_elem) { - ACE_TRY_NEW_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; + return _tao_any >>= ACE_const_cast(CORBA::EnumMemberSeq*&,_tao_elem); } CORBA::Container_ptr (*_TAO_collocation_CORBA_Container_Stub_Factory_function_pointer) ( @@ -15769,47 +14955,31 @@ CORBA::Container_ptr (*_TAO_collocation_CORBA_Container_Stub_Factory_function_po ) = 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_Container, + CORBA::_tc_Container, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void CORBA::Container::_tao_any_destructor (void *x) +{ + CORBA::Container *tmp = ACE_static_cast(CORBA::Container*,x); + CORBA::release (tmp); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Container_ptr &_tao_elem) { - CORBA::Object_ptr *tmp = 0; - ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = CORBA::Container::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (CORBA::_tc_Container, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -15822,24 +14992,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Container_ptr &_t { _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)->_tao_replace ( CORBA::_tc_Container, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + CORBA::Container::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = CORBA::Container::_nil (); return 0; } @@ -15859,34 +15022,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Container_ptr &_t void operator<<= (CORBA::Any &_tao_any, const CORBA::Container::Description &_tao_elem) // copying { - CORBA::Container::Description *_any_val = 0; - ACE_NEW (_any_val, CORBA::Container::Description (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_any_val; + stream << _tao_elem; _tao_any._tao_replace ( CORBA::Container::_tc_Description, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _any_val; - } - ACE_ENDTRY; +} + +void CORBA::Container::Description::_tao_any_destructor (void *x) +{ + CORBA::Container::Description *tmp = ACE_static_cast(CORBA::Container::Description*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, CORBA::Container::Description *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -15895,16 +15047,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::Container::Description *_tao_elem stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::Container::Description::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Container::Description *&_tao_elem) @@ -15936,9 +15080,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Container::Descri CORBA::Container::_tc_Description, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::Container::Description::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -15952,7 +15095,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Container::Descri { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -15960,53 +15103,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Container::Descri 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; + return _tao_any >>= ACE_const_cast(CORBA::Container::Description*&,_tao_elem); } void operator<<= ( @@ -16014,40 +15111,25 @@ void operator<<= ( const CORBA::Container::DescriptionSeq &_tao_elem ) // copying { - 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_OutputCDR stream; - if (stream << *_tao_any_val) + if (stream << _tao_elem) { _tao_any._tao_replace ( CORBA::Container::_tc_DescriptionSeq, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_any_val; - } - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void CORBA::Container::DescriptionSeq::_tao_any_destructor (void *x) +{ + CORBA::Container::DescriptionSeq *tmp = ACE_static_cast(CORBA::Container::DescriptionSeq*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, CORBA::Container::DescriptionSeq *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -16056,16 +15138,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::Container::DescriptionSeq *_tao_e stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::Container::DescriptionSeq::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Container::DescriptionSeq *&_tao_elem) @@ -16097,9 +15171,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Container::Descri CORBA::Container::_tc_DescriptionSeq, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::Container::DescriptionSeq::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -16113,7 +15186,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Container::Descri { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -16121,53 +15194,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Container::Descri CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::Container::DescriptionSeq *&_tao_elem) { - ACE_TRY_NEW_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; + return _tao_any >>= ACE_const_cast(CORBA::Container::DescriptionSeq*&,_tao_elem); } CORBA::IDLType_ptr (*_TAO_collocation_CORBA_IDLType_Stub_Factory_function_pointer) ( @@ -16175,47 +15202,31 @@ CORBA::IDLType_ptr (*_TAO_collocation_CORBA_IDLType_Stub_Factory_function_pointe ) = 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_IDLType, + CORBA::_tc_IDLType, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void CORBA::IDLType::_tao_any_destructor (void *x) +{ + CORBA::IDLType *tmp = ACE_static_cast(CORBA::IDLType*,x); + CORBA::release (tmp); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::IDLType_ptr &_tao_elem) { - CORBA::Object_ptr *tmp = 0; - ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = CORBA::IDLType::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (CORBA::_tc_IDLType, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -16228,24 +15239,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::IDLType_ptr &_tao { _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)->_tao_replace ( CORBA::_tc_IDLType, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + CORBA::IDLType::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = CORBA::IDLType::_nil (); return 0; } @@ -16265,29 +15269,13 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::IDLType_ptr &_tao void operator<<= (CORBA::Any &_tao_any, CORBA::PrimitiveKind _tao_elem) { - CORBA::PrimitiveKind *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA::PrimitiveKind (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_tao_any_val; + stream << _tao_elem; _tao_any._tao_replace ( CORBA::_tc_PrimitiveKind, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - // free allocated storage - delete _tao_any_val; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PrimitiveKind &_tao_elem) @@ -16322,47 +15310,31 @@ CORBA::Repository_ptr (*_TAO_collocation_CORBA_Repository_Stub_Factory_function_ ) = 0; void operator<<= (CORBA::Any &_tao_any, CORBA::Repository_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::Repository::_duplicate (_tao_elem); TAO_OutputCDR stream; - if (stream << *_tao_obj_ptr) + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_Repository, + CORBA::_tc_Repository, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void CORBA::Repository::_tao_any_destructor (void *x) +{ + CORBA::Repository *tmp = ACE_static_cast(CORBA::Repository*,x); + CORBA::release (tmp); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Repository_ptr &_tao_elem) { - CORBA::Object_ptr *tmp = 0; - ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = CORBA::Repository::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (CORBA::_tc_Repository, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -16375,24 +15347,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Repository_ptr &_ { _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)->_tao_replace ( CORBA::_tc_Repository, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + CORBA::Repository::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = CORBA::Repository::_nil (); return 0; } @@ -16415,47 +15380,31 @@ CORBA::ModuleDef_ptr (*_TAO_collocation_CORBA_ModuleDef_Stub_Factory_function_po ) = 0; void operator<<= (CORBA::Any &_tao_any, CORBA::ModuleDef_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::ModuleDef::_duplicate (_tao_elem); TAO_OutputCDR stream; - if (stream << *_tao_obj_ptr) + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_ModuleDef, + CORBA::_tc_ModuleDef, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void CORBA::ModuleDef::_tao_any_destructor (void *x) +{ + CORBA::ModuleDef *tmp = ACE_static_cast(CORBA::ModuleDef*,x); + CORBA::release (tmp); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ModuleDef_ptr &_tao_elem) { - CORBA::Object_ptr *tmp = 0; - ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = CORBA::ModuleDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (CORBA::_tc_ModuleDef, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -16468,24 +15417,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ModuleDef_ptr &_t { _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)->_tao_replace ( CORBA::_tc_ModuleDef, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + CORBA::ModuleDef::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = CORBA::ModuleDef::_nil (); return 0; } @@ -16505,34 +15447,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ModuleDef_ptr &_t void operator<<= (CORBA::Any &_tao_any, const CORBA::ModuleDescription &_tao_elem) // copying { - CORBA::ModuleDescription *_any_val = 0; - ACE_NEW (_any_val, CORBA::ModuleDescription (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_any_val; + stream << _tao_elem; _tao_any._tao_replace ( CORBA::_tc_ModuleDescription, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _any_val; - } - ACE_ENDTRY; +} + +void CORBA::ModuleDescription::_tao_any_destructor (void *x) +{ + CORBA::ModuleDescription *tmp = ACE_static_cast(CORBA::ModuleDescription*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, CORBA::ModuleDescription *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -16541,16 +15472,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::ModuleDescription *_tao_elem) // stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::ModuleDescription::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ModuleDescription *&_tao_elem) @@ -16582,9 +15505,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ModuleDescription CORBA::_tc_ModuleDescription, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::ModuleDescription::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -16598,7 +15520,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ModuleDescription { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -16606,53 +15528,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ModuleDescription CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ModuleDescription *&_tao_elem) { - ACE_TRY_NEW_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; + return _tao_any >>= ACE_const_cast(CORBA::ModuleDescription *&,_tao_elem); } CORBA::ConstantDef_ptr (*_TAO_collocation_CORBA_ConstantDef_Stub_Factory_function_pointer) ( @@ -16660,47 +15536,31 @@ CORBA::ConstantDef_ptr (*_TAO_collocation_CORBA_ConstantDef_Stub_Factory_functio ) = 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_ConstantDef, + CORBA::_tc_ConstantDef, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void CORBA::ConstantDef::_tao_any_destructor (void *x) +{ + CORBA::ConstantDef *tmp = ACE_static_cast(CORBA::ConstantDef*,x); + CORBA::release (tmp); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ConstantDef_ptr &_tao_elem) { - CORBA::Object_ptr *tmp = 0; - ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = CORBA::ConstantDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (CORBA::_tc_ConstantDef, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -16713,24 +15573,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ConstantDef_ptr & { _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)->_tao_replace ( CORBA::_tc_ConstantDef, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + CORBA::ConstantDef::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = CORBA::ConstantDef::_nil (); return 0; } @@ -16750,34 +15603,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ConstantDef_ptr & void operator<<= (CORBA::Any &_tao_any, const CORBA::ConstantDescription &_tao_elem) // copying { - CORBA::ConstantDescription *_any_val = 0; - ACE_NEW (_any_val, CORBA::ConstantDescription (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_any_val; + stream << _tao_elem; _tao_any._tao_replace ( CORBA::_tc_ConstantDescription, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _any_val; - } - ACE_ENDTRY; +} + +void CORBA::ConstantDescription::_tao_any_destructor (void *x) +{ + CORBA::ConstantDescription *tmp = ACE_static_cast(CORBA::ConstantDescription*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, CORBA::ConstantDescription *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -16786,16 +15628,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::ConstantDescription *_tao_elem) / stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::ConstantDescription::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ConstantDescription *&_tao_elem) @@ -16827,9 +15661,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ConstantDescripti CORBA::_tc_ConstantDescription, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::ConstantDescription::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -16843,7 +15676,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ConstantDescripti { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -16851,53 +15684,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ConstantDescripti CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ConstantDescription *&_tao_elem) { - ACE_TRY_NEW_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; + return _tao_any >>= ACE_const_cast(CORBA::ConstantDescription *&,_tao_elem); } CORBA::TypedefDef_ptr (*_TAO_collocation_CORBA_TypedefDef_Stub_Factory_function_pointer) ( @@ -16905,47 +15692,31 @@ CORBA::TypedefDef_ptr (*_TAO_collocation_CORBA_TypedefDef_Stub_Factory_function_ ) = 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_TypedefDef, + CORBA::_tc_TypedefDef, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void CORBA::TypedefDef::_tao_any_destructor (void *x) +{ + CORBA::TypedefDef *tmp = ACE_static_cast(CORBA::TypedefDef*,x); + CORBA::release (tmp); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::TypedefDef_ptr &_tao_elem) { - CORBA::Object_ptr *tmp = 0; - ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = CORBA::TypedefDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (CORBA::_tc_TypedefDef, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -16958,24 +15729,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::TypedefDef_ptr &_ { _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)->_tao_replace ( CORBA::_tc_TypedefDef, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + CORBA::TypedefDef::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = CORBA::TypedefDef::_nil (); return 0; } @@ -16995,34 +15759,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::TypedefDef_ptr &_ void operator<<= (CORBA::Any &_tao_any, const CORBA::TypeDescription &_tao_elem) // copying { - CORBA::TypeDescription *_any_val = 0; - ACE_NEW (_any_val, CORBA::TypeDescription (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_any_val; + stream << _tao_elem; _tao_any._tao_replace ( CORBA::_tc_TypeDescription, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _any_val; - } - ACE_ENDTRY; +} + +void CORBA::TypeDescription::_tao_any_destructor (void *x) +{ + CORBA::TypeDescription *tmp = ACE_static_cast(CORBA::TypeDescription*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, CORBA::TypeDescription *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -17031,16 +15784,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::TypeDescription *_tao_elem) // no stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::TypeDescription::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::TypeDescription *&_tao_elem) @@ -17072,9 +15817,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::TypeDescription * CORBA::_tc_TypeDescription, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::TypeDescription::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -17088,7 +15832,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::TypeDescription * { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -17096,53 +15840,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::TypeDescription * CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::TypeDescription *&_tao_elem) { - ACE_TRY_NEW_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; + return _tao_any >>= ACE_const_cast(CORBA::TypeDescription *&,_tao_elem); } CORBA::StructDef_ptr (*_TAO_collocation_CORBA_StructDef_Stub_Factory_function_pointer) ( @@ -17150,47 +15848,31 @@ CORBA::StructDef_ptr (*_TAO_collocation_CORBA_StructDef_Stub_Factory_function_po ) = 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_StructDef, + CORBA::_tc_StructDef, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void CORBA::StructDef::_tao_any_destructor (void *x) +{ + CORBA::StructDef *tmp = ACE_static_cast(CORBA::StructDef*,x); + CORBA::release (tmp); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::StructDef_ptr &_tao_elem) { - CORBA::Object_ptr *tmp = 0; - ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = CORBA::StructDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (CORBA::_tc_StructDef, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -17203,24 +15885,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::StructDef_ptr &_t { _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)->_tao_replace ( CORBA::_tc_StructDef, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + CORBA::StructDef::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = CORBA::StructDef::_nil (); return 0; } @@ -17243,47 +15918,31 @@ CORBA::UnionDef_ptr (*_TAO_collocation_CORBA_UnionDef_Stub_Factory_function_poin ) = 0; void operator<<= (CORBA::Any &_tao_any, CORBA::UnionDef_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::UnionDef::_duplicate (_tao_elem); TAO_OutputCDR stream; - if (stream << *_tao_obj_ptr) + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_UnionDef, + CORBA::_tc_UnionDef, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void CORBA::UnionDef::_tao_any_destructor (void *x) +{ + CORBA::UnionDef *tmp = ACE_static_cast(CORBA::UnionDef*,x); + CORBA::release (tmp); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::UnionDef_ptr &_tao_elem) { - CORBA::Object_ptr *tmp = 0; - ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = CORBA::UnionDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (CORBA::_tc_UnionDef, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -17296,24 +15955,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::UnionDef_ptr &_ta { _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)->_tao_replace ( CORBA::_tc_UnionDef, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + CORBA::UnionDef::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = CORBA::UnionDef::_nil (); return 0; } @@ -17336,47 +15988,31 @@ CORBA::EnumDef_ptr (*_TAO_collocation_CORBA_EnumDef_Stub_Factory_function_pointe ) = 0; void operator<<= (CORBA::Any &_tao_any, CORBA::EnumDef_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::EnumDef::_duplicate (_tao_elem); TAO_OutputCDR stream; - if (stream << *_tao_obj_ptr) + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_EnumDef, + CORBA::_tc_EnumDef, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void CORBA::EnumDef::_tao_any_destructor (void *x) +{ + CORBA::EnumDef *tmp = ACE_static_cast(CORBA::EnumDef*,x); + delete tmp; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::EnumDef_ptr &_tao_elem) { - CORBA::Object_ptr *tmp = 0; - ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = CORBA::EnumDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (CORBA::_tc_EnumDef, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -17389,24 +16025,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::EnumDef_ptr &_tao { _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)->_tao_replace ( CORBA::_tc_EnumDef, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + CORBA::EnumDef::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = CORBA::EnumDef::_nil (); return 0; } @@ -17429,47 +16058,31 @@ CORBA::AliasDef_ptr (*_TAO_collocation_CORBA_AliasDef_Stub_Factory_function_poin ) = 0; void operator<<= (CORBA::Any &_tao_any, CORBA::AliasDef_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::AliasDef::_duplicate (_tao_elem); TAO_OutputCDR stream; - if (stream << *_tao_obj_ptr) + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_AliasDef, + CORBA::_tc_AliasDef, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_obj_ptr; } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void CORBA::AliasDef::_tao_any_destructor (void *x) +{ + CORBA::AliasDef *tmp = ACE_static_cast(CORBA::AliasDef*,x); + delete tmp; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AliasDef_ptr &_tao_elem) { - CORBA::Object_ptr *tmp = 0; - ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = CORBA::AliasDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (CORBA::_tc_AliasDef, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -17482,24 +16095,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AliasDef_ptr &_ta { _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)->_tao_replace ( CORBA::_tc_AliasDef, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + CORBA::AliasDef::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = CORBA::AliasDef::_nil (); return 0; } @@ -17522,47 +16128,31 @@ CORBA::PrimitiveDef_ptr (*_TAO_collocation_CORBA_PrimitiveDef_Stub_Factory_funct ) = 0; void operator<<= (CORBA::Any &_tao_any, CORBA::PrimitiveDef_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::PrimitiveDef::_duplicate (_tao_elem); TAO_OutputCDR stream; - if (stream << *_tao_obj_ptr) + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_PrimitiveDef, + CORBA::_tc_PrimitiveDef, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_obj_ptr; } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void CORBA::PrimitiveDef::_tao_any_destructor (void *x) +{ + CORBA::PrimitiveDef *tmp = ACE_static_cast(CORBA::PrimitiveDef*,x); + delete tmp; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PrimitiveDef_ptr &_tao_elem) { - CORBA::Object_ptr *tmp = 0; - ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = CORBA::PrimitiveDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (CORBA::_tc_PrimitiveDef, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -17575,24 +16165,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PrimitiveDef_ptr { _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)->_tao_replace ( CORBA::_tc_PrimitiveDef, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + CORBA::PrimitiveDef::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = CORBA::PrimitiveDef::_nil (); return 0; } @@ -17615,47 +16198,31 @@ CORBA::StringDef_ptr (*_TAO_collocation_CORBA_StringDef_Stub_Factory_function_po ) = 0; void operator<<= (CORBA::Any &_tao_any, CORBA::StringDef_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::StringDef::_duplicate (_tao_elem); TAO_OutputCDR stream; - if (stream << *_tao_obj_ptr) + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_StringDef, + CORBA::_tc_StringDef, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_obj_ptr; } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void CORBA::StringDef::_tao_any_destructor (void *x) +{ + CORBA::StringDef *tmp = ACE_static_cast(CORBA::StringDef*,x); + delete tmp; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::StringDef_ptr &_tao_elem) { - CORBA::Object_ptr *tmp = 0; - ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = CORBA::StringDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (CORBA::_tc_StringDef, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -17668,24 +16235,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::StringDef_ptr &_t { _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)->_tao_replace ( CORBA::_tc_StringDef, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + CORBA::StringDef::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = CORBA::StringDef::_nil (); return 0; } @@ -17708,47 +16268,31 @@ CORBA::WstringDef_ptr (*_TAO_collocation_CORBA_WstringDef_Stub_Factory_function_ ) = 0; void operator<<= (CORBA::Any &_tao_any, CORBA::WstringDef_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::WstringDef::_duplicate (_tao_elem); TAO_OutputCDR stream; - if (stream << *_tao_obj_ptr) + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_WstringDef, + CORBA::_tc_WstringDef, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_obj_ptr; } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void CORBA::WstringDef::_tao_any_destructor (void *x) +{ + CORBA::WstringDef *tmp = ACE_static_cast(CORBA::WstringDef*,x); + delete tmp; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::WstringDef_ptr &_tao_elem) { - CORBA::Object_ptr *tmp = 0; - ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = CORBA::WstringDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (CORBA::_tc_WstringDef, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -17761,24 +16305,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::WstringDef_ptr &_ { _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)->_tao_replace ( CORBA::_tc_WstringDef, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + CORBA::WstringDef::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = CORBA::WstringDef::_nil (); return 0; } @@ -17801,47 +16338,31 @@ CORBA::FixedDef_ptr (*_TAO_collocation_CORBA_FixedDef_Stub_Factory_function_poin ) = 0; void operator<<= (CORBA::Any &_tao_any, CORBA::FixedDef_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::FixedDef::_duplicate (_tao_elem); TAO_OutputCDR stream; - if (stream << *_tao_obj_ptr) + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_FixedDef, + CORBA::_tc_FixedDef, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void CORBA::FixedDef::_tao_any_destructor (void *x) +{ + CORBA::FixedDef *tmp = ACE_static_cast(CORBA::FixedDef*,x); + delete tmp; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::FixedDef_ptr &_tao_elem) { - CORBA::Object_ptr *tmp = 0; - ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = CORBA::FixedDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (CORBA::_tc_FixedDef, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -17854,24 +16375,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::FixedDef_ptr &_ta { _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)->_tao_replace ( CORBA::_tc_FixedDef, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + CORBA::FixedDef::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = CORBA::FixedDef::_nil (); return 0; } @@ -17894,47 +16408,31 @@ CORBA::SequenceDef_ptr (*_TAO_collocation_CORBA_SequenceDef_Stub_Factory_functio ) = 0; void operator<<= (CORBA::Any &_tao_any, CORBA::SequenceDef_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::SequenceDef::_duplicate (_tao_elem); TAO_OutputCDR stream; - if (stream << *_tao_obj_ptr) + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_SequenceDef, + CORBA::_tc_SequenceDef, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_obj_ptr; } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void CORBA::SequenceDef::_tao_any_destructor (void *x) +{ + CORBA::SequenceDef *tmp = ACE_static_cast(CORBA::SequenceDef*,x); + delete tmp; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::SequenceDef_ptr &_tao_elem) { - CORBA::Object_ptr *tmp = 0; - ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = CORBA::SequenceDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (CORBA::_tc_SequenceDef, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -17947,24 +16445,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::SequenceDef_ptr & { _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)->_tao_replace ( CORBA::_tc_SequenceDef, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + CORBA::SequenceDef::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = CORBA::SequenceDef::_nil (); return 0; } @@ -17987,47 +16478,31 @@ CORBA::ArrayDef_ptr (*_TAO_collocation_CORBA_ArrayDef_Stub_Factory_function_poin ) = 0; void operator<<= (CORBA::Any &_tao_any, CORBA::ArrayDef_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::ArrayDef::_duplicate (_tao_elem); TAO_OutputCDR stream; - if (stream << *_tao_obj_ptr) + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_ArrayDef, + CORBA::_tc_ArrayDef, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void CORBA::ArrayDef::_tao_any_destructor (void *x) +{ + CORBA::ArrayDef *tmp = ACE_static_cast(CORBA::ArrayDef*,x); + delete tmp; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ArrayDef_ptr &_tao_elem) { - CORBA::Object_ptr *tmp = 0; - ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = CORBA::ArrayDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (CORBA::_tc_ArrayDef, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -18040,24 +16515,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ArrayDef_ptr &_ta { _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)->_tao_replace ( CORBA::_tc_ArrayDef, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + CORBA::ArrayDef::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = CORBA::ArrayDef::_nil (); return 0; } @@ -18080,47 +16548,31 @@ CORBA::ExceptionDef_ptr (*_TAO_collocation_CORBA_ExceptionDef_Stub_Factory_funct ) = 0; void operator<<= (CORBA::Any &_tao_any, CORBA::ExceptionDef_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::ExceptionDef::_duplicate (_tao_elem); TAO_OutputCDR stream; - if (stream << *_tao_obj_ptr) + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_ExceptionDef, + CORBA::_tc_ExceptionDef, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void CORBA::ExceptionDef::_tao_any_destructor (void *x) +{ + CORBA::ExceptionDef *tmp = ACE_static_cast(CORBA::ExceptionDef*,x); + delete tmp; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ExceptionDef_ptr &_tao_elem) { - CORBA::Object_ptr *tmp = 0; - ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = CORBA::ExceptionDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (CORBA::_tc_ExceptionDef, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -18133,24 +16585,18 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ExceptionDef_ptr { _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)->_tao_replace ( CORBA::_tc_ExceptionDef, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + CORBA::ExceptionDef::_tao_any_destructor ); ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = CORBA::ExceptionDef::_nil (); return 0; } @@ -18170,34 +16616,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ExceptionDef_ptr void operator<<= (CORBA::Any &_tao_any, const CORBA::ExceptionDescription &_tao_elem) // copying { - CORBA::ExceptionDescription *_any_val = 0; - ACE_NEW (_any_val, CORBA::ExceptionDescription (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_any_val; + stream << _tao_elem; _tao_any._tao_replace ( CORBA::_tc_ExceptionDescription, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _any_val; - } - ACE_ENDTRY; +} + +void CORBA::ExceptionDescription::_tao_any_destructor (void *x) +{ + CORBA::ExceptionDescription *tmp = ACE_static_cast(CORBA::ExceptionDescription*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, CORBA::ExceptionDescription *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -18206,16 +16641,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::ExceptionDescription *_tao_elem) stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::ExceptionDescription::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ExceptionDescription *&_tao_elem) @@ -18247,9 +16674,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ExceptionDescript CORBA::_tc_ExceptionDescription, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::ExceptionDescription::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -18263,7 +16689,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ExceptionDescript { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -18271,80 +16697,18 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ExceptionDescript CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ExceptionDescription *&_tao_elem) { - ACE_TRY_NEW_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; + return _tao_any >>= ACE_const_cast(CORBA::ExceptionDescription *&,_tao_elem); } 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; + stream << _tao_elem; _tao_any._tao_replace ( CORBA::_tc_AttributeMode, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - // free allocated storage - delete _tao_any_val; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AttributeMode &_tao_elem) @@ -18379,47 +16743,31 @@ CORBA::AttributeDef_ptr (*_TAO_collocation_CORBA_AttributeDef_Stub_Factory_funct ) = 0; void operator<<= (CORBA::Any &_tao_any, CORBA::AttributeDef_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::AttributeDef::_duplicate (_tao_elem); TAO_OutputCDR stream; - if (stream << *_tao_obj_ptr) + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_AttributeDef, + CORBA::_tc_AttributeDef, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_obj_ptr; } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void CORBA::AttributeDef::_tao_any_destructor (void *x) +{ + CORBA::AttributeDef *tmp = ACE_static_cast(CORBA::AttributeDef*,x); + delete tmp; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AttributeDef_ptr &_tao_elem) { - CORBA::Object_ptr *tmp = 0; - ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = CORBA::AttributeDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (CORBA::_tc_AttributeDef, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -18432,24 +16780,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AttributeDef_ptr { _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)->_tao_replace ( CORBA::_tc_AttributeDef, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + CORBA::AttributeDef::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = CORBA::AttributeDef::_nil (); return 0; } @@ -18469,34 +16810,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AttributeDef_ptr void operator<<= (CORBA::Any &_tao_any, const CORBA::AttributeDescription &_tao_elem) // copying { - CORBA::AttributeDescription *_any_val = 0; - ACE_NEW (_any_val, CORBA::AttributeDescription (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_any_val; + stream << _tao_elem; _tao_any._tao_replace ( CORBA::_tc_AttributeDescription, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _any_val; - } - ACE_ENDTRY; +} + +void CORBA::AttributeDescription::_tao_any_destructor (void *x) +{ + CORBA::AttributeDescription *tmp = ACE_static_cast(CORBA::AttributeDescription*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, CORBA::AttributeDescription *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -18505,16 +16835,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::AttributeDescription *_tao_elem) stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::AttributeDescription::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AttributeDescription *&_tao_elem) @@ -18546,9 +16868,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AttributeDescript CORBA::_tc_AttributeDescription, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::AttributeDescription::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -18562,7 +16883,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AttributeDescript { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -18570,80 +16891,18 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AttributeDescript CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::AttributeDescription *&_tao_elem) { - ACE_TRY_NEW_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; + return _tao_any >>= ACE_const_cast(CORBA::AttributeDescription *&,_tao_elem); } 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; + stream << _tao_elem; _tao_any._tao_replace ( CORBA::_tc_OperationMode, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - // free allocated storage - delete _tao_any_val; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::OperationMode &_tao_elem) @@ -18675,29 +16934,13 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::OperationMode &_t void operator<<= (CORBA::Any &_tao_any, CORBA::ParameterMode _tao_elem) { - CORBA::ParameterMode *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA::ParameterMode (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_tao_any_val; + stream << _tao_elem; _tao_any._tao_replace ( CORBA::_tc_ParameterMode, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - // free allocated storage - delete _tao_any_val; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ParameterMode &_tao_elem) @@ -18729,34 +16972,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ParameterMode &_t void operator<<= (CORBA::Any &_tao_any, const CORBA::ParameterDescription &_tao_elem) // copying { - CORBA::ParameterDescription *_any_val = 0; - ACE_NEW (_any_val, CORBA::ParameterDescription (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_any_val; + stream << _tao_elem; _tao_any._tao_replace ( CORBA::_tc_ParameterDescription, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _any_val; - } - ACE_ENDTRY; +} + +void CORBA::ParameterDescription::_tao_any_destructor (void *x) +{ + CORBA::ParameterDescription *tmp = ACE_static_cast(CORBA::ParameterDescription*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, CORBA::ParameterDescription *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -18765,16 +16997,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::ParameterDescription *_tao_elem) stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::ParameterDescription::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ParameterDescription *&_tao_elem) @@ -18806,7 +17030,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ParameterDescript CORBA::_tc_ParameterDescription, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::ParameterDescription::_tao_any_destructor ); ACE_TRY_CHECK; return 1; @@ -18822,7 +17046,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ParameterDescript { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -18830,53 +17054,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ParameterDescript 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; + return _tao_any >>= ACE_const_cast(CORBA::ParameterDescription *&,_tao_elem); } void operator<<= ( @@ -18884,40 +17062,25 @@ void operator<<= ( const CORBA::ParDescriptionSeq &_tao_elem ) // copying { - CORBA::ParDescriptionSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA::ParDescriptionSeq (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - if (stream << *_tao_any_val) + if (stream << _tao_elem) { _tao_any._tao_replace ( CORBA::_tc_ParDescriptionSeq, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_any_val; - } - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void CORBA::ParDescriptionSeq::_tao_any_destructor (void *x) +{ + CORBA::ParDescriptionSeq *tmp = ACE_static_cast(CORBA::ParDescriptionSeq*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, CORBA::ParDescriptionSeq *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -18926,16 +17089,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::ParDescriptionSeq *_tao_elem) // stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::ParDescriptionSeq::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ParDescriptionSeq *&_tao_elem) @@ -18967,9 +17122,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ParDescriptionSeq CORBA::_tc_ParDescriptionSeq, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::ParDescriptionSeq::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -18983,7 +17137,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ParDescriptionSeq { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -18991,53 +17145,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ParDescriptionSeq 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; + return _tao_any >>= ACE_const_cast(CORBA::ParDescriptionSeq *&,_tao_elem); } void operator<<= ( @@ -19045,40 +17153,25 @@ void operator<<= ( const CORBA::ContextIdSeq &_tao_elem ) // copying { - CORBA::ContextIdSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA::ContextIdSeq (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - if (stream << *_tao_any_val) + if (stream << _tao_elem) { _tao_any._tao_replace ( CORBA::_tc_ContextIdSeq, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_any_val; } - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void CORBA::ContextIdSeq::_tao_any_destructor (void *x) +{ + CORBA::ContextIdSeq *tmp = ACE_static_cast(CORBA::ContextIdSeq*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, CORBA::ContextIdSeq *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -19087,16 +17180,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::ContextIdSeq *_tao_elem) // non c stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::ContextIdSeq::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ContextIdSeq *&_tao_elem) @@ -19128,9 +17213,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ContextIdSeq *&_t CORBA::_tc_ContextIdSeq, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::ContextIdSeq::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -19144,7 +17228,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ContextIdSeq *&_t { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -19152,53 +17236,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ContextIdSeq *&_t 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; + return _tao_any >>= ACE_const_cast(CORBA::ContextIdSeq *&,_tao_elem); } void operator<<= ( @@ -19206,40 +17244,25 @@ void operator<<= ( const CORBA::ExceptionDefSeq &_tao_elem ) // copying { - CORBA::ExceptionDefSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA::ExceptionDefSeq (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - if (stream << *_tao_any_val) + if (stream << _tao_elem) { _tao_any._tao_replace ( CORBA::_tc_ExceptionDefSeq, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_any_val; } - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void CORBA::ExceptionDefSeq::_tao_any_destructor (void *x) +{ + CORBA::ExceptionDefSeq *tmp = ACE_static_cast(CORBA::ExceptionDefSeq*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, CORBA::ExceptionDefSeq *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -19248,16 +17271,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::ExceptionDefSeq *_tao_elem) // no stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::ExceptionDefSeq::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ExceptionDefSeq *&_tao_elem) @@ -19289,9 +17304,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ExceptionDefSeq * CORBA::_tc_ExceptionDefSeq, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::ExceptionDefSeq::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -19305,7 +17319,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ExceptionDefSeq * { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -19313,53 +17327,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ExceptionDefSeq * 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; + return _tao_any >>= ACE_const_cast(CORBA::ExceptionDefSeq *&,_tao_elem); } void operator<<= ( @@ -19367,40 +17335,25 @@ void operator<<= ( const CORBA::ExcDescriptionSeq &_tao_elem ) // copying { - CORBA::ExcDescriptionSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA::ExcDescriptionSeq (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - if (stream << *_tao_any_val) + if (stream << _tao_elem) { _tao_any._tao_replace ( CORBA::_tc_ExcDescriptionSeq, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_any_val; - } - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void CORBA::ExcDescriptionSeq::_tao_any_destructor (void *x) +{ + CORBA::ExcDescriptionSeq *tmp = ACE_static_cast(CORBA::ExcDescriptionSeq*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, CORBA::ExcDescriptionSeq *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -19409,16 +17362,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::ExcDescriptionSeq *_tao_elem) // stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::ExcDescriptionSeq::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ExcDescriptionSeq *&_tao_elem) @@ -19450,9 +17395,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ExcDescriptionSeq CORBA::_tc_ExcDescriptionSeq, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::ExcDescriptionSeq::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -19466,7 +17410,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ExcDescriptionSeq { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -19474,53 +17418,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ExcDescriptionSeq CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ExcDescriptionSeq *&_tao_elem) { - ACE_TRY_NEW_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; + return _tao_any >>= ACE_const_cast(CORBA::ExcDescriptionSeq *&,_tao_elem); } CORBA::OperationDef_ptr (*_TAO_collocation_CORBA_OperationDef_Stub_Factory_function_pointer) ( @@ -19528,47 +17426,31 @@ CORBA::OperationDef_ptr (*_TAO_collocation_CORBA_OperationDef_Stub_Factory_funct ) = 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_OperationDef, + CORBA::_tc_OperationDef, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_obj_ptr; } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void CORBA::OperationDef::_tao_any_destructor (void *x) +{ + CORBA::OperationDef *tmp = ACE_static_cast(CORBA::OperationDef*,x); + delete tmp; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::OperationDef_ptr &_tao_elem) { - CORBA::Object_ptr *tmp = 0; - ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = CORBA::OperationDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (CORBA::_tc_OperationDef, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -19581,24 +17463,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::OperationDef_ptr { _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)->_tao_replace ( CORBA::_tc_OperationDef, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + CORBA::OperationDef::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = CORBA::OperationDef::_nil (); return 0; } @@ -19618,34 +17493,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::OperationDef_ptr void operator<<= (CORBA::Any &_tao_any, const CORBA::OperationDescription &_tao_elem) // copying { - CORBA::OperationDescription *_any_val = 0; - ACE_NEW (_any_val, CORBA::OperationDescription (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_any_val; + stream << _tao_elem; _tao_any._tao_replace ( CORBA::_tc_OperationDescription, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _any_val; - } - ACE_ENDTRY; +} + +void CORBA::OperationDescription::_tao_any_destructor (void *x) +{ + CORBA::OperationDescription *tmp = ACE_static_cast(CORBA::OperationDescription*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, CORBA::OperationDescription *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -19654,16 +17518,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::OperationDescription *_tao_elem) stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::OperationDescription::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::OperationDescription *&_tao_elem) @@ -19695,9 +17551,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::OperationDescript CORBA::_tc_OperationDescription, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::OperationDescription::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -19711,7 +17566,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::OperationDescript { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -19719,53 +17574,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::OperationDescript 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; + return _tao_any >>= ACE_const_cast(CORBA::OperationDescription *&,_tao_elem); } void operator<<= ( @@ -19773,40 +17582,25 @@ void operator<<= ( const CORBA::RepositoryIdSeq &_tao_elem ) // copying { - CORBA::RepositoryIdSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA::RepositoryIdSeq (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - if (stream << *_tao_any_val) + if (stream << _tao_elem) { _tao_any._tao_replace ( CORBA::_tc_RepositoryIdSeq, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_any_val; } - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void CORBA::RepositoryIdSeq::_tao_any_destructor (void *x) +{ + CORBA::RepositoryIdSeq *tmp = ACE_static_cast(CORBA::RepositoryIdSeq*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, CORBA::RepositoryIdSeq *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -19815,16 +17609,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::RepositoryIdSeq *_tao_elem) // no stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::RepositoryIdSeq::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::RepositoryIdSeq *&_tao_elem) @@ -19856,9 +17642,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::RepositoryIdSeq * CORBA::_tc_RepositoryIdSeq, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::RepositoryIdSeq::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -19872,7 +17657,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::RepositoryIdSeq * { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -19880,53 +17665,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::RepositoryIdSeq * 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; + return _tao_any >>= ACE_const_cast(CORBA::RepositoryIdSeq *&,_tao_elem); } void operator<<= ( @@ -19934,40 +17673,25 @@ void operator<<= ( const CORBA::OpDescriptionSeq &_tao_elem ) // copying { - CORBA::OpDescriptionSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA::OpDescriptionSeq (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - if (stream << *_tao_any_val) + if (stream << _tao_elem) { _tao_any._tao_replace ( CORBA::_tc_OpDescriptionSeq, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_any_val; - } - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void CORBA::OpDescriptionSeq::_tao_any_destructor (void *x) +{ + CORBA::OpDescriptionSeq *tmp = ACE_static_cast(CORBA::OpDescriptionSeq*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, CORBA::OpDescriptionSeq *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -19976,16 +17700,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::OpDescriptionSeq *_tao_elem) // n stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::OpDescriptionSeq::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::OpDescriptionSeq *&_tao_elem) @@ -20017,9 +17733,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::OpDescriptionSeq CORBA::_tc_OpDescriptionSeq, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::OpDescriptionSeq::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -20033,7 +17748,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::OpDescriptionSeq { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -20041,53 +17756,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::OpDescriptionSeq 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; + return _tao_any >>= ACE_const_cast(CORBA::OpDescriptionSeq *&,_tao_elem); } void operator<<= ( @@ -20095,40 +17764,25 @@ void operator<<= ( const CORBA::AttrDescriptionSeq &_tao_elem ) // copying { - CORBA::AttrDescriptionSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA::AttrDescriptionSeq (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - if (stream << *_tao_any_val) + if (stream << _tao_elem) { _tao_any._tao_replace ( CORBA::_tc_AttrDescriptionSeq, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_any_val; } - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void CORBA::AttrDescriptionSeq::_tao_any_destructor (void *x) +{ + CORBA::AttrDescriptionSeq *tmp = ACE_static_cast(CORBA::AttrDescriptionSeq*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, CORBA::AttrDescriptionSeq *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -20137,16 +17791,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::AttrDescriptionSeq *_tao_elem) // stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::AttrDescriptionSeq::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AttrDescriptionSeq *&_tao_elem) @@ -20178,9 +17824,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AttrDescriptionSe CORBA::_tc_AttrDescriptionSeq, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::AttrDescriptionSeq::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -20194,7 +17839,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AttrDescriptionSe { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -20202,53 +17847,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AttrDescriptionSe CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::AttrDescriptionSeq *&_tao_elem) { - ACE_TRY_NEW_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; + return _tao_any >>= ACE_const_cast(CORBA::AttrDescriptionSeq *&,_tao_elem); } CORBA::InterfaceDef_ptr (*_TAO_collocation_CORBA_InterfaceDef_Stub_Factory_function_pointer) ( @@ -20256,47 +17855,31 @@ CORBA::InterfaceDef_ptr (*_TAO_collocation_CORBA_InterfaceDef_Stub_Factory_funct ) = 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_InterfaceDef, + CORBA::_tc_InterfaceDef, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void CORBA::InterfaceDef::_tao_any_destructor (void *x) +{ + CORBA::InterfaceDef *tmp = ACE_static_cast(CORBA::InterfaceDef*,x); + delete tmp; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InterfaceDef_ptr &_tao_elem) { - CORBA::Object_ptr *tmp = 0; - ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = CORBA::InterfaceDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (CORBA::_tc_InterfaceDef, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -20309,24 +17892,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InterfaceDef_ptr { _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)->_tao_replace ( CORBA::_tc_InterfaceDef, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + CORBA::InterfaceDef::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = CORBA::InterfaceDef::_nil (); return 0; } @@ -20346,34 +17922,24 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InterfaceDef_ptr void operator<<= (CORBA::Any &_tao_any, const CORBA::InterfaceDef::FullInterfaceDescription &_tao_elem) // copying { - CORBA::InterfaceDef::FullInterfaceDescription *_any_val = 0; - ACE_NEW (_any_val, CORBA::InterfaceDef::FullInterfaceDescription (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_any_val; + stream << _tao_elem; _tao_any._tao_replace ( CORBA::InterfaceDef::_tc_FullInterfaceDescription, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _any_val; - } - ACE_ENDTRY; +} + +void +CORBA::InterfaceDef::FullInterfaceDescription::_tao_any_destructor (void *x) +{ + CORBA::InterfaceDef::FullInterfaceDescription *tmp = ACE_static_cast(CORBA::InterfaceDef::FullInterfaceDescription*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, CORBA::InterfaceDef::FullInterfaceDescription *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -20382,16 +17948,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::InterfaceDef::FullInterfaceDescri stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::InterfaceDef::FullInterfaceDescription::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InterfaceDef::FullInterfaceDescription *&_tao_elem) @@ -20423,9 +17981,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InterfaceDef::Ful CORBA::InterfaceDef::_tc_FullInterfaceDescription, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::InterfaceDef::FullInterfaceDescription::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -20439,7 +17996,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InterfaceDef::Ful { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -20447,85 +18004,28 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InterfaceDef::Ful 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; + return _tao_any >>= ACE_const_cast(CORBA::InterfaceDef::FullInterfaceDescription *&,_tao_elem); } void operator<<= (CORBA::Any &_tao_any, const CORBA::InterfaceDescription &_tao_elem) // copying { - CORBA::InterfaceDescription *_any_val = 0; - ACE_NEW (_any_val, CORBA::InterfaceDescription (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_any_val; + stream << _tao_elem; _tao_any._tao_replace ( CORBA::_tc_InterfaceDescription, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _any_val; - } - ACE_ENDTRY; +} + +void CORBA::InterfaceDescription::_tao_any_destructor (void *x) +{ + CORBA::InterfaceDescription *tmp = ACE_static_cast(CORBA::InterfaceDescription*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, CORBA::InterfaceDescription *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -20534,16 +18034,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::InterfaceDescription *_tao_elem) stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::InterfaceDescription::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InterfaceDescription *&_tao_elem) @@ -20575,9 +18067,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InterfaceDescript CORBA::_tc_InterfaceDescription, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::InterfaceDescription::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -20591,7 +18082,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InterfaceDescript { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -20599,85 +18090,28 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InterfaceDescript 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; + return _tao_any >>= ACE_const_cast(CORBA::InterfaceDescription *&,_tao_elem); } void operator<<= (CORBA::Any &_tao_any, const CORBA::ValueMember &_tao_elem) // copying { - CORBA::ValueMember *_any_val = 0; - ACE_NEW (_any_val, CORBA::ValueMember (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_any_val; + stream << _tao_elem; _tao_any._tao_replace ( CORBA::_tc_ValueMember, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _any_val; - } - ACE_ENDTRY; +} + +void CORBA::ValueMember::_tao_any_destructor (void *x) +{ + CORBA::ValueMember *tmp = ACE_static_cast(CORBA::ValueMember*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, CORBA::ValueMember *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -20686,16 +18120,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::ValueMember *_tao_elem) // non co stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::ValueMember::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueMember *&_tao_elem) @@ -20727,9 +18153,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueMember *&_ta CORBA::_tc_ValueMember, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::ValueMember::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -20743,7 +18168,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueMember *&_ta { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -20751,53 +18176,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueMember *&_ta 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; + return _tao_any >>= ACE_const_cast(CORBA::ValueMember *&,_tao_elem); } void operator<<= ( @@ -20805,40 +18184,25 @@ void operator<<= ( const CORBA::ValueMemberSeq &_tao_elem ) // copying { - CORBA::ValueMemberSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA::ValueMemberSeq (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - if (stream << *_tao_any_val) + if (stream << _tao_elem) { _tao_any._tao_replace ( CORBA::_tc_ValueMemberSeq, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_any_val; } - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void CORBA::ValueMemberSeq::_tao_any_destructor (void *x) +{ + CORBA::ValueMemberSeq *tmp = ACE_static_cast(CORBA::ValueMemberSeq*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, CORBA::ValueMemberSeq *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -20847,16 +18211,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::ValueMemberSeq *_tao_elem) // non stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::ValueMemberSeq::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueMemberSeq *&_tao_elem) @@ -20888,9 +18244,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueMemberSeq *& CORBA::_tc_ValueMemberSeq, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::ValueMemberSeq::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -20904,7 +18259,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueMemberSeq *& { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -20912,53 +18267,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueMemberSeq *& CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ValueMemberSeq *&_tao_elem) { - ACE_TRY_NEW_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; + return _tao_any >>= ACE_const_cast(CORBA::ValueMemberSeq *&,_tao_elem); } CORBA::ValueMemberDef_ptr (*_TAO_collocation_CORBA_ValueMemberDef_Stub_Factory_function_pointer) ( @@ -20966,47 +18275,31 @@ CORBA::ValueMemberDef_ptr (*_TAO_collocation_CORBA_ValueMemberDef_Stub_Factory_f ) = 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_ValueMemberDef, + CORBA::_tc_ValueMemberDef, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void CORBA::ValueMemberDef::_tao_any_destructor (void *x) +{ + CORBA::ValueMemberDef *tmp = ACE_static_cast(CORBA::ValueMemberDef*,x); + delete tmp; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueMemberDef_ptr &_tao_elem) { - CORBA::Object_ptr *tmp = 0; - ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = CORBA::ValueMemberDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (CORBA::_tc_ValueMemberDef, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -21019,24 +18312,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueMemberDef_pt { _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)->_tao_replace ( CORBA::_tc_ValueMemberDef, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + CORBA::ValueMemberDef::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = CORBA::ValueMemberDef::_nil (); return 0; } @@ -21059,47 +18345,31 @@ CORBA::ValueDef_ptr (*_TAO_collocation_CORBA_ValueDef_Stub_Factory_function_poin ) = 0; void operator<<= (CORBA::Any &_tao_any, CORBA::ValueDef_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::ValueDef::_duplicate (_tao_elem); TAO_OutputCDR stream; - if (stream << *_tao_obj_ptr) + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_ValueDef, + CORBA::_tc_ValueDef, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void CORBA::ValueDef::_tao_any_destructor (void *x) +{ + CORBA::ValueDef *tmp = ACE_static_cast(CORBA::ValueDef*,x); + delete tmp; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueDef_ptr &_tao_elem) { - CORBA::Object_ptr *tmp = 0; - ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = CORBA::ValueDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (CORBA::_tc_ValueDef, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -21112,24 +18382,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueDef_ptr &_ta { _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)->_tao_replace ( CORBA::_tc_ValueDef, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + CORBA::ValueDef::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = CORBA::ValueDef::_nil (); return 0; } @@ -21149,34 +18412,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueDef_ptr &_ta void operator<<= (CORBA::Any &_tao_any, const CORBA::ValueDef::FullValueDescription &_tao_elem) // copying { - CORBA::ValueDef::FullValueDescription *_any_val = 0; - ACE_NEW (_any_val, CORBA::ValueDef::FullValueDescription (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_any_val; + stream << _tao_elem; _tao_any._tao_replace ( CORBA::ValueDef::_tc_FullValueDescription, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _any_val; - } - ACE_ENDTRY; +} + +void CORBA::ValueDef::FullValueDescription::_tao_any_destructor (void *x) +{ + CORBA::ValueDef::FullValueDescription *tmp = ACE_static_cast(CORBA::ValueDef::FullValueDescription*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, CORBA::ValueDef::FullValueDescription *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -21185,16 +18437,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::ValueDef::FullValueDescription *_ stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::ValueDef::FullValueDescription::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueDef::FullValueDescription *&_tao_elem) @@ -21226,9 +18470,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueDef::FullVal CORBA::ValueDef::_tc_FullValueDescription, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::ValueDef::FullValueDescription::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -21242,7 +18485,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueDef::FullVal { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -21250,85 +18493,28 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueDef::FullVal 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; + return _tao_any >>= ACE_const_cast(CORBA::ValueDef::FullValueDescription *&,_tao_elem); } void operator<<= (CORBA::Any &_tao_any, const CORBA::ValueDescription &_tao_elem) // copying { - CORBA::ValueDescription *_any_val = 0; - ACE_NEW (_any_val, CORBA::ValueDescription (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_any_val; + stream << _tao_elem; _tao_any._tao_replace ( CORBA::_tc_ValueDescription, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _any_val; - } - ACE_ENDTRY; +} + +void CORBA::ValueDescription::_tao_any_destructor (void *x) +{ + CORBA::ValueDescription *tmp = ACE_static_cast(CORBA::ValueDescription*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, CORBA::ValueDescription *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -21337,16 +18523,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::ValueDescription *_tao_elem) // n stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::ValueDescription::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueDescription *&_tao_elem) @@ -21378,9 +18556,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueDescription CORBA::_tc_ValueDescription, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::ValueDescription::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -21394,7 +18571,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueDescription { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -21402,53 +18579,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueDescription CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ValueDescription *&_tao_elem) { - ACE_TRY_NEW_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; + return _tao_any >>= ACE_const_cast(CORBA::ValueDescription *&,_tao_elem); } CORBA::ValueBoxDef_ptr (*_TAO_collocation_CORBA_ValueBoxDef_Stub_Factory_function_pointer) ( @@ -21456,47 +18587,31 @@ CORBA::ValueBoxDef_ptr (*_TAO_collocation_CORBA_ValueBoxDef_Stub_Factory_functio ) = 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_ValueBoxDef, + CORBA::_tc_ValueBoxDef, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void CORBA::ValueBoxDef::_tao_any_destructor (void *x) +{ + CORBA::ValueBoxDef *tmp = ACE_static_cast(CORBA::ValueBoxDef*,x); + delete tmp; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueBoxDef_ptr &_tao_elem) { - CORBA::Object_ptr *tmp = 0; - ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0); ACE_TRY_NEW_ENV { _tao_elem = CORBA::ValueBoxDef::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (CORBA::_tc_ValueBoxDef, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -21509,24 +18624,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueBoxDef_ptr & { _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)->_tao_replace ( CORBA::_tc_ValueBoxDef, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + CORBA::ValueBoxDef::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = CORBA::ValueBoxDef::_nil (); return 0; } diff --git a/TAO/tao/InterfaceC.h b/TAO/tao/InterfaceC.h index ca9ba64e5e6..5e390f09982 100644 --- a/TAO/tao/InterfaceC.h +++ b/TAO/tao/InterfaceC.h @@ -122,6 +122,7 @@ class TAO_Export CORBA_IRObject : public virtual ACE_CORBA_1 (Object) { return (CORBA::IRObject_ptr)0; } + static void _tao_any_destructor (void*); virtual CORBA::DefinitionKind def_kind ( CORBA::Environment &ACE_TRY_ENV = @@ -411,6 +412,7 @@ class TAO_Export CORBA_Contained: public virtual CORBA_IRObject { return (CORBA::Contained_ptr)0; } + static void _tao_any_destructor (void*); virtual char * id ( CORBA::Environment &ACE_TRY_ENV = @@ -489,6 +491,8 @@ class TAO_Export CORBA_Contained: public virtual CORBA_IRObject struct Description { + static void _tao_any_destructor (void*); + CORBA::DefinitionKind kind; CORBA::Any value; }; @@ -1204,6 +1208,8 @@ class TAO_Export CORBA_Contained: public virtual CORBA_IRObject ); CORBA_InterfaceDefSeq (const CORBA_InterfaceDefSeq &); // copy ctor ~CORBA_InterfaceDefSeq (void); // dtor + + static void _tao_any_destructor (void*); }; #endif /* end #if !defined */ @@ -1397,6 +1403,8 @@ class TAO_Export CORBA_Contained: public virtual CORBA_IRObject ); CORBA_ValueDefSeq (const CORBA_ValueDefSeq &); // copy ctor ~CORBA_ValueDefSeq (void); // dtor + + static void _tao_any_destructor (void *x); }; #endif /* end #if !defined */ @@ -1590,6 +1598,8 @@ class TAO_Export CORBA_Contained: public virtual CORBA_IRObject ); CORBA_ContainedSeq (const CORBA_ContainedSeq &); // copy ctor ~CORBA_ContainedSeq (void); // dtor + + static void _tao_any_destructor (void*); }; #endif /* end #if !defined */ @@ -1661,6 +1671,8 @@ class TAO_Export CORBA_Contained: public virtual CORBA_IRObject struct CORBA_StructMember { + static void _tao_any_destructor (void*); + TAO_String_Manager name; CORBA::TypeCode_var type; TAO_Object_Field_T<CORBA_IDLType,CORBA_IDLType_var> type_def; @@ -1778,6 +1790,8 @@ class TAO_Export CORBA_Contained: public virtual CORBA_IRObject ); CORBA_StructMemberSeq (const CORBA_StructMemberSeq &); // copy ctor ~CORBA_StructMemberSeq (void); // dtor + + static void _tao_any_destructor (void*); }; #endif /* end #if !defined */ @@ -1849,6 +1863,8 @@ class TAO_Export CORBA_Contained: public virtual CORBA_IRObject struct CORBA_Initializer { + static void _tao_any_destructor (void*); + CORBA_StructMemberSeq members; }; @@ -1965,6 +1981,8 @@ class TAO_Export CORBA_Contained: public virtual CORBA_IRObject ); CORBA_InitializerSeq (const CORBA_InitializerSeq &); // copy ctor ~CORBA_InitializerSeq (void); // dtor + + static void _tao_any_destructor (void*); }; #endif /* end #if !defined */ @@ -2036,6 +2054,8 @@ class TAO_Export CORBA_Contained: public virtual CORBA_IRObject struct CORBA_UnionMember { + static void _tao_any_destructor (void*); + TAO_String_Manager name; CORBA::Any label; CORBA::TypeCode_var type; @@ -2155,6 +2175,8 @@ class TAO_Export CORBA_Contained: public virtual CORBA_IRObject ); CORBA_UnionMemberSeq (const CORBA_UnionMemberSeq &); // copy ctor ~CORBA_UnionMemberSeq (void); // dtor + + static void _tao_any_destructor (void*); }; #endif /* end #if !defined */ @@ -2250,6 +2272,8 @@ class TAO_Export CORBA_Contained: public virtual CORBA_IRObject ); CORBA_EnumMemberSeq (const CORBA_EnumMemberSeq &); // copy ctor ~CORBA_EnumMemberSeq (void); // dtor + + static void _tao_any_destructor (void*); }; #endif /* end #if !defined */ @@ -2402,6 +2426,7 @@ class TAO_Export CORBA_Container: public virtual CORBA_IRObject { return (CORBA::Container_ptr)0; } + static void _tao_any_destructor (void*); virtual CORBA_Contained_ptr lookup ( const char * search_name, @@ -2436,6 +2461,8 @@ class TAO_Export CORBA_Container: public virtual CORBA_IRObject struct Description { + static void _tao_any_destructor (void*); + TAO_Object_Field_T<CORBA_Contained,CORBA_Contained_var> contained_object; CORBA::DefinitionKind kind; CORBA::Any value; @@ -2556,6 +2583,8 @@ class TAO_Export CORBA_Container: public virtual CORBA_IRObject ); DescriptionSeq (const DescriptionSeq &); // copy ctor ~DescriptionSeq (void); // dtor + + static void _tao_any_destructor (void*); }; typedef DescriptionSeq *DescriptionSeq_ptr; @@ -2872,6 +2901,7 @@ class TAO_Export CORBA_IDLType: public virtual CORBA_IRObject { return (CORBA::IDLType_ptr)0; } + static void _tao_any_destructor (void*); virtual CORBA::TypeCode_ptr type ( CORBA::Environment &ACE_TRY_ENV = @@ -3317,6 +3347,7 @@ class TAO_Export CORBA_Repository: public virtual CORBA_Container { return (CORBA::Repository_ptr)0; } + static void _tao_any_destructor (void*); virtual CORBA_Contained_ptr lookup_id ( const char * search_id, @@ -3489,6 +3520,7 @@ class TAO_Export CORBA_ModuleDef: public virtual CORBA_Container, public virtual { return (CORBA::ModuleDef_ptr)0; } + static void _tao_any_destructor (void*); virtual CORBA::Boolean _is_a ( const CORBA::Char *type_id, @@ -3514,6 +3546,8 @@ class TAO_Export CORBA_ModuleDef: public virtual CORBA_Container, public virtual struct CORBA_ModuleDescription { + static void _tao_any_destructor (void*); + TAO_String_Manager name; TAO_String_Manager id; TAO_String_Manager defined_in; @@ -3650,6 +3684,7 @@ class TAO_Export CORBA_ConstantDef: public virtual CORBA_Contained { return (CORBA::ConstantDef_ptr)0; } + static void _tao_any_destructor (void*); virtual CORBA::TypeCode_ptr type ( CORBA::Environment &ACE_TRY_ENV = @@ -3717,6 +3752,8 @@ class TAO_Export CORBA_ConstantDef: public virtual CORBA_Contained struct CORBA_ConstantDescription { + static void _tao_any_destructor (void*); + TAO_String_Manager name; TAO_String_Manager id; TAO_String_Manager defined_in; @@ -3853,6 +3890,7 @@ class TAO_Export CORBA_TypedefDef: public virtual CORBA_Contained, public virtua { return (CORBA::TypedefDef_ptr)0; } + static void _tao_any_destructor (void*); virtual CORBA::Boolean _is_a ( const CORBA::Char *type_id, @@ -3878,6 +3916,8 @@ class TAO_Export CORBA_TypedefDef: public virtual CORBA_Contained, public virtua struct CORBA_TypeDescription { + static void _tao_any_destructor (void*); + TAO_String_Manager name; TAO_String_Manager id; TAO_String_Manager defined_in; @@ -4013,6 +4053,7 @@ class TAO_Export CORBA_StructDef: public virtual CORBA_TypedefDef, public virtua { return (CORBA::StructDef_ptr)0; } + static void _tao_any_destructor (void*); virtual CORBA_StructMemberSeq * members ( CORBA::Environment &ACE_TRY_ENV = @@ -4137,6 +4178,7 @@ class TAO_Export CORBA_UnionDef: public virtual CORBA_TypedefDef, public virtual { return (CORBA::UnionDef_ptr)0; } + static void _tao_any_destructor (void*); virtual CORBA::TypeCode_ptr discriminator_type ( CORBA::Environment &ACE_TRY_ENV = @@ -4285,6 +4327,7 @@ class TAO_Export CORBA_EnumDef: public virtual CORBA_TypedefDef { return (CORBA::EnumDef_ptr)0; } + static void _tao_any_destructor (void*); virtual CORBA_EnumMemberSeq * members ( CORBA::Environment &ACE_TRY_ENV = @@ -4408,6 +4451,7 @@ class TAO_Export CORBA_AliasDef: public virtual CORBA_TypedefDef { return (CORBA::AliasDef_ptr)0; } + static void _tao_any_destructor (void*); virtual CORBA_IDLType_ptr original_type_def ( CORBA::Environment &ACE_TRY_ENV = @@ -4531,6 +4575,7 @@ class TAO_Export CORBA_PrimitiveDef: public virtual CORBA_IDLType { return (CORBA::PrimitiveDef_ptr)0; } + static void _tao_any_destructor (void*); virtual CORBA::PrimitiveKind kind ( CORBA::Environment &ACE_TRY_ENV = @@ -4646,6 +4691,7 @@ class TAO_Export CORBA_StringDef: public virtual CORBA_IDLType { return (CORBA::StringDef_ptr)0; } + static void _tao_any_destructor (void*); virtual CORBA::ULong bound ( CORBA::Environment &ACE_TRY_ENV = @@ -4769,6 +4815,7 @@ class TAO_Export CORBA_WstringDef: public virtual CORBA_IDLType { return (CORBA::WstringDef_ptr)0; } + static void _tao_any_destructor (void*); virtual CORBA::ULong bound ( CORBA::Environment &ACE_TRY_ENV = @@ -4893,6 +4940,7 @@ class TAO_Export CORBA_FixedDef: public virtual CORBA_IDLType { return (CORBA::FixedDef_ptr)0; } + static void _tao_any_destructor (void*); virtual CORBA::UShort digits ( CORBA::Environment &ACE_TRY_ENV = @@ -5033,6 +5081,7 @@ class TAO_Export CORBA_SequenceDef: public virtual CORBA_IDLType { return (CORBA::SequenceDef_ptr)0; } + static void _tao_any_destructor (void*); virtual CORBA::ULong bound ( CORBA::Environment &ACE_TRY_ENV = @@ -5182,6 +5231,7 @@ class TAO_Export CORBA_ArrayDef: public virtual CORBA_IDLType { return (CORBA::ArrayDef_ptr)0; } + static void _tao_any_destructor (void*); virtual CORBA::ULong length ( CORBA::Environment &ACE_TRY_ENV = @@ -5330,6 +5380,7 @@ class TAO_Export CORBA_ExceptionDef: public virtual CORBA_Contained, public virt { return (CORBA::ExceptionDef_ptr)0; } + static void _tao_any_destructor (void*); virtual CORBA::TypeCode_ptr type ( CORBA::Environment &ACE_TRY_ENV = @@ -5380,6 +5431,8 @@ class TAO_Export CORBA_ExceptionDef: public virtual CORBA_Contained, public virt struct CORBA_ExceptionDescription { + static void _tao_any_destructor (void*); + TAO_String_Manager name; TAO_String_Manager id; TAO_String_Manager defined_in; @@ -5516,6 +5569,7 @@ class TAO_Export CORBA_AttributeDef: public virtual CORBA_Contained { return (CORBA::AttributeDef_ptr)0; } + static void _tao_any_destructor (void*); virtual CORBA::TypeCode_ptr type ( CORBA::Environment &ACE_TRY_ENV = @@ -5583,6 +5637,8 @@ class TAO_Export CORBA_AttributeDef: public virtual CORBA_Contained struct CORBA_AttributeDescription { + static void _tao_any_destructor (void*); + TAO_String_Manager name; TAO_String_Manager id; TAO_String_Manager defined_in; @@ -5638,6 +5694,8 @@ class TAO_Export CORBA_AttributeDef: public virtual CORBA_Contained struct CORBA_ParameterDescription { + static void _tao_any_destructor (void*); + TAO_String_Manager name; CORBA::TypeCode_var type; TAO_Object_Field_T<CORBA_IDLType,CORBA_IDLType_var> type_def; @@ -5757,6 +5815,8 @@ class TAO_Export CORBA_AttributeDef: public virtual CORBA_Contained ); CORBA_ParDescriptionSeq (const CORBA_ParDescriptionSeq &); // copy ctor ~CORBA_ParDescriptionSeq (void); // dtor + + static void _tao_any_destructor (void*); }; #endif /* end #if !defined */ @@ -5851,6 +5911,8 @@ class TAO_Export CORBA_AttributeDef: public virtual CORBA_Contained ); CORBA_ContextIdSeq (const CORBA_ContextIdSeq &); // copy ctor ~CORBA_ContextIdSeq (void); // dtor + + static void _tao_any_destructor (void*); }; #endif /* end #if !defined */ @@ -5989,6 +6051,8 @@ class TAO_Export CORBA_AttributeDef: public virtual CORBA_Contained ); CORBA_ExceptionDefSeq (const CORBA_ExceptionDefSeq &); // copy ctor ~CORBA_ExceptionDefSeq (void); // dtor + + static void _tao_any_destructor (void*); }; #endif /* end #if !defined */ @@ -6126,6 +6190,8 @@ class TAO_Export CORBA_AttributeDef: public virtual CORBA_Contained ); CORBA_ExcDescriptionSeq (const CORBA_ExcDescriptionSeq &); // copy ctor ~CORBA_ExcDescriptionSeq (void); // dtor + + static void _tao_any_destructor (void*); }; #endif /* end #if !defined */ @@ -6278,6 +6344,7 @@ class TAO_Export CORBA_OperationDef: public virtual CORBA_Contained { return (CORBA::OperationDef_ptr)0; } + static void _tao_any_destructor (void*); virtual CORBA::TypeCode_ptr result ( CORBA::Environment &ACE_TRY_ENV = @@ -6396,6 +6463,8 @@ class TAO_Export CORBA_OperationDef: public virtual CORBA_Contained struct CORBA_OperationDescription { + static void _tao_any_destructor (void*); + TAO_String_Manager name; TAO_String_Manager id; TAO_String_Manager defined_in; @@ -6478,6 +6547,8 @@ class TAO_Export CORBA_OperationDef: public virtual CORBA_Contained ); CORBA_RepositoryIdSeq (const CORBA_RepositoryIdSeq &); // copy ctor ~CORBA_RepositoryIdSeq (void); // dtor + + static void _tao_any_destructor (void*); }; #endif /* end #if !defined */ @@ -6615,6 +6686,8 @@ class TAO_Export CORBA_OperationDef: public virtual CORBA_Contained ); CORBA_OpDescriptionSeq (const CORBA_OpDescriptionSeq &); // copy ctor ~CORBA_OpDescriptionSeq (void); // dtor + + static void _tao_any_destructor (void*); }; #endif /* end #if !defined */ @@ -6752,6 +6825,8 @@ class TAO_Export CORBA_OperationDef: public virtual CORBA_Contained ); CORBA_AttrDescriptionSeq (const CORBA_AttrDescriptionSeq &); // copy ctor ~CORBA_AttrDescriptionSeq (void); // dtor + + static void _tao_any_destructor (void*); }; #endif /* end #if !defined */ @@ -6905,6 +6980,7 @@ class TAO_Export CORBA_InterfaceDef: public virtual CORBA_Container, public virt { return (CORBA::InterfaceDef_ptr)0; } + static void _tao_any_destructor (void*); virtual CORBA_InterfaceDefSeq * base_interfaces ( CORBA::Environment &ACE_TRY_ENV = @@ -6934,6 +7010,8 @@ class TAO_Export CORBA_InterfaceDef: public virtual CORBA_Container, public virt struct FullInterfaceDescription { + static void _tao_any_destructor (void*); + TAO_String_Manager name; TAO_String_Manager id; TAO_String_Manager defined_in; @@ -7053,6 +7131,8 @@ class TAO_Export CORBA_InterfaceDef: public virtual CORBA_Container, public virt struct CORBA_InterfaceDescription { + static void _tao_any_destructor (void*); + TAO_String_Manager name; TAO_String_Manager id; TAO_String_Manager defined_in; @@ -7108,6 +7188,8 @@ class TAO_Export CORBA_InterfaceDef: public virtual CORBA_Container, public virt struct CORBA_ValueMember { + static void _tao_any_destructor (void*); + TAO_String_Manager name; TAO_String_Manager id; TAO_String_Manager defined_in; @@ -7231,6 +7313,8 @@ class TAO_Export CORBA_InterfaceDef: public virtual CORBA_Container, public virt ); CORBA_ValueMemberSeq (const CORBA_ValueMemberSeq &); // copy ctor ~CORBA_ValueMemberSeq (void); // dtor + + static void _tao_any_destructor (void*); }; #endif /* end #if !defined */ @@ -7383,6 +7467,7 @@ class TAO_Export CORBA_ValueMemberDef: public virtual CORBA_Contained { return (CORBA::ValueMemberDef_ptr)0; } + static void _tao_any_destructor (void*); virtual CORBA::TypeCode_ptr type ( CORBA::Environment &ACE_TRY_ENV = @@ -7532,6 +7617,7 @@ class TAO_Export CORBA_ValueDef: public virtual CORBA_Container, public virtual { return (CORBA::ValueDef_ptr)0; } + static void _tao_any_destructor (void*); virtual CORBA_InterfaceDef_ptr supported_interface ( CORBA::Environment &ACE_TRY_ENV = @@ -7663,6 +7749,8 @@ class TAO_Export CORBA_ValueDef: public virtual CORBA_Container, public virtual struct FullValueDescription { + static void _tao_any_destructor (void*); + TAO_String_Manager name; TAO_String_Manager id; CORBA::Boolean is_abstract; @@ -7801,6 +7889,8 @@ class TAO_Export CORBA_ValueDef: public virtual CORBA_Container, public virtual struct CORBA_ValueDescription { + static void _tao_any_destructor (void*); + TAO_String_Manager name; TAO_String_Manager id; CORBA::Boolean is_abstract; @@ -7942,6 +8032,7 @@ class TAO_Export CORBA_ValueBoxDef: public virtual CORBA_IDLType { return (CORBA::ValueBoxDef_ptr)0; } + static void _tao_any_destructor (void*); virtual CORBA_IDLType_ptr original_type_def ( CORBA::Environment &ACE_TRY_ENV = @@ -7994,472 +8085,472 @@ 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 &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::Contained_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::Contained *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::Contained::Description &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::Contained::Description*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::Contained::Description *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::Contained::Description *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::InterfaceDefSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::InterfaceDefSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::InterfaceDefSeq *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::InterfaceDefSeq *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::ValueDefSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::ValueDefSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ValueDefSeq *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::ValueDefSeq *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::ContainedSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::ContainedSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ContainedSeq *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::ContainedSeq *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::StructMember &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::StructMember*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::StructMember *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::StructMember *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::StructMemberSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::StructMemberSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::StructMemberSeq *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::StructMemberSeq *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::Initializer &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::Initializer*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::Initializer *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::Initializer *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::InitializerSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::InitializerSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::InitializerSeq *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::InitializerSeq *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::UnionMember &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::UnionMember*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::UnionMember *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::UnionMember *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::UnionMemberSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::UnionMemberSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::UnionMemberSeq *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::UnionMemberSeq *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::EnumMemberSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::EnumMemberSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::EnumMemberSeq *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +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 &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::Container_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::Container *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::Container::Description &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::Container::Description*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::Container::Description *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::Container::Description *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::Container::DescriptionSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::Container::DescriptionSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::Container::DescriptionSeq *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +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 &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::IDLType_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::IDLType *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::PrimitiveKind); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +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 &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::Repository_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +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 &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::ModuleDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ModuleDef *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::ModuleDescription &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::ModuleDescription*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ModuleDescription *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +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 &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::ConstantDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ConstantDef *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::ConstantDescription &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::ConstantDescription*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ConstantDescription *&); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +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 &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::TypedefDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::TypedefDef *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::TypeDescription &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::TypeDescription*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::TypeDescription *&); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +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 &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::StructDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +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 &, +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 &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::EnumDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +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 &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::AliasDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +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 &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::PrimitiveDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +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 &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::StringDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +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 &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::WstringDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +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 &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::FixedDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +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 &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::SequenceDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +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 &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::ArrayDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +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 &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::ExceptionDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ExceptionDef *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::ExceptionDescription &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::ExceptionDescription*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ExceptionDescription *&); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::ExceptionDescription *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::AttributeMode); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +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 &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::AttributeDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::AttributeDef *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::AttributeDescription &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::AttributeDescription*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::AttributeDescription *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::AttributeDescription *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::OperationMode); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::OperationMode &); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::ParameterMode); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ParameterMode &); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::ParameterDescription &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::ParameterDescription*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ParameterDescription *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::ParameterDescription *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::ParDescriptionSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::ParDescriptionSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ParDescriptionSeq *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::ParDescriptionSeq *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::ContextIdSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::ContextIdSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ContextIdSeq *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::ContextIdSeq *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::ExceptionDefSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::ExceptionDefSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ExceptionDefSeq *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::ExceptionDefSeq *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::ExcDescriptionSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::ExcDescriptionSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ExcDescriptionSeq *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +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 &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::OperationDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::OperationDef *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::OperationDescription &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::OperationDescription*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::OperationDescription *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::OperationDescription *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::RepositoryIdSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::RepositoryIdSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::RepositoryIdSeq *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::RepositoryIdSeq *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::OpDescriptionSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::OpDescriptionSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::OpDescriptionSeq *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::OpDescriptionSeq *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::AttrDescriptionSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::AttrDescriptionSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::AttrDescriptionSeq *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +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 &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::InterfaceDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::InterfaceDef *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::InterfaceDef::FullInterfaceDescription &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::InterfaceDef::FullInterfaceDescription*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::InterfaceDef::FullInterfaceDescription *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::InterfaceDef::FullInterfaceDescription *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::InterfaceDescription &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::InterfaceDescription*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::InterfaceDescription *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::InterfaceDescription *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::ValueMember &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::ValueMember*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ValueMember *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::ValueMember *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::ValueMemberSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::ValueMemberSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ValueMemberSeq *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +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 &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::ValueMemberDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +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 &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::ValueDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ValueDef *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::ValueDef::FullValueDescription &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::ValueDef::FullValueDescription*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ValueDef::FullValueDescription *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::ValueDef::FullValueDescription *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA::ValueDescription &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::ValueDescription*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ValueDescription *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +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 &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::ValueBoxDef_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +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 259362bf309..3cee91ee6ff 100644 --- a/TAO/tao/Invocation.cpp +++ b/TAO/tao/Invocation.cpp @@ -297,7 +297,7 @@ TAO_GIOP_Invocation::start (CORBA::Environment &ACE_TRY_ENV) // Obtain unique request id from the RMS. this->op_details_.request_id ( - this->transport_->tms ()->request_id ()); + this->transport_->tms ()->request_id ()); } @@ -310,7 +310,7 @@ TAO_GIOP_Invocation::prepare_header (CORBA::Octet response_flags, // // The target specification mode this->target_spec_.target_specifier (this->profile_->object_key ()); - + // Update the response flags this->op_details_.response_flags (response_flags); @@ -429,8 +429,7 @@ TAO_GIOP_Invocation::close_connection (void) } // Handle the GIOP Reply with status = LOCATION_FORWARD -// Replace the IIOP Profile. The call is then automatically -// reinvoked by the TAO_Stub::do_static_call method. +// Replace the IIOP Profile. int TAO_GIOP_Invocation::location_forward (TAO_InputCDR &inp_stream, @@ -926,7 +925,7 @@ TAO_GIOP_Oneway_Invocation::start (CORBA::Environment &ACE_TRY_ENV) // Make sure that you have the right object key this->target_spec_.target_specifier (this->profile_->object_key ()); - + this->transport_->start_request (this->orb_core_, this->target_spec_, this->out_stream_, @@ -1131,7 +1130,7 @@ TAO_GIOP_Locate_Request_Invocation::start (CORBA::Environment &ACE_TRY_ENV) // Just make sure that you pass in the object key this->target_spec_.target_specifier (this->profile_->object_key ()); - + this->transport_->start_locate (this->orb_core_, this->target_spec_, this->op_details_, diff --git a/TAO/tao/Invocation.h b/TAO/tao/Invocation.h index fe3f498cac4..2772308c67d 100644 --- a/TAO/tao/Invocation.h +++ b/TAO/tao/Invocation.h @@ -156,7 +156,7 @@ protected: TAO_Operation_Details op_details_; // The relevant operation detail - + TAO_Target_Specification target_spec_; TAO_OutputCDR out_stream_; @@ -217,7 +217,7 @@ public: CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) ACE_THROW_SPEC ((CORBA::Exception)); - // Special purpose invoke method used by the interpretive stubs. This + // Special purpose invoke method used by the generated stubs. This // accomplishes the same task as the normal invoke except that // Exceptions are allocated and decoded here. This reduces the // footprint of the generated stubs. diff --git a/TAO/tao/Makefile b/TAO/tao/Makefile index 40f29db471b..81fd84b223a 100644 --- a/TAO/tao/Makefile +++ b/TAO/tao/Makefile @@ -118,9 +118,6 @@ DEFAULT_RESOURCES_FILES = \ INTERPRETIVE_MARSHALING_FILES = \ append \ - decode \ - deep_free \ - encode \ CDR_Interpreter \ Marshal \ skip @@ -190,6 +187,7 @@ ORB_CORE_FILES = \ CONV_FRAMES \ Tagged_Components \ GIOPC \ + BoundsC \ TAOC \ TAOS @@ -411,6 +409,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -575,7 +574,42 @@ realclean: $(TAO_ROOT)/tao/POAManager.h \ $(TAO_ROOT)/tao/POAManager.i \ $(TAO_ROOT)/tao/ImplRepoC.h \ - $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/corba.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/IORC.i \ + $(TAO_ROOT)/tao/IORS.i \ + $(TAO_ROOT)/tao/Interceptor.h \ + $(TAO_ROOT)/tao/InterceptorS.h \ + $(TAO_ROOT)/tao/InterceptorC.h \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/InterceptorC.i \ + $(TAO_ROOT)/tao/Interceptor.i \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/Request.h \ + $(TAO_ROOT)/tao/Context.h \ + $(TAO_ROOT)/tao/Context.i \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/TimeBaseC.i \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/MessagingC.i \ + $(TAO_ROOT)/tao/Request.i \ + $(TAO_ROOT)/tao/Server_Request.h \ + $(TAO_ROOT)/tao/Server_Request.i \ + $(TAO_ROOT)/tao/Marshal.h \ + $(TAO_ROOT)/tao/Marshal.i \ + $(TAO_ROOT)/tao/singletons.h \ $(TAO_ROOT)/tao/Stub.h \ $(TAO_ROOT)/tao/Pluggable.h \ $(ACE_ROOT)/ace/Message_Queue.h \ @@ -599,8 +633,6 @@ realclean: $(ACE_ROOT)/ace/WFMO_Reactor.i \ $(ACE_ROOT)/ace/Strategies.i \ $(ACE_ROOT)/ace/Message_Queue.i \ - $(TAO_ROOT)/tao/IOPC.h \ - $(TAO_ROOT)/tao/IOPC.i \ $(TAO_ROOT)/tao/Pluggable.i \ $(TAO_ROOT)/tao/MProfile.h \ $(TAO_ROOT)/tao/Profile.h \ @@ -610,47 +642,22 @@ realclean: $(TAO_ROOT)/tao/Tagged_Components.i \ $(TAO_ROOT)/tao/Profile.i \ $(TAO_ROOT)/tao/MProfile.i \ - $(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/IORC.i \ - $(TAO_ROOT)/tao/IORS.i \ - $(TAO_ROOT)/tao/Interceptor.h \ - $(TAO_ROOT)/tao/InterceptorS.h \ - $(TAO_ROOT)/tao/InterceptorC.h \ - $(TAO_ROOT)/tao/InterceptorC.i \ - $(TAO_ROOT)/tao/Interceptor.i \ - $(TAO_ROOT)/tao/ORB.i \ $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ $(TAO_ROOT)/tao/ORB_Core.h \ $(TAO_ROOT)/tao/Policy_Manager.h \ $(TAO_ROOT)/tao/Policy_Manager.i \ $(TAO_ROOT)/tao/Resource_Factory.h \ $(TAO_ROOT)/tao/Protocol_Factory.h \ - $(TAO_ROOT)/tao/params.h \ - $(TAO_ROOT)/tao/params.i \ $(TAO_ROOT)/tao/ORB_Core.i \ $(ACE_ROOT)/ace/Dynamic_Service.h \ $(ACE_ROOT)/ace/Dynamic_Service.cpp \ - $(TAO_ROOT)/tao/Server_Request.h \ - $(TAO_ROOT)/tao/Server_Request.i \ - $(TAO_ROOT)/tao/NVList.h \ - $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Client_Strategy_Factory.h \ $(TAO_ROOT)/tao/Invocation.h \ $(TAO_ROOT)/tao/Reply_Dispatcher.h \ - $(TAO_ROOT)/tao/Request.h \ - $(TAO_ROOT)/tao/Context.h \ - $(TAO_ROOT)/tao/Context.i \ - $(TAO_ROOT)/tao/MessagingC.h \ - $(TAO_ROOT)/tao/TimeBaseC.h \ - $(TAO_ROOT)/tao/TimeBaseC.i \ - $(TAO_ROOT)/tao/PollableC.h \ - $(TAO_ROOT)/tao/MessagingC.i \ - $(TAO_ROOT)/tao/Request.i \ $(TAO_ROOT)/tao/GIOP_Message_State.h \ $(TAO_ROOT)/tao/Pluggable_Messaging.h \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ @@ -665,6 +672,19 @@ realclean: $(TAO_ROOT)/tao/target_specification.h \ $(TAO_ROOT)/tao/target_specification.i \ $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/InconsistentTypeCodeC.h \ + $(TAO_ROOT)/tao/DynAny_i.h \ + $(TAO_ROOT)/tao/Union.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/InterfaceC.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ $(TAO_ROOT)/tao/ImplRepoC.i \ $(TAO_ROOT)/tao/POA.i \ $(ACE_ROOT)/ace/Auto_Ptr.h \ @@ -682,6 +702,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -825,11 +846,13 @@ realclean: $(TAO_ROOT)/tao/POAC.i \ $(TAO_ROOT)/tao/Key_Adapters.i -.obj/POA.o .obj/POA.so .shobj/POA.o .shobj/POA.so: POA.cpp $(ACE_ROOT)/ace/Auto_Ptr.h \ +.obj/POA.o .obj/POA.so .shobj/POA.o .shobj/POA.so: POA.cpp \ + $(ACE_ROOT)/ace/Auto_Ptr.h \ $(ACE_ROOT)/ace/pre.h \ $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -1001,7 +1024,42 @@ realclean: $(TAO_ROOT)/tao/POAManager.h \ $(TAO_ROOT)/tao/POAManager.i \ $(TAO_ROOT)/tao/ImplRepoC.h \ - $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/corba.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/IORC.i \ + $(TAO_ROOT)/tao/IORS.i \ + $(TAO_ROOT)/tao/Interceptor.h \ + $(TAO_ROOT)/tao/InterceptorS.h \ + $(TAO_ROOT)/tao/InterceptorC.h \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/InterceptorC.i \ + $(TAO_ROOT)/tao/Interceptor.i \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/Request.h \ + $(TAO_ROOT)/tao/Context.h \ + $(TAO_ROOT)/tao/Context.i \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/TimeBaseC.i \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/MessagingC.i \ + $(TAO_ROOT)/tao/Request.i \ + $(TAO_ROOT)/tao/Server_Request.h \ + $(TAO_ROOT)/tao/Server_Request.i \ + $(TAO_ROOT)/tao/Marshal.h \ + $(TAO_ROOT)/tao/Marshal.i \ + $(TAO_ROOT)/tao/singletons.h \ $(TAO_ROOT)/tao/Stub.h \ $(TAO_ROOT)/tao/Pluggable.h \ $(ACE_ROOT)/ace/Message_Queue.h \ @@ -1025,8 +1083,6 @@ realclean: $(ACE_ROOT)/ace/WFMO_Reactor.i \ $(ACE_ROOT)/ace/Strategies.i \ $(ACE_ROOT)/ace/Message_Queue.i \ - $(TAO_ROOT)/tao/IOPC.h \ - $(TAO_ROOT)/tao/IOPC.i \ $(TAO_ROOT)/tao/Pluggable.i \ $(TAO_ROOT)/tao/MProfile.h \ $(TAO_ROOT)/tao/Profile.h \ @@ -1036,47 +1092,22 @@ realclean: $(TAO_ROOT)/tao/Tagged_Components.i \ $(TAO_ROOT)/tao/Profile.i \ $(TAO_ROOT)/tao/MProfile.i \ - $(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/IORC.i \ - $(TAO_ROOT)/tao/IORS.i \ - $(TAO_ROOT)/tao/Interceptor.h \ - $(TAO_ROOT)/tao/InterceptorS.h \ - $(TAO_ROOT)/tao/InterceptorC.h \ - $(TAO_ROOT)/tao/InterceptorC.i \ - $(TAO_ROOT)/tao/Interceptor.i \ - $(TAO_ROOT)/tao/ORB.i \ $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ $(TAO_ROOT)/tao/ORB_Core.h \ $(TAO_ROOT)/tao/Policy_Manager.h \ $(TAO_ROOT)/tao/Policy_Manager.i \ $(TAO_ROOT)/tao/Resource_Factory.h \ $(TAO_ROOT)/tao/Protocol_Factory.h \ - $(TAO_ROOT)/tao/params.h \ - $(TAO_ROOT)/tao/params.i \ $(TAO_ROOT)/tao/ORB_Core.i \ $(ACE_ROOT)/ace/Dynamic_Service.h \ $(ACE_ROOT)/ace/Dynamic_Service.cpp \ - $(TAO_ROOT)/tao/Server_Request.h \ - $(TAO_ROOT)/tao/Server_Request.i \ - $(TAO_ROOT)/tao/NVList.h \ - $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Client_Strategy_Factory.h \ $(TAO_ROOT)/tao/Invocation.h \ $(TAO_ROOT)/tao/Reply_Dispatcher.h \ - $(TAO_ROOT)/tao/Request.h \ - $(TAO_ROOT)/tao/Context.h \ - $(TAO_ROOT)/tao/Context.i \ - $(TAO_ROOT)/tao/MessagingC.h \ - $(TAO_ROOT)/tao/TimeBaseC.h \ - $(TAO_ROOT)/tao/TimeBaseC.i \ - $(TAO_ROOT)/tao/PollableC.h \ - $(TAO_ROOT)/tao/MessagingC.i \ - $(TAO_ROOT)/tao/Request.i \ $(TAO_ROOT)/tao/GIOP_Message_State.h \ $(TAO_ROOT)/tao/Pluggable_Messaging.h \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ @@ -1091,9 +1122,21 @@ realclean: $(TAO_ROOT)/tao/target_specification.h \ $(TAO_ROOT)/tao/target_specification.i \ $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/InconsistentTypeCodeC.h \ + $(TAO_ROOT)/tao/DynAny_i.h \ + $(TAO_ROOT)/tao/Union.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/InterfaceC.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ $(TAO_ROOT)/tao/ImplRepoC.i \ $(TAO_ROOT)/tao/POA.i \ - $(TAO_ROOT)/tao/debug.h \ $(TAO_ROOT)/tao/ImplRepoS.h \ $(TAO_ROOT)/tao/ImplRepoS_T.h \ $(TAO_ROOT)/tao/ImplRepoS_T.i \ @@ -1103,7 +1146,8 @@ realclean: $(TAO_ROOT)/tao/Acceptor_Registry.i \ $(TAO_ROOT)/tao/Forwarding_Servant.h -.obj/POAC.o .obj/POAC.so .shobj/POAC.o .shobj/POAC.so: POAC.cpp $(TAO_ROOT)/tao/POAC.h \ +.obj/POAC.o .obj/POAC.so .shobj/POAC.o .shobj/POAC.so: POAC.cpp \ + $(TAO_ROOT)/tao/POAC.h \ $(ACE_ROOT)/ace/pre.h \ $(TAO_ROOT)/tao/PolicyC.h \ $(TAO_ROOT)/tao/CurrentC.h \ @@ -1114,6 +1158,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -1276,7 +1321,42 @@ realclean: $(TAO_ROOT)/tao/POAManager.h \ $(TAO_ROOT)/tao/POAManager.i \ $(TAO_ROOT)/tao/ImplRepoC.h \ - $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/corba.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/IORC.i \ + $(TAO_ROOT)/tao/IORS.i \ + $(TAO_ROOT)/tao/Interceptor.h \ + $(TAO_ROOT)/tao/InterceptorS.h \ + $(TAO_ROOT)/tao/InterceptorC.h \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/InterceptorC.i \ + $(TAO_ROOT)/tao/Interceptor.i \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/Request.h \ + $(TAO_ROOT)/tao/Context.h \ + $(TAO_ROOT)/tao/Context.i \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/TimeBaseC.i \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/MessagingC.i \ + $(TAO_ROOT)/tao/Request.i \ + $(TAO_ROOT)/tao/Server_Request.h \ + $(TAO_ROOT)/tao/Server_Request.i \ + $(TAO_ROOT)/tao/Marshal.h \ + $(TAO_ROOT)/tao/Marshal.i \ + $(TAO_ROOT)/tao/singletons.h \ $(TAO_ROOT)/tao/Stub.h \ $(TAO_ROOT)/tao/Pluggable.h \ $(ACE_ROOT)/ace/Message_Queue.h \ @@ -1300,8 +1380,6 @@ realclean: $(ACE_ROOT)/ace/WFMO_Reactor.i \ $(ACE_ROOT)/ace/Strategies.i \ $(ACE_ROOT)/ace/Message_Queue.i \ - $(TAO_ROOT)/tao/IOPC.h \ - $(TAO_ROOT)/tao/IOPC.i \ $(TAO_ROOT)/tao/Pluggable.i \ $(TAO_ROOT)/tao/MProfile.h \ $(TAO_ROOT)/tao/Profile.h \ @@ -1311,47 +1389,22 @@ realclean: $(TAO_ROOT)/tao/Tagged_Components.i \ $(TAO_ROOT)/tao/Profile.i \ $(TAO_ROOT)/tao/MProfile.i \ - $(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/IORC.i \ - $(TAO_ROOT)/tao/IORS.i \ - $(TAO_ROOT)/tao/Interceptor.h \ - $(TAO_ROOT)/tao/InterceptorS.h \ - $(TAO_ROOT)/tao/InterceptorC.h \ - $(TAO_ROOT)/tao/InterceptorC.i \ - $(TAO_ROOT)/tao/Interceptor.i \ - $(TAO_ROOT)/tao/ORB.i \ $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ $(TAO_ROOT)/tao/ORB_Core.h \ $(TAO_ROOT)/tao/Policy_Manager.h \ $(TAO_ROOT)/tao/Policy_Manager.i \ $(TAO_ROOT)/tao/Resource_Factory.h \ $(TAO_ROOT)/tao/Protocol_Factory.h \ - $(TAO_ROOT)/tao/params.h \ - $(TAO_ROOT)/tao/params.i \ $(TAO_ROOT)/tao/ORB_Core.i \ $(ACE_ROOT)/ace/Dynamic_Service.h \ $(ACE_ROOT)/ace/Dynamic_Service.cpp \ - $(TAO_ROOT)/tao/Server_Request.h \ - $(TAO_ROOT)/tao/Server_Request.i \ - $(TAO_ROOT)/tao/NVList.h \ - $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Client_Strategy_Factory.h \ $(TAO_ROOT)/tao/Invocation.h \ $(TAO_ROOT)/tao/Reply_Dispatcher.h \ - $(TAO_ROOT)/tao/Request.h \ - $(TAO_ROOT)/tao/Context.h \ - $(TAO_ROOT)/tao/Context.i \ - $(TAO_ROOT)/tao/MessagingC.h \ - $(TAO_ROOT)/tao/TimeBaseC.h \ - $(TAO_ROOT)/tao/TimeBaseC.i \ - $(TAO_ROOT)/tao/PollableC.h \ - $(TAO_ROOT)/tao/MessagingC.i \ - $(TAO_ROOT)/tao/Request.i \ $(TAO_ROOT)/tao/GIOP_Message_State.h \ $(TAO_ROOT)/tao/Pluggable_Messaging.h \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ @@ -1366,10 +1419,24 @@ realclean: $(TAO_ROOT)/tao/target_specification.h \ $(TAO_ROOT)/tao/target_specification.i \ $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/InconsistentTypeCodeC.h \ + $(TAO_ROOT)/tao/DynAny_i.h \ + $(TAO_ROOT)/tao/Union.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/InterfaceC.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ $(TAO_ROOT)/tao/ImplRepoC.i \ $(TAO_ROOT)/tao/POA.i -.obj/POAS.o .obj/POAS.so .shobj/POAS.o .shobj/POAS.so: POAS.cpp $(TAO_ROOT)/tao/POAS.h \ +.obj/POAS.o .obj/POAS.so .shobj/POAS.o .shobj/POAS.so: POAS.cpp \ + $(TAO_ROOT)/tao/POAS.h \ $(ACE_ROOT)/ace/pre.h \ $(TAO_ROOT)/tao/POAC.h \ $(TAO_ROOT)/tao/PolicyC.h \ @@ -1381,6 +1448,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -1583,6 +1651,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -1743,7 +1812,42 @@ realclean: $(TAO_ROOT)/tao/Object_KeyC.h \ $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/ImplRepoC.h \ - $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/corba.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/IORC.i \ + $(TAO_ROOT)/tao/IORS.i \ + $(TAO_ROOT)/tao/Interceptor.h \ + $(TAO_ROOT)/tao/InterceptorS.h \ + $(TAO_ROOT)/tao/InterceptorC.h \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/InterceptorC.i \ + $(TAO_ROOT)/tao/Interceptor.i \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/Request.h \ + $(TAO_ROOT)/tao/Context.h \ + $(TAO_ROOT)/tao/Context.i \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/TimeBaseC.i \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/MessagingC.i \ + $(TAO_ROOT)/tao/Request.i \ + $(TAO_ROOT)/tao/Server_Request.h \ + $(TAO_ROOT)/tao/Server_Request.i \ + $(TAO_ROOT)/tao/Marshal.h \ + $(TAO_ROOT)/tao/Marshal.i \ + $(TAO_ROOT)/tao/singletons.h \ $(TAO_ROOT)/tao/Stub.h \ $(TAO_ROOT)/tao/Pluggable.h \ $(ACE_ROOT)/ace/Message_Queue.h \ @@ -1767,8 +1871,6 @@ realclean: $(ACE_ROOT)/ace/WFMO_Reactor.i \ $(ACE_ROOT)/ace/Strategies.i \ $(ACE_ROOT)/ace/Message_Queue.i \ - $(TAO_ROOT)/tao/IOPC.h \ - $(TAO_ROOT)/tao/IOPC.i \ $(TAO_ROOT)/tao/Pluggable.i \ $(TAO_ROOT)/tao/MProfile.h \ $(TAO_ROOT)/tao/Profile.h \ @@ -1778,47 +1880,22 @@ realclean: $(TAO_ROOT)/tao/Tagged_Components.i \ $(TAO_ROOT)/tao/Profile.i \ $(TAO_ROOT)/tao/MProfile.i \ - $(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/IORC.i \ - $(TAO_ROOT)/tao/IORS.i \ - $(TAO_ROOT)/tao/Interceptor.h \ - $(TAO_ROOT)/tao/InterceptorS.h \ - $(TAO_ROOT)/tao/InterceptorC.h \ - $(TAO_ROOT)/tao/InterceptorC.i \ - $(TAO_ROOT)/tao/Interceptor.i \ - $(TAO_ROOT)/tao/ORB.i \ $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ $(TAO_ROOT)/tao/ORB_Core.h \ $(TAO_ROOT)/tao/Policy_Manager.h \ $(TAO_ROOT)/tao/Policy_Manager.i \ $(TAO_ROOT)/tao/Resource_Factory.h \ $(TAO_ROOT)/tao/Protocol_Factory.h \ - $(TAO_ROOT)/tao/params.h \ - $(TAO_ROOT)/tao/params.i \ $(TAO_ROOT)/tao/ORB_Core.i \ $(ACE_ROOT)/ace/Dynamic_Service.h \ $(ACE_ROOT)/ace/Dynamic_Service.cpp \ - $(TAO_ROOT)/tao/Server_Request.h \ - $(TAO_ROOT)/tao/Server_Request.i \ - $(TAO_ROOT)/tao/NVList.h \ - $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Client_Strategy_Factory.h \ $(TAO_ROOT)/tao/Invocation.h \ $(TAO_ROOT)/tao/Reply_Dispatcher.h \ - $(TAO_ROOT)/tao/Request.h \ - $(TAO_ROOT)/tao/Context.h \ - $(TAO_ROOT)/tao/Context.i \ - $(TAO_ROOT)/tao/MessagingC.h \ - $(TAO_ROOT)/tao/TimeBaseC.h \ - $(TAO_ROOT)/tao/TimeBaseC.i \ - $(TAO_ROOT)/tao/PollableC.h \ - $(TAO_ROOT)/tao/MessagingC.i \ - $(TAO_ROOT)/tao/Request.i \ $(TAO_ROOT)/tao/GIOP_Message_State.h \ $(TAO_ROOT)/tao/Pluggable_Messaging.h \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ @@ -1833,6 +1910,19 @@ realclean: $(TAO_ROOT)/tao/target_specification.h \ $(TAO_ROOT)/tao/target_specification.i \ $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/InconsistentTypeCodeC.h \ + $(TAO_ROOT)/tao/DynAny_i.h \ + $(TAO_ROOT)/tao/Union.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/InterfaceC.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ $(TAO_ROOT)/tao/ImplRepoC.i \ $(TAO_ROOT)/tao/POA.i @@ -1846,6 +1936,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -2005,6 +2096,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -2223,6 +2315,25 @@ realclean: $(TAO_ROOT)/tao/POAManager.h \ $(TAO_ROOT)/tao/POAManager.i \ $(TAO_ROOT)/tao/ImplRepoC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/Request.h \ + $(TAO_ROOT)/tao/Context.h \ + $(TAO_ROOT)/tao/Context.i \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/TimeBaseC.i \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/MessagingC.i \ + $(TAO_ROOT)/tao/Request.i \ + $(TAO_ROOT)/tao/Server_Request.h \ + $(TAO_ROOT)/tao/Server_Request.i \ + $(TAO_ROOT)/tao/Marshal.h \ + $(TAO_ROOT)/tao/Marshal.i \ + $(TAO_ROOT)/tao/singletons.h \ $(TAO_ROOT)/tao/Stub.h \ $(TAO_ROOT)/tao/MProfile.h \ $(TAO_ROOT)/tao/Profile.h \ @@ -2233,21 +2344,10 @@ realclean: $(TAO_ROOT)/tao/Profile.i \ $(TAO_ROOT)/tao/MProfile.i \ $(TAO_ROOT)/tao/Stub.i \ - $(TAO_ROOT)/tao/Server_Request.h \ - $(TAO_ROOT)/tao/Server_Request.i \ - $(TAO_ROOT)/tao/NVList.h \ - $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Client_Strategy_Factory.h \ $(TAO_ROOT)/tao/Invocation.h \ $(TAO_ROOT)/tao/Reply_Dispatcher.h \ - $(TAO_ROOT)/tao/Request.h \ - $(TAO_ROOT)/tao/Context.h \ - $(TAO_ROOT)/tao/Context.i \ - $(TAO_ROOT)/tao/MessagingC.h \ - $(TAO_ROOT)/tao/TimeBaseC.h \ - $(TAO_ROOT)/tao/TimeBaseC.i \ - $(TAO_ROOT)/tao/PollableC.h \ - $(TAO_ROOT)/tao/MessagingC.i \ - $(TAO_ROOT)/tao/Request.i \ $(TAO_ROOT)/tao/GIOP_Message_State.h \ $(TAO_ROOT)/tao/Pluggable_Messaging.h \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ @@ -2262,6 +2362,19 @@ realclean: $(TAO_ROOT)/tao/target_specification.h \ $(TAO_ROOT)/tao/target_specification.i \ $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/InconsistentTypeCodeC.h \ + $(TAO_ROOT)/tao/DynAny_i.h \ + $(TAO_ROOT)/tao/Union.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/InterfaceC.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ $(TAO_ROOT)/tao/ImplRepoC.i \ $(TAO_ROOT)/tao/POA.i @@ -2271,6 +2384,7 @@ realclean: $(TAO_ROOT)/tao/orbconf.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -2425,13 +2539,10 @@ realclean: .obj/ImplRepoC.o .obj/ImplRepoC.so .shobj/ImplRepoC.o .shobj/ImplRepoC.so: ImplRepoC.cpp ImplRepoC.h \ $(ACE_ROOT)/ace/pre.h \ - $(TAO_ROOT)/tao/Object.h \ - $(TAO_ROOT)/tao/corbafwd.h \ - $(ACE_ROOT)/ace/CDR_Stream.h \ - $(ACE_ROOT)/ace/Message_Block.h \ - $(ACE_ROOT)/ace/ACE.h \ + $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -2445,6 +2556,10 @@ realclean: $(ACE_ROOT)/ace/Log_Record.h \ $(ACE_ROOT)/ace/Log_Priority.h \ $(ACE_ROOT)/ace/Log_Record.i \ + $(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/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ @@ -2503,34 +2618,12 @@ realclean: $(TAO_ROOT)/tao/orbconf.h \ $(ACE_ROOT)/ace/CORBA_macros.h \ $(TAO_ROOT)/tao/corbafwd.i \ - $(TAO_ROOT)/tao/Object.i \ - $(TAO_ROOT)/tao/Managed_Types.h \ - $(TAO_ROOT)/tao/Managed_Types.i \ - $(TAO_ROOT)/tao/POAC.h \ - $(TAO_ROOT)/tao/PolicyC.h \ - $(TAO_ROOT)/tao/CurrentC.h \ - $(TAO_ROOT)/tao/CurrentC.i \ - $(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/Environment.h \ $(TAO_ROOT)/tao/Environment.i \ - $(TAO_ROOT)/tao/Sequence.h \ - $(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/varout.i \ - $(TAO_ROOT)/tao/varout.cpp \ - $(TAO_ROOT)/tao/PolicyC.i \ - $(TAO_ROOT)/tao/POAC.i \ - $(TAO_ROOT)/tao/Servant_Base.h \ - $(TAO_ROOT)/tao/Servant_Base.i \ - $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/IOR_LookupTable.h \ $(ACE_ROOT)/ace/Hash_Map_Manager.h \ $(ACE_ROOT)/ace/Functor.h \ $(ACE_ROOT)/ace/Functor.i \ @@ -2557,82 +2650,68 @@ realclean: $(ACE_ROOT)/ace/Reactor.i \ $(ACE_ROOT)/ace/Reactor_Impl.h \ $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ - $(TAO_ROOT)/tao/Stub.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 \ - $(ACE_ROOT)/ace/Message_Queue_T.i \ - $(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 \ - $(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/WFMO_Reactor.i \ - $(ACE_ROOT)/ace/Strategies.i \ - $(ACE_ROOT)/ace/Message_Queue.i \ - $(TAO_ROOT)/tao/IOPC.h \ - $(TAO_ROOT)/tao/IOPC.i \ - $(TAO_ROOT)/tao/Pluggable.i \ - $(TAO_ROOT)/tao/MProfile.h \ - $(TAO_ROOT)/tao/Profile.h \ - $(TAO_ROOT)/tao/Tagged_Components.h \ - $(TAO_ROOT)/tao/CONV_FRAMEC.h \ - $(TAO_ROOT)/tao/CONV_FRAMEC.i \ - $(TAO_ROOT)/tao/Tagged_Components.i \ - $(TAO_ROOT)/tao/Profile.i \ - $(TAO_ROOT)/tao/MProfile.i \ - $(TAO_ROOT)/tao/ORB.h \ - $(TAO_ROOT)/tao/IOR_LookupTable.h \ $(TAO_ROOT)/tao/Services.h \ + $(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/Services.i \ $(TAO_ROOT)/tao/IORManipulation.h \ $(TAO_ROOT)/tao/IORS.h \ $(TAO_ROOT)/tao/IORC.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/CDR.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/IOPC.h \ + $(TAO_ROOT)/tao/IOPC.i \ $(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/Stub.i \ - $(TAO_ROOT)/tao/ORB_Core.h \ - $(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/Protocol_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/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/Request.h \ + $(TAO_ROOT)/tao/Context.h \ + $(TAO_ROOT)/tao/Context.i \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/TimeBaseC.i \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/MessagingC.i \ + $(TAO_ROOT)/tao/Request.i \ $(TAO_ROOT)/tao/Server_Request.h \ $(TAO_ROOT)/tao/Object_KeyC.h \ $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/Server_Request.i \ - $(TAO_ROOT)/tao/NVList.h \ - $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Marshal.h \ + $(TAO_ROOT)/tao/Marshal.i \ + $(TAO_ROOT)/tao/singletons.h \ + $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ $(ACE_ROOT)/ace/Map.h \ @@ -2643,6 +2722,9 @@ realclean: $(ACE_ROOT)/ace/Pair_T.h \ $(ACE_ROOT)/ace/Pair_T.i \ $(ACE_ROOT)/ace/Pair_T.cpp \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ $(ACE_ROOT)/ace/Active_Map_Manager.h \ $(ACE_ROOT)/ace/Active_Map_Manager.i \ $(ACE_ROOT)/ace/Active_Map_Manager_T.h \ @@ -2654,21 +2736,67 @@ realclean: $(TAO_ROOT)/tao/Server_Strategy_Factory.h \ $(TAO_ROOT)/tao/poa_macros.h \ $(TAO_ROOT)/tao/POAS.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/POAS.i \ $(TAO_ROOT)/tao/Active_Object_Map.h \ $(TAO_ROOT)/tao/Active_Object_Map.i \ $(TAO_ROOT)/tao/Object_Adapter.i \ + $(TAO_ROOT)/tao/POAManager.h \ + $(TAO_ROOT)/tao/POAManager.i \ + $(TAO_ROOT)/tao/ImplRepoC.h \ + $(TAO_ROOT)/tao/POA.i \ + $(TAO_ROOT)/tao/Stub.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 \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(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 \ + $(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/WFMO_Reactor.i \ + $(ACE_ROOT)/ace/Strategies.i \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(TAO_ROOT)/tao/Pluggable.i \ + $(TAO_ROOT)/tao/MProfile.h \ + $(TAO_ROOT)/tao/Profile.h \ + $(TAO_ROOT)/tao/Tagged_Components.h \ + $(TAO_ROOT)/tao/CONV_FRAMEC.h \ + $(TAO_ROOT)/tao/CONV_FRAMEC.i \ + $(TAO_ROOT)/tao/Tagged_Components.i \ + $(TAO_ROOT)/tao/Profile.i \ + $(TAO_ROOT)/tao/MProfile.i \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/Policy_Manager.i \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(TAO_ROOT)/tao/Protocol_Factory.h \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(ACE_ROOT)/ace/Dynamic_Service.h \ + $(ACE_ROOT)/ace/Dynamic_Service.cpp \ + $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Client_Strategy_Factory.h \ $(TAO_ROOT)/tao/Invocation.h \ $(TAO_ROOT)/tao/Reply_Dispatcher.h \ - $(TAO_ROOT)/tao/Request.h \ - $(TAO_ROOT)/tao/Context.h \ - $(TAO_ROOT)/tao/Context.i \ - $(TAO_ROOT)/tao/MessagingC.h \ - $(TAO_ROOT)/tao/TimeBaseC.h \ - $(TAO_ROOT)/tao/TimeBaseC.i \ - $(TAO_ROOT)/tao/PollableC.h \ - $(TAO_ROOT)/tao/MessagingC.i \ - $(TAO_ROOT)/tao/Request.i \ $(TAO_ROOT)/tao/GIOP_Message_State.h \ $(TAO_ROOT)/tao/Pluggable_Messaging.h \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ @@ -2682,18 +2810,29 @@ realclean: $(TAO_ROOT)/tao/operation_details.i \ $(TAO_ROOT)/tao/target_specification.h \ $(TAO_ROOT)/tao/target_specification.i \ - $(TAO_ROOT)/tao/Invocation.i ImplRepoC.i + $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/InconsistentTypeCodeC.h \ + $(TAO_ROOT)/tao/DynAny_i.h \ + $(TAO_ROOT)/tao/Union.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/InterfaceC.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + ImplRepoC.i .obj/ImplRepoS.o .obj/ImplRepoS.so .shobj/ImplRepoS.o .shobj/ImplRepoS.so: ImplRepoS.cpp ImplRepoS.h \ $(ACE_ROOT)/ace/pre.h \ - $(TAO_ROOT)/tao/ImplRepoC.h \ - $(TAO_ROOT)/tao/Object.h \ - $(TAO_ROOT)/tao/corbafwd.h \ - $(ACE_ROOT)/ace/CDR_Stream.h \ - $(ACE_ROOT)/ace/Message_Block.h \ - $(ACE_ROOT)/ace/ACE.h \ + ImplRepoC.h \ + $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -2707,6 +2846,10 @@ realclean: $(ACE_ROOT)/ace/Log_Record.h \ $(ACE_ROOT)/ace/Log_Priority.h \ $(ACE_ROOT)/ace/Log_Record.i \ + $(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/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ @@ -2765,34 +2908,12 @@ realclean: $(TAO_ROOT)/tao/orbconf.h \ $(ACE_ROOT)/ace/CORBA_macros.h \ $(TAO_ROOT)/tao/corbafwd.i \ - $(TAO_ROOT)/tao/Object.i \ - $(TAO_ROOT)/tao/Managed_Types.h \ - $(TAO_ROOT)/tao/Managed_Types.i \ - $(TAO_ROOT)/tao/POAC.h \ - $(TAO_ROOT)/tao/PolicyC.h \ - $(TAO_ROOT)/tao/CurrentC.h \ - $(TAO_ROOT)/tao/CurrentC.i \ - $(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/Environment.h \ $(TAO_ROOT)/tao/Environment.i \ - $(TAO_ROOT)/tao/Sequence.h \ - $(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/varout.i \ - $(TAO_ROOT)/tao/varout.cpp \ - $(TAO_ROOT)/tao/PolicyC.i \ - $(TAO_ROOT)/tao/POAC.i \ - $(TAO_ROOT)/tao/Servant_Base.h \ - $(TAO_ROOT)/tao/Servant_Base.i \ - $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/IOR_LookupTable.h \ $(ACE_ROOT)/ace/Hash_Map_Manager.h \ $(ACE_ROOT)/ace/Functor.h \ $(ACE_ROOT)/ace/Functor.i \ @@ -2819,82 +2940,68 @@ realclean: $(ACE_ROOT)/ace/Reactor.i \ $(ACE_ROOT)/ace/Reactor_Impl.h \ $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ - $(TAO_ROOT)/tao/Stub.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 \ - $(ACE_ROOT)/ace/Message_Queue_T.i \ - $(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 \ - $(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/WFMO_Reactor.i \ - $(ACE_ROOT)/ace/Strategies.i \ - $(ACE_ROOT)/ace/Message_Queue.i \ - $(TAO_ROOT)/tao/IOPC.h \ - $(TAO_ROOT)/tao/IOPC.i \ - $(TAO_ROOT)/tao/Pluggable.i \ - $(TAO_ROOT)/tao/MProfile.h \ - $(TAO_ROOT)/tao/Profile.h \ - $(TAO_ROOT)/tao/Tagged_Components.h \ - $(TAO_ROOT)/tao/CONV_FRAMEC.h \ - $(TAO_ROOT)/tao/CONV_FRAMEC.i \ - $(TAO_ROOT)/tao/Tagged_Components.i \ - $(TAO_ROOT)/tao/Profile.i \ - $(TAO_ROOT)/tao/MProfile.i \ - $(TAO_ROOT)/tao/ORB.h \ - $(TAO_ROOT)/tao/IOR_LookupTable.h \ $(TAO_ROOT)/tao/Services.h \ + $(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/Services.i \ $(TAO_ROOT)/tao/IORManipulation.h \ $(TAO_ROOT)/tao/IORS.h \ $(TAO_ROOT)/tao/IORC.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/CDR.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/IOPC.h \ + $(TAO_ROOT)/tao/IOPC.i \ $(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/Stub.i \ - $(TAO_ROOT)/tao/ORB_Core.h \ - $(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/Protocol_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/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/Request.h \ + $(TAO_ROOT)/tao/Context.h \ + $(TAO_ROOT)/tao/Context.i \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/TimeBaseC.i \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/MessagingC.i \ + $(TAO_ROOT)/tao/Request.i \ $(TAO_ROOT)/tao/Server_Request.h \ $(TAO_ROOT)/tao/Object_KeyC.h \ $(TAO_ROOT)/tao/Object_KeyC.i \ $(TAO_ROOT)/tao/Server_Request.i \ - $(TAO_ROOT)/tao/NVList.h \ - $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Marshal.h \ + $(TAO_ROOT)/tao/Marshal.i \ + $(TAO_ROOT)/tao/singletons.h \ + $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ $(ACE_ROOT)/ace/Map.h \ @@ -2905,6 +3012,9 @@ realclean: $(ACE_ROOT)/ace/Pair_T.h \ $(ACE_ROOT)/ace/Pair_T.i \ $(ACE_ROOT)/ace/Pair_T.cpp \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ $(ACE_ROOT)/ace/Active_Map_Manager.h \ $(ACE_ROOT)/ace/Active_Map_Manager.i \ $(ACE_ROOT)/ace/Active_Map_Manager_T.h \ @@ -2916,21 +3026,67 @@ realclean: $(TAO_ROOT)/tao/Server_Strategy_Factory.h \ $(TAO_ROOT)/tao/poa_macros.h \ $(TAO_ROOT)/tao/POAS.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/POAS.i \ $(TAO_ROOT)/tao/Active_Object_Map.h \ $(TAO_ROOT)/tao/Active_Object_Map.i \ $(TAO_ROOT)/tao/Object_Adapter.i \ + $(TAO_ROOT)/tao/POAManager.h \ + $(TAO_ROOT)/tao/POAManager.i \ + $(TAO_ROOT)/tao/ImplRepoC.h \ + $(TAO_ROOT)/tao/POA.i \ + $(TAO_ROOT)/tao/Stub.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 \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(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 \ + $(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/WFMO_Reactor.i \ + $(ACE_ROOT)/ace/Strategies.i \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(TAO_ROOT)/tao/Pluggable.i \ + $(TAO_ROOT)/tao/MProfile.h \ + $(TAO_ROOT)/tao/Profile.h \ + $(TAO_ROOT)/tao/Tagged_Components.h \ + $(TAO_ROOT)/tao/CONV_FRAMEC.h \ + $(TAO_ROOT)/tao/CONV_FRAMEC.i \ + $(TAO_ROOT)/tao/Tagged_Components.i \ + $(TAO_ROOT)/tao/Profile.i \ + $(TAO_ROOT)/tao/MProfile.i \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/Policy_Manager.i \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(TAO_ROOT)/tao/Protocol_Factory.h \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(ACE_ROOT)/ace/Dynamic_Service.h \ + $(ACE_ROOT)/ace/Dynamic_Service.cpp \ + $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Client_Strategy_Factory.h \ $(TAO_ROOT)/tao/Invocation.h \ $(TAO_ROOT)/tao/Reply_Dispatcher.h \ - $(TAO_ROOT)/tao/Request.h \ - $(TAO_ROOT)/tao/Context.h \ - $(TAO_ROOT)/tao/Context.i \ - $(TAO_ROOT)/tao/MessagingC.h \ - $(TAO_ROOT)/tao/TimeBaseC.h \ - $(TAO_ROOT)/tao/TimeBaseC.i \ - $(TAO_ROOT)/tao/PollableC.h \ - $(TAO_ROOT)/tao/MessagingC.i \ - $(TAO_ROOT)/tao/Request.i \ $(TAO_ROOT)/tao/GIOP_Message_State.h \ $(TAO_ROOT)/tao/Pluggable_Messaging.h \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ @@ -2945,8 +3101,20 @@ realclean: $(TAO_ROOT)/tao/target_specification.h \ $(TAO_ROOT)/tao/target_specification.i \ $(TAO_ROOT)/tao/Invocation.i \ - $(TAO_ROOT)/tao/ImplRepoC.i ImplRepoS_T.h \ - ImplRepoS_T.i ImplRepoS_T.cpp ImplRepoS.i + $(TAO_ROOT)/tao/InconsistentTypeCodeC.h \ + $(TAO_ROOT)/tao/DynAny_i.h \ + $(TAO_ROOT)/tao/Union.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/InterfaceC.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + ImplRepoC.i ImplRepoS_T.h ImplRepoS_T.i ImplRepoS_T.cpp ImplRepoS.i .obj/Pluggable.o .obj/Pluggable.so .shobj/Pluggable.o .shobj/Pluggable.so: Pluggable.cpp \ $(TAO_ROOT)/tao/Pluggable.h \ @@ -2957,6 +3125,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -3188,6 +3357,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -3296,6 +3466,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -3500,6 +3671,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -3706,6 +3878,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -3859,6 +4032,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -4140,6 +4314,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -4424,6 +4599,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -4694,17 +4870,11 @@ realclean: $(TAO_ROOT)/tao/POAManager.h \ $(TAO_ROOT)/tao/POAManager.i \ $(TAO_ROOT)/tao/ImplRepoC.h \ - $(TAO_ROOT)/tao/Operation_Table.h \ - $(TAO_ROOT)/tao/Stub.h \ - $(TAO_ROOT)/tao/MProfile.h \ - $(TAO_ROOT)/tao/MProfile.i \ - $(TAO_ROOT)/tao/Stub.i \ - $(TAO_ROOT)/tao/Server_Request.h \ - $(TAO_ROOT)/tao/Server_Request.i \ + $(TAO_ROOT)/tao/corba.h \ $(TAO_ROOT)/tao/NVList.h \ $(TAO_ROOT)/tao/NVList.i \ - $(TAO_ROOT)/tao/Invocation.h \ - $(TAO_ROOT)/tao/Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ $(TAO_ROOT)/tao/Request.h \ $(TAO_ROOT)/tao/Context.h \ $(TAO_ROOT)/tao/Context.i \ @@ -4714,15 +4884,41 @@ realclean: $(TAO_ROOT)/tao/PollableC.h \ $(TAO_ROOT)/tao/MessagingC.i \ $(TAO_ROOT)/tao/Request.i \ + $(TAO_ROOT)/tao/Server_Request.h \ + $(TAO_ROOT)/tao/Server_Request.i \ + $(TAO_ROOT)/tao/Marshal.h \ + $(TAO_ROOT)/tao/Marshal.i \ + $(TAO_ROOT)/tao/singletons.h \ + $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/MProfile.h \ + $(TAO_ROOT)/tao/MProfile.i \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Client_Strategy_Factory.h \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.h \ $(TAO_ROOT)/tao/Reply_Dispatcher.i \ $(TAO_ROOT)/tao/TAOC.h \ $(TAO_ROOT)/tao/TAOC.i \ $(TAO_ROOT)/tao/target_specification.h \ $(TAO_ROOT)/tao/target_specification.i \ $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/InconsistentTypeCodeC.h \ + $(TAO_ROOT)/tao/DynAny_i.h \ + $(TAO_ROOT)/tao/Union.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/InterfaceC.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ $(TAO_ROOT)/tao/ImplRepoC.i \ - $(TAO_ROOT)/tao/POA.i \ - $(TAO_ROOT)/tao/debug.h + $(TAO_ROOT)/tao/POA.i .obj/IIOP_Transport.o .obj/IIOP_Transport.so .shobj/IIOP_Transport.o .shobj/IIOP_Transport.so: IIOP_Transport.cpp \ $(TAO_ROOT)/tao/IIOP_Transport.h \ @@ -4734,6 +4930,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -5021,6 +5218,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -5307,6 +5505,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -5571,6 +5770,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -5856,6 +6056,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -5998,12 +6199,6 @@ realclean: $(TAO_ROOT)/tao/IOPC.i \ $(TAO_ROOT)/tao/Pluggable.i \ $(TAO_ROOT)/tao/UIOP_Acceptor.h \ - $(TAO_ROOT)/tao/GIOP_Message_State.h \ - $(TAO_ROOT)/tao/Pluggable_Messaging.h \ - $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ - $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ - $(TAO_ROOT)/tao/Pluggable_Messaging.i \ - $(TAO_ROOT)/tao/GIOP_Message_State.i \ $(ACE_ROOT)/ace/Acceptor.h \ $(ACE_ROOT)/ace/Svc_Handler.h \ $(ACE_ROOT)/ace/Task.h \ @@ -6049,6 +6244,12 @@ realclean: $(ACE_ROOT)/ace/LSOCK_Acceptor.i \ $(TAO_ROOT)/tao/UIOP_Connect.h \ $(TAO_ROOT)/tao/UIOP_Transport.h \ + $(TAO_ROOT)/tao/GIOP_Message_State.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ + $(TAO_ROOT)/tao/Pluggable_Messaging.i \ + $(TAO_ROOT)/tao/GIOP_Message_State.i \ $(TAO_ROOT)/tao/UIOP_Transport.i \ $(TAO_ROOT)/tao/Wait_Strategy.h \ $(TAO_ROOT)/tao/UIOP_Connect.i \ @@ -6144,6 +6345,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -6286,12 +6488,6 @@ realclean: $(TAO_ROOT)/tao/IOPC.i \ $(TAO_ROOT)/tao/Pluggable.i \ $(TAO_ROOT)/tao/UIOP_Acceptor.h \ - $(TAO_ROOT)/tao/GIOP_Message_State.h \ - $(TAO_ROOT)/tao/Pluggable_Messaging.h \ - $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ - $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ - $(TAO_ROOT)/tao/Pluggable_Messaging.i \ - $(TAO_ROOT)/tao/GIOP_Message_State.i \ $(ACE_ROOT)/ace/Acceptor.h \ $(ACE_ROOT)/ace/Svc_Handler.h \ $(ACE_ROOT)/ace/Task.h \ @@ -6337,6 +6533,12 @@ realclean: $(ACE_ROOT)/ace/LSOCK_Acceptor.i \ $(TAO_ROOT)/tao/UIOP_Connect.h \ $(TAO_ROOT)/tao/UIOP_Transport.h \ + $(TAO_ROOT)/tao/GIOP_Message_State.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ + $(TAO_ROOT)/tao/Pluggable_Messaging.i \ + $(TAO_ROOT)/tao/GIOP_Message_State.i \ $(TAO_ROOT)/tao/UIOP_Transport.i \ $(TAO_ROOT)/tao/Wait_Strategy.h \ $(TAO_ROOT)/tao/UIOP_Connect.i \ @@ -6433,6 +6635,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -6709,17 +6912,11 @@ realclean: $(TAO_ROOT)/tao/POAManager.h \ $(TAO_ROOT)/tao/POAManager.i \ $(TAO_ROOT)/tao/ImplRepoC.h \ - $(TAO_ROOT)/tao/Operation_Table.h \ - $(TAO_ROOT)/tao/Stub.h \ - $(TAO_ROOT)/tao/MProfile.h \ - $(TAO_ROOT)/tao/MProfile.i \ - $(TAO_ROOT)/tao/Stub.i \ - $(TAO_ROOT)/tao/Server_Request.h \ - $(TAO_ROOT)/tao/Server_Request.i \ + $(TAO_ROOT)/tao/corba.h \ $(TAO_ROOT)/tao/NVList.h \ $(TAO_ROOT)/tao/NVList.i \ - $(TAO_ROOT)/tao/Invocation.h \ - $(TAO_ROOT)/tao/Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ $(TAO_ROOT)/tao/Request.h \ $(TAO_ROOT)/tao/Context.h \ $(TAO_ROOT)/tao/Context.i \ @@ -6729,6 +6926,20 @@ realclean: $(TAO_ROOT)/tao/PollableC.h \ $(TAO_ROOT)/tao/MessagingC.i \ $(TAO_ROOT)/tao/Request.i \ + $(TAO_ROOT)/tao/Server_Request.h \ + $(TAO_ROOT)/tao/Server_Request.i \ + $(TAO_ROOT)/tao/Marshal.h \ + $(TAO_ROOT)/tao/Marshal.i \ + $(TAO_ROOT)/tao/singletons.h \ + $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/MProfile.h \ + $(TAO_ROOT)/tao/MProfile.i \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Client_Strategy_Factory.h \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.h \ $(TAO_ROOT)/tao/Reply_Dispatcher.i \ $(TAO_ROOT)/tao/TAOC.h \ $(TAO_ROOT)/tao/TAOC.i \ @@ -6737,9 +6948,21 @@ realclean: $(TAO_ROOT)/tao/target_specification.h \ $(TAO_ROOT)/tao/target_specification.i \ $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/InconsistentTypeCodeC.h \ + $(TAO_ROOT)/tao/DynAny_i.h \ + $(TAO_ROOT)/tao/Union.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/InterfaceC.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ $(TAO_ROOT)/tao/ImplRepoC.i \ - $(TAO_ROOT)/tao/POA.i \ - $(TAO_ROOT)/tao/debug.h + $(TAO_ROOT)/tao/POA.i .obj/UIOP_Transport.o .obj/UIOP_Transport.so .shobj/UIOP_Transport.o .shobj/UIOP_Transport.so: UIOP_Transport.cpp \ $(TAO_ROOT)/tao/UIOP_Transport.h \ @@ -6751,6 +6974,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -7044,6 +7268,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -7337,6 +7562,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -7476,12 +7702,6 @@ realclean: $(TAO_ROOT)/tao/CDR.i \ $(TAO_ROOT)/tao/IOPC.i \ $(TAO_ROOT)/tao/Pluggable.i \ - $(TAO_ROOT)/tao/GIOP_Message_State.h \ - $(TAO_ROOT)/tao/Pluggable_Messaging.h \ - $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ - $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ - $(TAO_ROOT)/tao/Pluggable_Messaging.i \ - $(TAO_ROOT)/tao/GIOP_Message_State.i \ $(ACE_ROOT)/ace/Acceptor.h \ $(ACE_ROOT)/ace/Svc_Handler.h \ $(ACE_ROOT)/ace/Task.h \ @@ -7527,6 +7747,12 @@ realclean: $(ACE_ROOT)/ace/LSOCK_Acceptor.i \ $(TAO_ROOT)/tao/UIOP_Connect.h \ $(TAO_ROOT)/tao/UIOP_Transport.h \ + $(TAO_ROOT)/tao/GIOP_Message_State.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ + $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ + $(TAO_ROOT)/tao/Pluggable_Messaging.i \ + $(TAO_ROOT)/tao/GIOP_Message_State.i \ $(TAO_ROOT)/tao/UIOP_Transport.i \ $(TAO_ROOT)/tao/Wait_Strategy.h \ $(TAO_ROOT)/tao/UIOP_Connect.i \ @@ -7606,6 +7832,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -7894,6 +8121,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -8185,6 +8413,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -8464,17 +8693,11 @@ realclean: $(TAO_ROOT)/tao/POAManager.h \ $(TAO_ROOT)/tao/POAManager.i \ $(TAO_ROOT)/tao/ImplRepoC.h \ - $(TAO_ROOT)/tao/Operation_Table.h \ - $(TAO_ROOT)/tao/Stub.h \ - $(TAO_ROOT)/tao/MProfile.h \ - $(TAO_ROOT)/tao/MProfile.i \ - $(TAO_ROOT)/tao/Stub.i \ - $(TAO_ROOT)/tao/Server_Request.h \ - $(TAO_ROOT)/tao/Server_Request.i \ + $(TAO_ROOT)/tao/corba.h \ $(TAO_ROOT)/tao/NVList.h \ $(TAO_ROOT)/tao/NVList.i \ - $(TAO_ROOT)/tao/Invocation.h \ - $(TAO_ROOT)/tao/Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ $(TAO_ROOT)/tao/Request.h \ $(TAO_ROOT)/tao/Context.h \ $(TAO_ROOT)/tao/Context.i \ @@ -8484,6 +8707,20 @@ realclean: $(TAO_ROOT)/tao/PollableC.h \ $(TAO_ROOT)/tao/MessagingC.i \ $(TAO_ROOT)/tao/Request.i \ + $(TAO_ROOT)/tao/Server_Request.h \ + $(TAO_ROOT)/tao/Server_Request.i \ + $(TAO_ROOT)/tao/Marshal.h \ + $(TAO_ROOT)/tao/Marshal.i \ + $(TAO_ROOT)/tao/singletons.h \ + $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/MProfile.h \ + $(TAO_ROOT)/tao/MProfile.i \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Client_Strategy_Factory.h \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.h \ $(TAO_ROOT)/tao/Reply_Dispatcher.i \ $(TAO_ROOT)/tao/TAOC.h \ $(TAO_ROOT)/tao/TAOC.i \ @@ -8492,9 +8729,21 @@ realclean: $(TAO_ROOT)/tao/target_specification.h \ $(TAO_ROOT)/tao/target_specification.i \ $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/InconsistentTypeCodeC.h \ + $(TAO_ROOT)/tao/DynAny_i.h \ + $(TAO_ROOT)/tao/Union.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/InterfaceC.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ $(TAO_ROOT)/tao/ImplRepoC.i \ - $(TAO_ROOT)/tao/POA.i \ - $(TAO_ROOT)/tao/debug.h + $(TAO_ROOT)/tao/POA.i .obj/SHMIOP_Transport.o .obj/SHMIOP_Transport.so .shobj/SHMIOP_Transport.o .shobj/SHMIOP_Transport.so: SHMIOP_Transport.cpp \ $(TAO_ROOT)/tao/SHMIOP_Transport.h \ @@ -8505,6 +8754,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -8800,6 +9050,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -9096,6 +9347,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -9367,6 +9619,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -9636,10 +9889,12 @@ realclean: $(TAO_ROOT)/tao/GIOP_Utils.i \ $(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 \ +.obj/IORC.o .obj/IORC.so .shobj/IORC.o .shobj/IORC.so: IORC.cpp \ + $(TAO_ROOT)/tao/IORC.h \ $(ACE_ROOT)/ace/pre.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -9868,11 +10123,13 @@ realclean: $(TAO_ROOT)/tao/target_specification.i \ $(TAO_ROOT)/tao/Invocation.i -.obj/IORS.o .obj/IORS.so .shobj/IORS.o .shobj/IORS.so: IORS.cpp $(TAO_ROOT)/tao/IORS.h \ +.obj/IORS.o .obj/IORS.so .shobj/IORS.o .shobj/IORS.so: IORS.cpp \ + $(TAO_ROOT)/tao/IORS.h \ $(ACE_ROOT)/ace/pre.h \ $(TAO_ROOT)/tao/IORC.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -9989,6 +10246,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -10177,6 +10435,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -10383,6 +10642,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -10579,6 +10839,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -10824,6 +11085,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -10978,6 +11240,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -11131,6 +11394,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -11280,600 +11544,6 @@ realclean: $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/debug.h -.obj/decode.o .obj/decode.so .shobj/decode.o .shobj/decode.so: decode.cpp \ - $(TAO_ROOT)/tao/Marshal.h \ - $(ACE_ROOT)/ace/pre.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/post.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/Typecode.h \ - $(TAO_ROOT)/tao/Exception.h \ - $(TAO_ROOT)/tao/Exception.i \ - $(TAO_ROOT)/tao/Typecode.i \ - $(TAO_ROOT)/tao/Principal.h \ - $(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/Principal.i \ - $(TAO_ROOT)/tao/Any.h \ - $(TAO_ROOT)/tao/CDR.h \ - $(TAO_ROOT)/tao/CDR.i \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ - $(TAO_ROOT)/tao/Any.i \ - $(TAO_ROOT)/tao/ORB.h \ - $(TAO_ROOT)/tao/IOR_LookupTable.h \ - $(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/Service_Config.h \ - $(ACE_ROOT)/ace/Service_Object.h \ - $(ACE_ROOT)/ace/Shared_Object.h \ - $(ACE_ROOT)/ace/Shared_Object.i \ - $(ACE_ROOT)/ace/Service_Object.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 \ - $(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/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/IOPC.h \ - $(TAO_ROOT)/tao/IOPC.i \ - $(TAO_ROOT)/tao/InterceptorC.i \ - $(TAO_ROOT)/tao/Interceptor.i \ - $(TAO_ROOT)/tao/ORB.i \ - $(TAO_ROOT)/tao/Marshal.i \ - $(TAO_ROOT)/tao/MProfile.h \ - $(TAO_ROOT)/tao/Profile.h \ - $(TAO_ROOT)/tao/Tagged_Components.h \ - $(TAO_ROOT)/tao/CONV_FRAMEC.h \ - $(TAO_ROOT)/tao/CONV_FRAMEC.i \ - $(TAO_ROOT)/tao/Tagged_Components.i \ - $(TAO_ROOT)/tao/Profile.i \ - $(TAO_ROOT)/tao/MProfile.i \ - $(TAO_ROOT)/tao/Stub.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 \ - $(ACE_ROOT)/ace/Message_Queue_T.i \ - $(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 \ - $(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/WFMO_Reactor.i \ - $(ACE_ROOT)/ace/Strategies.i \ - $(ACE_ROOT)/ace/Message_Queue.i \ - $(TAO_ROOT)/tao/Pluggable.i \ - $(TAO_ROOT)/tao/Stub.i \ - $(TAO_ROOT)/tao/Union.h \ - $(TAO_ROOT)/tao/ORB_Core.h \ - $(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/Protocol_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/debug.h - -.obj/deep_free.o .obj/deep_free.so .shobj/deep_free.o .shobj/deep_free.so: deep_free.cpp \ - $(TAO_ROOT)/tao/Marshal.h \ - $(ACE_ROOT)/ace/pre.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/post.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/Typecode.h \ - $(TAO_ROOT)/tao/Exception.h \ - $(TAO_ROOT)/tao/Exception.i \ - $(TAO_ROOT)/tao/Typecode.i \ - $(TAO_ROOT)/tao/Principal.h \ - $(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/Principal.i \ - $(TAO_ROOT)/tao/Any.h \ - $(TAO_ROOT)/tao/CDR.h \ - $(TAO_ROOT)/tao/CDR.i \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ - $(TAO_ROOT)/tao/Any.i \ - $(TAO_ROOT)/tao/ORB.h \ - $(TAO_ROOT)/tao/IOR_LookupTable.h \ - $(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/Service_Config.h \ - $(ACE_ROOT)/ace/Service_Object.h \ - $(ACE_ROOT)/ace/Shared_Object.h \ - $(ACE_ROOT)/ace/Shared_Object.i \ - $(ACE_ROOT)/ace/Service_Object.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 \ - $(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/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/IOPC.h \ - $(TAO_ROOT)/tao/IOPC.i \ - $(TAO_ROOT)/tao/InterceptorC.i \ - $(TAO_ROOT)/tao/Interceptor.i \ - $(TAO_ROOT)/tao/ORB.i \ - $(TAO_ROOT)/tao/Marshal.i \ - $(TAO_ROOT)/tao/Stub.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 \ - $(ACE_ROOT)/ace/Message_Queue_T.i \ - $(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 \ - $(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/WFMO_Reactor.i \ - $(ACE_ROOT)/ace/Strategies.i \ - $(ACE_ROOT)/ace/Message_Queue.i \ - $(TAO_ROOT)/tao/Pluggable.i \ - $(TAO_ROOT)/tao/MProfile.h \ - $(TAO_ROOT)/tao/Profile.h \ - $(TAO_ROOT)/tao/Tagged_Components.h \ - $(TAO_ROOT)/tao/CONV_FRAMEC.h \ - $(TAO_ROOT)/tao/CONV_FRAMEC.i \ - $(TAO_ROOT)/tao/Tagged_Components.i \ - $(TAO_ROOT)/tao/Profile.i \ - $(TAO_ROOT)/tao/MProfile.i \ - $(TAO_ROOT)/tao/Stub.i \ - $(TAO_ROOT)/tao/Union.h \ - $(TAO_ROOT)/tao/debug.h - -.obj/encode.o .obj/encode.so .shobj/encode.o .shobj/encode.so: encode.cpp \ - $(TAO_ROOT)/tao/Marshal.h \ - $(ACE_ROOT)/ace/pre.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/post.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/Typecode.h \ - $(TAO_ROOT)/tao/Exception.h \ - $(TAO_ROOT)/tao/Exception.i \ - $(TAO_ROOT)/tao/Typecode.i \ - $(TAO_ROOT)/tao/Principal.h \ - $(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/Principal.i \ - $(TAO_ROOT)/tao/Any.h \ - $(TAO_ROOT)/tao/CDR.h \ - $(TAO_ROOT)/tao/CDR.i \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ - $(TAO_ROOT)/tao/Any.i \ - $(TAO_ROOT)/tao/ORB.h \ - $(TAO_ROOT)/tao/IOR_LookupTable.h \ - $(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/Service_Config.h \ - $(ACE_ROOT)/ace/Service_Object.h \ - $(ACE_ROOT)/ace/Shared_Object.h \ - $(ACE_ROOT)/ace/Shared_Object.i \ - $(ACE_ROOT)/ace/Service_Object.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 \ - $(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/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/IOPC.h \ - $(TAO_ROOT)/tao/IOPC.i \ - $(TAO_ROOT)/tao/InterceptorC.i \ - $(TAO_ROOT)/tao/Interceptor.i \ - $(TAO_ROOT)/tao/ORB.i \ - $(TAO_ROOT)/tao/Marshal.i \ - $(TAO_ROOT)/tao/Stub.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 \ - $(ACE_ROOT)/ace/Message_Queue_T.i \ - $(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 \ - $(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/WFMO_Reactor.i \ - $(ACE_ROOT)/ace/Strategies.i \ - $(ACE_ROOT)/ace/Message_Queue.i \ - $(TAO_ROOT)/tao/Pluggable.i \ - $(TAO_ROOT)/tao/MProfile.h \ - $(TAO_ROOT)/tao/Profile.h \ - $(TAO_ROOT)/tao/Tagged_Components.h \ - $(TAO_ROOT)/tao/CONV_FRAMEC.h \ - $(TAO_ROOT)/tao/CONV_FRAMEC.i \ - $(TAO_ROOT)/tao/Tagged_Components.i \ - $(TAO_ROOT)/tao/Profile.i \ - $(TAO_ROOT)/tao/MProfile.i \ - $(TAO_ROOT)/tao/Stub.i \ - $(TAO_ROOT)/tao/Union.h \ - $(TAO_ROOT)/tao/debug.h - .obj/CDR_Interpreter.o .obj/CDR_Interpreter.so .shobj/CDR_Interpreter.o .shobj/CDR_Interpreter.so: CDR_Interpreter.cpp \ $(TAO_ROOT)/tao/Sequence.h \ $(ACE_ROOT)/ace/pre.h \ @@ -11883,6 +11553,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -11987,6 +11658,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -12136,7 +11808,8 @@ realclean: $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h -.obj/skip.o .obj/skip.so .shobj/skip.o .shobj/skip.so: skip.cpp $(TAO_ROOT)/tao/Marshal.h \ +.obj/skip.o .obj/skip.so .shobj/skip.o .shobj/skip.so: skip.cpp \ + $(TAO_ROOT)/tao/Marshal.h \ $(ACE_ROOT)/ace/pre.h \ $(TAO_ROOT)/tao/corbafwd.h \ $(ACE_ROOT)/ace/CDR_Stream.h \ @@ -12144,6 +11817,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -12302,6 +11976,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -12446,7 +12121,8 @@ realclean: $(TAO_ROOT)/tao/Interceptor.i \ $(TAO_ROOT)/tao/ORB.i -.obj/Union.o .obj/Union.so .shobj/Union.o .shobj/Union.so: Union.cpp $(TAO_ROOT)/tao/Union.h \ +.obj/Union.o .obj/Union.so .shobj/Union.o .shobj/Union.so: Union.cpp \ + $(TAO_ROOT)/tao/Union.h \ $(ACE_ROOT)/ace/pre.h \ $(TAO_ROOT)/tao/corbafwd.h \ $(ACE_ROOT)/ace/CDR_Stream.h \ @@ -12454,6 +12130,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -12532,6 +12209,7 @@ realclean: $(ACE_ROOT)/ace/Hash_Map_Manager.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -12682,7 +12360,8 @@ realclean: $(TAO_ROOT)/tao/Interceptor.i \ $(TAO_ROOT)/tao/ORB.i -.obj/Any.o .obj/Any.so .shobj/Any.o .shobj/Any.so: Any.cpp $(TAO_ROOT)/tao/Any.h \ +.obj/Any.o .obj/Any.so .shobj/Any.o .shobj/Any.so: Any.cpp \ + $(TAO_ROOT)/tao/Any.h \ $(ACE_ROOT)/ace/pre.h \ $(TAO_ROOT)/tao/CDR.h \ $(TAO_ROOT)/tao/corbafwd.h \ @@ -12691,6 +12370,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -12891,6 +12571,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -13082,6 +12763,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -13224,6 +12906,7 @@ realclean: $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/pre.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -13318,6 +13001,7 @@ realclean: $(TAO_ROOT)/tao/orbconf.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -13410,6 +13094,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -13604,6 +13289,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -13868,6 +13554,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -14014,7 +13701,8 @@ realclean: $(TAO_ROOT)/tao/Interceptor.i \ $(TAO_ROOT)/tao/ORB.i -.obj/ORB.o .obj/ORB.so .shobj/ORB.o .shobj/ORB.so: ORB.cpp $(TAO_ROOT)/tao/ORB.h \ +.obj/ORB.o .obj/ORB.so .shobj/ORB.o .shobj/ORB.so: ORB.cpp \ + $(TAO_ROOT)/tao/ORB.h \ $(ACE_ROOT)/ace/pre.h \ $(TAO_ROOT)/tao/corbafwd.h \ $(ACE_ROOT)/ace/CDR_Stream.h \ @@ -14022,6 +13710,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -14287,11 +13976,7 @@ realclean: $(TAO_ROOT)/tao/POAManager.h \ $(TAO_ROOT)/tao/POAManager.i \ $(TAO_ROOT)/tao/ImplRepoC.h \ - $(TAO_ROOT)/tao/Operation_Table.h \ - $(TAO_ROOT)/tao/Server_Request.h \ - $(TAO_ROOT)/tao/Server_Request.i \ - $(TAO_ROOT)/tao/Invocation.h \ - $(TAO_ROOT)/tao/Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/corba.h \ $(TAO_ROOT)/tao/Request.h \ $(TAO_ROOT)/tao/Context.h \ $(TAO_ROOT)/tao/Context.i \ @@ -14301,6 +13986,13 @@ realclean: $(TAO_ROOT)/tao/PollableC.h \ $(TAO_ROOT)/tao/MessagingC.i \ $(TAO_ROOT)/tao/Request.i \ + $(TAO_ROOT)/tao/Server_Request.h \ + $(TAO_ROOT)/tao/Server_Request.i \ + $(TAO_ROOT)/tao/singletons.h \ + $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/Client_Strategy_Factory.h \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.h \ $(TAO_ROOT)/tao/GIOP_Message_State.h \ $(TAO_ROOT)/tao/Pluggable_Messaging.h \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ @@ -14315,6 +14007,18 @@ realclean: $(TAO_ROOT)/tao/target_specification.h \ $(TAO_ROOT)/tao/target_specification.i \ $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/InconsistentTypeCodeC.h \ + $(TAO_ROOT)/tao/Union.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/InterfaceC.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ $(TAO_ROOT)/tao/ImplRepoC.i \ $(TAO_ROOT)/tao/POA.i \ $(TAO_ROOT)/tao/ValueFactory_Map.h \ @@ -14346,6 +14050,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -14429,6 +14134,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -14662,6 +14368,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -14823,6 +14530,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -15055,6 +14763,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -15221,6 +14930,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -15321,6 +15031,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -15417,6 +15128,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -15517,6 +15229,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -15609,6 +15322,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -15813,6 +15527,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -15963,7 +15678,8 @@ realclean: $(TAO_ROOT)/tao/Environment.h \ $(TAO_ROOT)/tao/Environment.i -.obj/Stub.o .obj/Stub.so .shobj/Stub.o .shobj/Stub.so: Stub.cpp $(TAO_ROOT)/tao/Stub.h \ +.obj/Stub.o .obj/Stub.so .shobj/Stub.o .shobj/Stub.so: Stub.cpp \ + $(TAO_ROOT)/tao/Stub.h \ $(ACE_ROOT)/ace/pre.h \ $(TAO_ROOT)/tao/Pluggable.h \ $(TAO_ROOT)/tao/corbafwd.h \ @@ -15972,6 +15688,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -16220,9 +15937,7 @@ realclean: $(TAO_ROOT)/tao/MessagingS.i \ $(TAO_ROOT)/tao/Messaging_Policy_i.i \ $(TAO_ROOT)/tao/Client_Priority_Policy.h \ - $(TAO_ROOT)/tao/Client_Priority_Policy.i \ - $(TAO_ROOT)/tao/Timeprobe.h \ - $(ACE_ROOT)/ace/Timeprobe.h + $(TAO_ROOT)/tao/Client_Priority_Policy.i .obj/Typecode.o .obj/Typecode.so .shobj/Typecode.o .shobj/Typecode.so: Typecode.cpp \ $(TAO_ROOT)/tao/Typecode.h \ @@ -16231,6 +15946,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -16393,6 +16109,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -16589,6 +16306,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -16668,6 +16386,7 @@ realclean: $(ACE_ROOT)/ace/Hash_Map_Manager.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -16819,9 +16538,11 @@ realclean: $(TAO_ROOT)/tao/Interceptor.i \ $(TAO_ROOT)/tao/ORB.i -.obj/CDR.o .obj/CDR.so .shobj/CDR.o .shobj/CDR.so: CDR.cpp $(TAO_ROOT)/tao/Timeprobe.h \ +.obj/CDR.o .obj/CDR.so .shobj/CDR.o .shobj/CDR.so: CDR.cpp \ + $(TAO_ROOT)/tao/Timeprobe.h \ $(ACE_ROOT)/ace/pre.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -17027,6 +16748,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -17104,7 +16826,8 @@ realclean: $(ACE_ROOT)/ace/CORBA_macros.h \ $(TAO_ROOT)/tao/corbafwd.i -.obj/debug.o .obj/debug.so .shobj/debug.o .shobj/debug.so: debug.cpp $(TAO_ROOT)/tao/debug.h \ +.obj/debug.o .obj/debug.so .shobj/debug.o .shobj/debug.so: debug.cpp \ + $(TAO_ROOT)/tao/debug.h \ $(ACE_ROOT)/ace/pre.h \ $(TAO_ROOT)/tao/corbafwd.h \ $(ACE_ROOT)/ace/CDR_Stream.h \ @@ -17112,6 +16835,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -17193,6 +16917,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -17292,6 +17017,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -17551,6 +17277,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -17652,6 +17379,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -17768,6 +17496,7 @@ realclean: $(TAO_ROOT)/tao/orbconf.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -17883,6 +17612,7 @@ realclean: $(TAO_ROOT)/tao/orbconf.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -18002,6 +17732,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -18241,6 +17972,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -18490,13 +18222,11 @@ realclean: $(TAO_ROOT)/tao/POAManager.h \ $(TAO_ROOT)/tao/POAManager.i \ $(TAO_ROOT)/tao/ImplRepoC.h \ - $(TAO_ROOT)/tao/Operation_Table.h \ - $(TAO_ROOT)/tao/Server_Request.h \ - $(TAO_ROOT)/tao/Server_Request.i \ + $(TAO_ROOT)/tao/corba.h \ $(TAO_ROOT)/tao/NVList.h \ $(TAO_ROOT)/tao/NVList.i \ - $(TAO_ROOT)/tao/Invocation.h \ - $(TAO_ROOT)/tao/Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ $(TAO_ROOT)/tao/Request.h \ $(TAO_ROOT)/tao/Context.h \ $(TAO_ROOT)/tao/Context.i \ @@ -18506,6 +18236,14 @@ realclean: $(TAO_ROOT)/tao/PollableC.h \ $(TAO_ROOT)/tao/MessagingC.i \ $(TAO_ROOT)/tao/Request.i \ + $(TAO_ROOT)/tao/Server_Request.h \ + $(TAO_ROOT)/tao/Server_Request.i \ + $(TAO_ROOT)/tao/Marshal.h \ + $(TAO_ROOT)/tao/Marshal.i \ + $(TAO_ROOT)/tao/singletons.h \ + $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.h \ $(TAO_ROOT)/tao/GIOP_Message_State.h \ $(TAO_ROOT)/tao/Pluggable_Messaging.h \ $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ @@ -18520,6 +18258,19 @@ realclean: $(TAO_ROOT)/tao/target_specification.h \ $(TAO_ROOT)/tao/target_specification.i \ $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/InconsistentTypeCodeC.h \ + $(TAO_ROOT)/tao/DynAny_i.h \ + $(TAO_ROOT)/tao/Union.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/InterfaceC.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ $(TAO_ROOT)/tao/ImplRepoC.i \ $(TAO_ROOT)/tao/POA.i \ $(TAO_ROOT)/tao/Priority_Mapping.h \ @@ -18543,6 +18294,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -18738,6 +18490,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -18821,6 +18574,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -19021,6 +18775,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -19221,6 +18976,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -19327,6 +19083,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -19528,6 +19285,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -19613,6 +19371,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -19830,6 +19589,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -19991,6 +19751,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -20157,6 +19918,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -20275,7 +20037,8 @@ realclean: $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/debug.h -.obj/TAO.o .obj/TAO.so .shobj/TAO.o .shobj/TAO.so: TAO.cpp $(TAO_ROOT)/tao/TAO.h \ +.obj/TAO.o .obj/TAO.so .shobj/TAO.o .shobj/TAO.so: TAO.cpp \ + $(TAO_ROOT)/tao/TAO.h \ $(ACE_ROOT)/ace/pre.h \ $(TAO_ROOT)/tao/corbafwd.h \ $(ACE_ROOT)/ace/CDR_Stream.h \ @@ -20283,6 +20046,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -20437,6 +20201,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -20640,6 +20405,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -20830,6 +20596,7 @@ realclean: $(TAO_ROOT)/tao/orbconf.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -21039,7 +20806,8 @@ realclean: $(TAO_ROOT)/tao/Leader_Follower.i \ $(TAO_ROOT)/tao/debug.h -.obj/IOPC.o .obj/IOPC.so .shobj/IOPC.o .shobj/IOPC.so: IOPC.cpp $(TAO_ROOT)/tao/IOPC.h \ +.obj/IOPC.o .obj/IOPC.so .shobj/IOPC.o .shobj/IOPC.so: IOPC.cpp \ + $(TAO_ROOT)/tao/IOPC.h \ $(ACE_ROOT)/ace/pre.h \ $(TAO_ROOT)/tao/CDR.h \ $(TAO_ROOT)/tao/corbafwd.h \ @@ -21048,6 +20816,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -21142,7 +20911,8 @@ realclean: $(TAO_ROOT)/tao/Environment.i \ $(TAO_ROOT)/tao/Any.i -.obj/IOPS.o .obj/IOPS.so .shobj/IOPS.o .shobj/IOPS.so: IOPS.cpp $(TAO_ROOT)/tao/IOPS.h \ +.obj/IOPS.o .obj/IOPS.so .shobj/IOPS.o .shobj/IOPS.so: IOPS.cpp \ + $(TAO_ROOT)/tao/IOPS.h \ $(ACE_ROOT)/ace/pre.h \ $(TAO_ROOT)/tao/IOPC.h \ $(TAO_ROOT)/tao/CDR.h \ @@ -21152,6 +20922,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -21255,6 +21026,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -21337,6 +21109,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -21419,6 +21192,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -21524,6 +21298,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -21629,6 +21404,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -21722,7 +21498,8 @@ realclean: $(TAO_ROOT)/tao/CONV_FRAMEC.i \ $(TAO_ROOT)/tao/Tagged_Components.i -.obj/GIOPC.o .obj/GIOPC.so .shobj/GIOPC.o .shobj/GIOPC.so: GIOPC.cpp $(TAO_ROOT)/tao/GIOPC.h \ +.obj/GIOPC.o .obj/GIOPC.so .shobj/GIOPC.o .shobj/GIOPC.so: GIOPC.cpp \ + $(TAO_ROOT)/tao/GIOPC.h \ $(ACE_ROOT)/ace/pre.h \ $(TAO_ROOT)/tao/corbafwd.h \ $(ACE_ROOT)/ace/CDR_Stream.h \ @@ -21730,6 +21507,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -21830,11 +21608,108 @@ realclean: $(TAO_ROOT)/tao/Any.h \ $(TAO_ROOT)/tao/Any.i -.obj/TAOC.o .obj/TAOC.so .shobj/TAOC.o .shobj/TAOC.so: TAOC.cpp $(TAO_ROOT)/tao/TAOC.h \ +.obj/BoundsC.o .obj/BoundsC.so .shobj/BoundsC.o .shobj/BoundsC.so: BoundsC.cpp \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(ACE_ROOT)/ace/pre.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.7.h \ + $(ACE_ROOT)/ace/config-sunos5.6.h \ + $(ACE_ROOT)/ace/config-sunos5.5.h \ + $(ACE_ROOT)/ace/post.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/Exception.h \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/CDR.h \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/BoundsC.i + +.obj/TAOC.o .obj/TAOC.so .shobj/TAOC.o .shobj/TAOC.so: TAOC.cpp \ + $(TAO_ROOT)/tao/TAOC.h \ $(ACE_ROOT)/ace/pre.h \ $(TAO_ROOT)/tao/orbconf.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -21953,12 +21828,14 @@ realclean: $(TAO_ROOT)/tao/TAOS_T.cpp \ $(TAO_ROOT)/tao/TAOS.i -.obj/TAOS.o .obj/TAOS.so .shobj/TAOS.o .shobj/TAOS.so: TAOS.cpp $(TAO_ROOT)/tao/TAOS.h \ +.obj/TAOS.o .obj/TAOS.so .shobj/TAOS.o .shobj/TAOS.so: TAOS.cpp \ + $(TAO_ROOT)/tao/TAOS.h \ $(ACE_ROOT)/ace/pre.h \ $(TAO_ROOT)/tao/TAOC.h \ $(TAO_ROOT)/tao/orbconf.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -22085,6 +21962,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -22239,6 +22117,7 @@ realclean: $(TAO_ROOT)/tao/orbconf.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -22442,6 +22321,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -22542,6 +22422,7 @@ realclean: $(TAO_ROOT)/tao/orbconf.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -22690,6 +22571,8 @@ realclean: $(TAO_ROOT)/tao/InterceptorC.i \ $(TAO_ROOT)/tao/Interceptor.i \ $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ $(TAO_ROOT)/tao/debug.h \ $(ACE_ROOT)/ace/Auto_Ptr.h \ $(ACE_ROOT)/ace/Auto_Ptr.i \ @@ -22701,6 +22584,7 @@ realclean: $(TAO_ROOT)/tao/orbconf.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -22940,6 +22824,7 @@ realclean: $(ACE_ROOT)/ace/pre.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -23187,6 +23072,7 @@ realclean: $(TAO_ROOT)/tao/orbconf.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -23406,6 +23292,7 @@ realclean: $(TAO_ROOT)/tao/orbconf.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -23538,6 +23425,7 @@ realclean: $(TAO_ROOT)/tao/orbconf.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -23664,6 +23552,7 @@ realclean: $(TAO_ROOT)/tao/orbconf.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -23793,6 +23682,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -23871,6 +23761,7 @@ realclean: $(ACE_ROOT)/ace/pre.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -23955,6 +23846,7 @@ realclean: $(ACE_ROOT)/ace/pre.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -24044,6 +23936,7 @@ realclean: $(ACE_ROOT)/ace/pre.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -24138,6 +24031,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -24347,6 +24241,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -24560,6 +24455,7 @@ realclean: $(TAO_ROOT)/tao/orbconf.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -24751,6 +24647,7 @@ realclean: $(TAO_ROOT)/tao/orbconf.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -24866,6 +24763,7 @@ realclean: $(TAO_ROOT)/tao/orbconf.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -24993,6 +24891,7 @@ realclean: $(TAO_ROOT)/tao/orbconf.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -25111,6 +25010,7 @@ realclean: $(TAO_ROOT)/tao/orbconf.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -25229,6 +25129,7 @@ realclean: $(TAO_ROOT)/tao/orbconf.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -25347,6 +25248,7 @@ realclean: $(TAO_ROOT)/tao/orbconf.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -25508,6 +25410,7 @@ realclean: $(TAO_ROOT)/tao/orbconf.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -25628,6 +25531,7 @@ realclean: $(TAO_ROOT)/tao/orbconf.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -25785,6 +25689,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -26022,6 +25927,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -26259,6 +26165,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -26412,6 +26319,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -26517,6 +26425,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -26680,6 +26589,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -26813,6 +26723,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -27039,7 +26950,25 @@ realclean: $(TAO_ROOT)/tao/POAManager.h \ $(TAO_ROOT)/tao/POAManager.i \ $(TAO_ROOT)/tao/ImplRepoC.h \ - $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/corba.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/Request.h \ + $(TAO_ROOT)/tao/Context.h \ + $(TAO_ROOT)/tao/Context.i \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/TimeBaseC.i \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/MessagingC.i \ + $(TAO_ROOT)/tao/Request.i \ + $(TAO_ROOT)/tao/Server_Request.h \ + $(TAO_ROOT)/tao/Server_Request.i \ + $(TAO_ROOT)/tao/Marshal.h \ + $(TAO_ROOT)/tao/Marshal.i \ + $(TAO_ROOT)/tao/singletons.h \ $(TAO_ROOT)/tao/Stub.h \ $(TAO_ROOT)/tao/MProfile.h \ $(TAO_ROOT)/tao/Profile.h \ @@ -27050,21 +26979,11 @@ realclean: $(TAO_ROOT)/tao/Profile.i \ $(TAO_ROOT)/tao/MProfile.i \ $(TAO_ROOT)/tao/Stub.i \ - $(TAO_ROOT)/tao/Server_Request.h \ - $(TAO_ROOT)/tao/Server_Request.i \ - $(TAO_ROOT)/tao/NVList.h \ - $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Client_Strategy_Factory.h \ $(TAO_ROOT)/tao/Invocation.h \ $(TAO_ROOT)/tao/Reply_Dispatcher.h \ - $(TAO_ROOT)/tao/Request.h \ - $(TAO_ROOT)/tao/Context.h \ - $(TAO_ROOT)/tao/Context.i \ - $(TAO_ROOT)/tao/MessagingC.h \ - $(TAO_ROOT)/tao/TimeBaseC.h \ - $(TAO_ROOT)/tao/TimeBaseC.i \ - $(TAO_ROOT)/tao/PollableC.h \ - $(TAO_ROOT)/tao/MessagingC.i \ - $(TAO_ROOT)/tao/Request.i \ $(TAO_ROOT)/tao/Reply_Dispatcher.i \ $(TAO_ROOT)/tao/TAOC.h \ $(TAO_ROOT)/tao/TAOC.i \ @@ -27073,14 +26992,23 @@ realclean: $(TAO_ROOT)/tao/target_specification.h \ $(TAO_ROOT)/tao/target_specification.i \ $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/InconsistentTypeCodeC.h \ + $(TAO_ROOT)/tao/DynAny_i.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/InterfaceC.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ $(TAO_ROOT)/tao/ImplRepoC.i \ $(TAO_ROOT)/tao/POA.i \ - $(TAO_ROOT)/tao/debug.h \ $(TAO_ROOT)/tao/GIOP_Utils.h \ $(TAO_ROOT)/tao/GIOP_Utils.i \ $(TAO_ROOT)/tao/GIOP_Server_Request.h \ - $(TAO_ROOT)/tao/Principal.h \ - $(TAO_ROOT)/tao/Principal.i \ $(TAO_ROOT)/tao/GIOP_Server_Request.i .obj/GIOP_Message_Accept_State.o .obj/GIOP_Message_Accept_State.so .shobj/GIOP_Message_Accept_State.o .shobj/GIOP_Message_Accept_State.so: GIOP_Message_Accept_State.cpp \ @@ -27094,6 +27022,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -27271,6 +27200,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -27473,6 +27403,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -27580,6 +27511,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -27683,6 +27615,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -27901,6 +27834,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ @@ -28145,7 +28079,19 @@ realclean: $(TAO_ROOT)/tao/POAManager.h \ $(TAO_ROOT)/tao/POAManager.i \ $(TAO_ROOT)/tao/ImplRepoC.h \ - $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/corba.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Request.h \ + $(TAO_ROOT)/tao/Context.h \ + $(TAO_ROOT)/tao/Context.i \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/MessagingC.i \ + $(TAO_ROOT)/tao/Request.i \ + $(TAO_ROOT)/tao/Marshal.h \ + $(TAO_ROOT)/tao/Marshal.i \ + $(TAO_ROOT)/tao/singletons.h \ $(TAO_ROOT)/tao/Stub.h \ $(TAO_ROOT)/tao/MProfile.h \ $(TAO_ROOT)/tao/Profile.h \ @@ -28156,21 +28102,26 @@ realclean: $(TAO_ROOT)/tao/Profile.i \ $(TAO_ROOT)/tao/MProfile.i \ $(TAO_ROOT)/tao/Stub.i \ - $(TAO_ROOT)/tao/NVList.h \ - $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/Client_Strategy_Factory.h \ $(TAO_ROOT)/tao/Invocation.h \ $(TAO_ROOT)/tao/Reply_Dispatcher.h \ - $(TAO_ROOT)/tao/Request.h \ - $(TAO_ROOT)/tao/Context.h \ - $(TAO_ROOT)/tao/Context.i \ - $(TAO_ROOT)/tao/MessagingC.h \ - $(TAO_ROOT)/tao/PollableC.h \ - $(TAO_ROOT)/tao/MessagingC.i \ - $(TAO_ROOT)/tao/Request.i \ $(TAO_ROOT)/tao/Reply_Dispatcher.i \ $(TAO_ROOT)/tao/operation_details.h \ $(TAO_ROOT)/tao/operation_details.i \ $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/InconsistentTypeCodeC.h \ + $(TAO_ROOT)/tao/DynAny_i.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/InterfaceC.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ $(TAO_ROOT)/tao/ImplRepoC.i \ $(TAO_ROOT)/tao/POA.i @@ -28187,6 +28138,7 @@ realclean: $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config-sunos5.7.h \ $(ACE_ROOT)/ace/config-sunos5.6.h \ $(ACE_ROOT)/ace/config-sunos5.5.h \ $(ACE_ROOT)/ace/post.h \ diff --git a/TAO/tao/Marshal.h b/TAO/tao/Marshal.h index 08cace23d3a..9af48324893 100644 --- a/TAO/tao/Marshal.h +++ b/TAO/tao/Marshal.h @@ -35,18 +35,6 @@ class TAO_OutputCDR; class TAO_InputCDR; -CORBA::TypeCode::traverse_status -DEEP_COPY (CORBA::TypeCode_ptr param, - const void *source, - const void *dest, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - -CORBA::TypeCode::traverse_status -DEEP_FREE (CORBA::TypeCode_ptr param, - const void *source, - const void *dest, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - // = Forward declarations. class TAO_Marshal_Object; class TAO_Marshal_Primitive; @@ -115,23 +103,9 @@ class TAO_Export TAO_Marshal_Object // The Marshaling object that provides a common interface to the // CDR object for marshaling different IDL data types // - // Provides a set of virtual methods for encoding, decoding - // and deep_freeing. + // Provides a set of virtual methods for appending and skipping + // data over a CDR stream. public: - virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; - // encoding operation - - virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *parent_typecode, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; - // decoding operation - virtual CORBA::TypeCode::traverse_status skip (CORBA::TypeCode_ptr tc, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; @@ -161,20 +135,6 @@ public: virtual ~TAO_Marshal_Primitive (void); - virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *parent_typecode, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); virtual CORBA::TypeCode::traverse_status skip (CORBA::TypeCode_ptr tc, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); @@ -199,20 +159,6 @@ public: virtual ~TAO_Marshal_Any (void); - virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *parent_typecode, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc, - const void *source, - const void *, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); virtual CORBA::TypeCode::traverse_status skip (CORBA::TypeCode_ptr tc, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); @@ -237,20 +183,6 @@ public: virtual ~TAO_Marshal_TypeCode (void); - virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *parent_typecode, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); virtual CORBA::TypeCode::traverse_status skip (CORBA::TypeCode_ptr tc, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); @@ -275,20 +207,6 @@ public: virtual ~TAO_Marshal_Principal (void); - virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *parent_typecode, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); virtual CORBA::TypeCode::traverse_status skip (CORBA::TypeCode_ptr tc, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); @@ -313,20 +231,6 @@ public: virtual ~TAO_Marshal_ObjRef (void); - virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *parent_typecode, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); virtual CORBA::TypeCode::traverse_status skip (CORBA::TypeCode_ptr tc, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); @@ -351,20 +255,6 @@ public: virtual ~TAO_Marshal_Struct (void); - virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *parent_typecode, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); virtual CORBA::TypeCode::traverse_status skip (CORBA::TypeCode_ptr tc, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); @@ -389,20 +279,6 @@ public: virtual ~TAO_Marshal_Union (void); - virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *parent_typecode, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); virtual CORBA::TypeCode::traverse_status skip (CORBA::TypeCode_ptr tc, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); @@ -427,20 +303,6 @@ public: virtual ~TAO_Marshal_String (void); - virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *parent_typecode, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); virtual CORBA::TypeCode::traverse_status skip (CORBA::TypeCode_ptr tc, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); @@ -465,20 +327,6 @@ public: virtual ~TAO_Marshal_Sequence (void); - virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *parent_typecode, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); virtual CORBA::TypeCode::traverse_status skip (CORBA::TypeCode_ptr tc, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); @@ -503,20 +351,6 @@ public: virtual ~TAO_Marshal_Array (void); - virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *parent_typecode, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); virtual CORBA::TypeCode::traverse_status skip (CORBA::TypeCode_ptr tc, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); @@ -541,20 +375,6 @@ public: virtual ~TAO_Marshal_Alias (void); - virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *parent_typecode, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); virtual CORBA::TypeCode::traverse_status skip (CORBA::TypeCode_ptr tc, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); @@ -578,20 +398,6 @@ public: TAO_Marshal_Except (void); ~TAO_Marshal_Except (void); - virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *parent_typecode, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); virtual CORBA::TypeCode::traverse_status skip (CORBA::TypeCode_ptr tc, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); @@ -615,20 +421,6 @@ public: TAO_Marshal_WString (void); ~TAO_Marshal_WString (void); - virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *parent_typecode, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); virtual CORBA::TypeCode::traverse_status skip (CORBA::TypeCode_ptr tc, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); diff --git a/TAO/tao/Marshal.i b/TAO/tao/Marshal.i index 1d95143e76d..9ee1717db49 100644 --- a/TAO/tao/Marshal.i +++ b/TAO/tao/Marshal.i @@ -138,74 +138,3 @@ ACE_INLINE TAO_Marshal_WString::~TAO_Marshal_WString (void) { } - -// *************** deep_free methods ****************** - -// deep_free for Any -ACE_INLINE CORBA::TypeCode::traverse_status -TAO_Marshal_Any::deep_free (CORBA::TypeCode_ptr, - const void *source, - const void *, - CORBA::Environment &) -{ - ((CORBA::Any *) source)->~CORBA_Any (); - return CORBA::TypeCode::TRAVERSE_CONTINUE; -} - -// deep_free for TypeCode -ACE_INLINE CORBA::TypeCode::traverse_status -TAO_Marshal_TypeCode::deep_free (CORBA::TypeCode_ptr, - const void *source, - const void *, - CORBA::Environment &) -{ - CORBA::release (*(CORBA::TypeCode_ptr *) source); - return CORBA::TypeCode::TRAVERSE_CONTINUE; -} - -// deep_free for Principal -ACE_INLINE CORBA::TypeCode::traverse_status -TAO_Marshal_Principal::deep_free (CORBA::TypeCode_ptr, - const void *value, - const void *, - CORBA::Environment &) -{ - CORBA::release (*(CORBA::Principal_ptr *) value); - return CORBA::TypeCode::TRAVERSE_CONTINUE; -} - -// deep_free for ObjRef -ACE_INLINE CORBA::TypeCode::traverse_status -TAO_Marshal_ObjRef::deep_free (CORBA::TypeCode_ptr, - const void *source, - const void *, - CORBA::Environment &) -{ - CORBA::Object_ptr obj = *(CORBA::Object_ptr *)source; - CORBA::release (obj); - return CORBA::TypeCode::TRAVERSE_CONTINUE; -} - -// deep_free for string -ACE_INLINE CORBA::TypeCode::traverse_status -TAO_Marshal_String::deep_free (CORBA::TypeCode_ptr, - const void *source, - const void *, - CORBA::Environment &) -{ - CORBA::string_free (*(CORBA::Char* *) source); - *(CORBA::Char* *)source = 0; - return CORBA::TypeCode::TRAVERSE_CONTINUE; -} - -// deep_free for wstring -ACE_INLINE CORBA::TypeCode::traverse_status -TAO_Marshal_WString::deep_free (CORBA::TypeCode_ptr, - const void *source, - const void *, - CORBA::Environment &) -{ - CORBA::wstring_free (*(CORBA::WChar* *) source); - *(CORBA::WChar* *)source = 0; - return CORBA::TypeCode::TRAVERSE_CONTINUE; -} diff --git a/TAO/tao/MessagingC.cpp b/TAO/tao/MessagingC.cpp index 4528f4238c8..ddc1e33d3ed 100644 --- a/TAO/tao/MessagingC.cpp +++ b/TAO/tao/MessagingC.cpp @@ -2075,47 +2075,31 @@ 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( - Messaging::_tc_RebindPolicy, + Messaging::_tc_RebindPolicy, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void Messaging::RebindPolicy::_tao_any_destructor (void *x) +{ + Messaging::RebindPolicy *tmp = ACE_static_cast(Messaging::RebindPolicy*,x); + CORBA::release (tmp); } 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; @@ -2128,24 +2112,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::RebindPolicy_ { _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 + _tao_elem, + Messaging::RebindPolicy::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = Messaging::RebindPolicy::_nil (); return 0; } @@ -2156,47 +2133,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::RebindPolicy_ 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( - Messaging::_tc_SyncScopePolicy, + Messaging::_tc_SyncScopePolicy, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void Messaging::SyncScopePolicy::_tao_any_destructor (void *x) +{ + Messaging::SyncScopePolicy *tmp = ACE_static_cast(Messaging::SyncScopePolicy*,x); + CORBA::release (tmp); } 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; @@ -2209,24 +2170,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::SyncScopePoli { _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 + _tao_elem, + Messaging::SyncScopePolicy::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = Messaging::SyncScopePolicy::_nil (); return 0; } @@ -2237,34 +2191,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::SyncScopePoli void operator<<= (CORBA::Any &_tao_any, const Messaging::PriorityRange &_tao_elem) // copying { - Messaging::PriorityRange *_any_val = 0; - ACE_NEW (_any_val, Messaging::PriorityRange (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_any_val; + stream << _tao_elem; _tao_any._tao_replace ( Messaging::_tc_PriorityRange, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _any_val; - } - ACE_ENDTRY; +} + +void Messaging::PriorityRange::_tao_any_destructor (void *x) +{ + Messaging::PriorityRange *tmp = ACE_static_cast(Messaging::PriorityRange*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, Messaging::PriorityRange *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -2273,16 +2216,8 @@ void operator<<= (CORBA::Any &_tao_any, Messaging::PriorityRange *_tao_elem) // stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + Messaging::PriorityRange::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::PriorityRange *&_tao_elem) @@ -2314,9 +2249,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::PriorityRange Messaging::_tc_PriorityRange, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + Messaging::PriorityRange::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -2330,7 +2264,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::PriorityRange { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -2338,98 +2272,36 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::PriorityRange 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; + return _tao_any >>= ACE_const_cast(Messaging::PriorityRange *&,_tao_elem); } 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( - Messaging::_tc_RequestPriorityPolicy, + Messaging::_tc_RequestPriorityPolicy, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void Messaging::RequestPriorityPolicy::_tao_any_destructor (void *x) +{ + Messaging::RequestPriorityPolicy *tmp = ACE_static_cast(Messaging::RequestPriorityPolicy*,x); + CORBA::release (tmp); } 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; @@ -2442,24 +2314,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::RequestPriori { _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 + _tao_elem, + Messaging::RequestPriorityPolicy::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = Messaging::RequestPriorityPolicy::_nil (); return 0; } @@ -2470,47 +2335,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::RequestPriori 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( - Messaging::_tc_ReplyPriorityPolicy, + Messaging::_tc_ReplyPriorityPolicy, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void Messaging::ReplyPriorityPolicy::_tao_any_destructor (void *x) +{ + Messaging::ReplyPriorityPolicy *tmp = ACE_static_cast(Messaging::ReplyPriorityPolicy*,x); + CORBA::release (tmp); } 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; @@ -2523,24 +2372,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::ReplyPriority { _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 + _tao_elem, + Messaging::ReplyPriorityPolicy::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = Messaging::ReplyPriorityPolicy::_nil (); return 0; } @@ -2551,47 +2393,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::ReplyPriority 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( - Messaging::_tc_RequestStartTimePolicy, + Messaging::_tc_RequestStartTimePolicy, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void Messaging::RequestStartTimePolicy::_tao_any_destructor (void *x) +{ + Messaging::RequestStartTimePolicy *tmp = ACE_static_cast(Messaging::RequestStartTimePolicy*,x); + CORBA::release (tmp); } 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; @@ -2604,24 +2430,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::RequestStartT { _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 + _tao_elem, + Messaging::RequestStartTimePolicy::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = Messaging::RequestStartTimePolicy::_nil (); return 0; } @@ -2632,47 +2451,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::RequestStartT 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( - Messaging::_tc_RequestEndTimePolicy, + Messaging::_tc_RequestEndTimePolicy, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_obj_ptr; } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void Messaging::RequestEndTimePolicy::_tao_any_destructor (void *x) +{ + Messaging::RequestEndTimePolicy *tmp = ACE_static_cast(Messaging::RequestEndTimePolicy*,x); + CORBA::release (tmp); } 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; @@ -2685,24 +2488,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::RequestEndTim { _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 + _tao_elem, + Messaging::RequestEndTimePolicy::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = Messaging::RequestEndTimePolicy::_nil (); return 0; } @@ -2713,47 +2509,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::RequestEndTim 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( - Messaging::_tc_ReplyStartTimePolicy, + Messaging::_tc_ReplyStartTimePolicy, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void Messaging::ReplyStartTimePolicy::_tao_any_destructor (void *x) +{ + Messaging::ReplyStartTimePolicy *tmp = ACE_static_cast(Messaging::ReplyStartTimePolicy*,x); + CORBA::release (tmp); } 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; @@ -2766,24 +2546,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::ReplyStartTim { _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 + _tao_elem, + Messaging::ReplyStartTimePolicy::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = Messaging::ReplyStartTimePolicy::_nil (); return 0; } @@ -2794,47 +2567,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::ReplyStartTim 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( - Messaging::_tc_ReplyEndTimePolicy, + Messaging::_tc_ReplyEndTimePolicy, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void Messaging::ReplyEndTimePolicy::_tao_any_destructor (void *x) +{ + Messaging::ReplyEndTimePolicy *tmp = ACE_static_cast(Messaging::ReplyEndTimePolicy*,x); + CORBA::release (tmp); } 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; @@ -2847,24 +2604,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::ReplyEndTimeP { _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 + _tao_elem, + Messaging::ReplyEndTimePolicy::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = Messaging::ReplyEndTimePolicy::_nil (); return 0; } @@ -2875,47 +2625,32 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::ReplyEndTimeP 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( - Messaging::_tc_RelativeRequestTimeoutPolicy, + Messaging::_tc_RelativeRequestTimeoutPolicy, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void Messaging::RelativeRequestTimeoutPolicy::_tao_any_destructor +(void *x) +{ + Messaging::RelativeRequestTimeoutPolicy *tmp = ACE_static_cast(Messaging::RelativeRequestTimeoutPolicy*,x); + CORBA::release (tmp); } 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; @@ -2928,24 +2663,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::RelativeReque { _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 + _tao_elem, + Messaging::RelativeRequestTimeoutPolicy::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = Messaging::RelativeRequestTimeoutPolicy::_nil (); return 0; } @@ -2956,47 +2684,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::RelativeReque 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( - Messaging::_tc_RelativeRoundtripTimeoutPolicy, + Messaging::_tc_RelativeRoundtripTimeoutPolicy, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_obj_ptr; } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void Messaging::RelativeRoundtripTimeoutPolicy::_tao_any_destructor (void *x) +{ + Messaging::RelativeRoundtripTimeoutPolicy *tmp = ACE_static_cast(Messaging::RelativeRoundtripTimeoutPolicy*,x); + CORBA::release (tmp); } 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; @@ -3009,24 +2721,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::RelativeRound { _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 + _tao_elem, + Messaging::RelativeRoundtripTimeoutPolicy::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = Messaging::RelativeRoundtripTimeoutPolicy::_nil (); return 0; } @@ -3039,34 +2744,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::RelativeRound void operator<<= (CORBA::Any &_tao_any, const Messaging::RoutingTypeRange &_tao_elem) // copying { - Messaging::RoutingTypeRange *_any_val = 0; - ACE_NEW (_any_val, Messaging::RoutingTypeRange (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_any_val; + stream << _tao_elem; _tao_any._tao_replace ( Messaging::_tc_RoutingTypeRange, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _any_val; - } - ACE_ENDTRY; +} + +void Messaging::RoutingTypeRange::_tao_any_destructor (void *x) +{ + Messaging::RoutingTypeRange *tmp = ACE_static_cast(Messaging::RoutingTypeRange*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, Messaging::RoutingTypeRange *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -3075,16 +2769,8 @@ void operator<<= (CORBA::Any &_tao_any, Messaging::RoutingTypeRange *_tao_elem) stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + Messaging::RoutingTypeRange::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::RoutingTypeRange *&_tao_elem) @@ -3116,9 +2802,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::RoutingTypeRa Messaging::_tc_RoutingTypeRange, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + Messaging::RoutingTypeRange::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -3132,7 +2817,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::RoutingTypeRa { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -3140,100 +2825,38 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::RoutingTypeRa 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; + return _tao_any >>= ACE_const_cast(Messaging::RoutingTypeRange *&,_tao_elem); } // **************************************************************** 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( - Messaging::_tc_RoutingPolicy, + Messaging::_tc_RoutingPolicy, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void Messaging::RoutingPolicy::_tao_any_destructor (void *x) +{ + Messaging::RoutingPolicy *tmp = ACE_static_cast(Messaging::RoutingPolicy*,x); + CORBA::release (tmp); } 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; @@ -3246,24 +2869,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::RoutingPolicy { _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 + _tao_elem, + Messaging::RoutingPolicy::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = Messaging::RoutingPolicy::_nil (); return 0; } @@ -3274,47 +2890,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::RoutingPolicy 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( - Messaging::_tc_MaxHopsPolicy, + Messaging::_tc_MaxHopsPolicy, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void Messaging::MaxHopsPolicy::_tao_any_destructor (void *x) +{ + Messaging::MaxHopsPolicy *tmp = ACE_static_cast(Messaging::MaxHopsPolicy*,x); + CORBA::release (tmp); } 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; @@ -3327,24 +2927,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::MaxHopsPolicy { _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 + _tao_elem, + Messaging::MaxHopsPolicy::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = Messaging::MaxHopsPolicy::_nil (); return 0; } @@ -3355,47 +2948,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::MaxHopsPolicy 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( - Messaging::_tc_QueueOrderPolicy, + Messaging::_tc_QueueOrderPolicy, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void Messaging::QueueOrderPolicy::_tao_any_destructor (void *x) +{ + Messaging::QueueOrderPolicy *tmp = ACE_static_cast(Messaging::QueueOrderPolicy*,x); + CORBA::release (tmp); } 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; @@ -3408,24 +2985,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::QueueOrderPol { _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 + _tao_elem, + Messaging::QueueOrderPolicy::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = Messaging::QueueOrderPolicy::_nil (); return 0; } @@ -3436,34 +3006,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::QueueOrderPol void operator<<= (CORBA::Any &_tao_any, const Messaging::PolicyValue &_tao_elem) // copying { - Messaging::PolicyValue *_any_val = 0; - ACE_NEW (_any_val, Messaging::PolicyValue (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_any_val; + stream << _tao_elem; _tao_any._tao_replace ( Messaging::_tc_PolicyValue, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _any_val; - } - ACE_ENDTRY; +} + +void Messaging::PolicyValue::_tao_any_destructor (void *x) +{ + Messaging::PolicyValue *tmp = ACE_static_cast(Messaging::PolicyValue*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, Messaging::PolicyValue *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -3472,16 +3031,8 @@ void operator<<= (CORBA::Any &_tao_any, Messaging::PolicyValue *_tao_elem) // no stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + Messaging::PolicyValue::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::PolicyValue *&_tao_elem) @@ -3513,9 +3064,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::PolicyValue * Messaging::_tc_PolicyValue, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + Messaging::PolicyValue::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -3529,7 +3079,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::PolicyValue * { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -3537,53 +3087,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::PolicyValue * 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; + return _tao_any >>= ACE_const_cast(Messaging::PolicyValue *&,_tao_elem); } // **************************************************************** @@ -3593,40 +3097,25 @@ void operator<<= ( const Messaging::PolicyValueSeq &_tao_elem ) // copying { - Messaging::PolicyValueSeq *_tao_any_val; - ACE_NEW (_tao_any_val, Messaging::PolicyValueSeq (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - if (stream << *_tao_any_val) + if (stream << _tao_elem) { _tao_any._tao_replace ( Messaging::_tc_PolicyValueSeq, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_any_val; - } - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void Messaging::PolicyValueSeq::_tao_any_destructor (void *x) +{ + Messaging::PolicyValueSeq *tmp = ACE_static_cast(Messaging::PolicyValueSeq*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, Messaging::PolicyValueSeq *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -3635,16 +3124,8 @@ void operator<<= (CORBA::Any &_tao_any, Messaging::PolicyValueSeq *_tao_elem) // stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + Messaging::PolicyValueSeq::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::PolicyValueSeq *&_tao_elem) @@ -3676,9 +3157,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::PolicyValueSe Messaging::_tc_PolicyValueSeq, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + Messaging::PolicyValueSeq::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -3692,7 +3172,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::PolicyValueSe { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -3700,53 +3180,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::PolicyValueSe 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; + return _tao_any >>= ACE_const_cast(Messaging::PolicyValueSeq *&,_tao_elem); } // **************************************************************** @@ -3759,47 +3193,31 @@ Messaging::ReplyHandler_ptr (*_TAO_collocation_Messaging_ReplyHandler_Stub_Facto void operator<<= (CORBA::Any &_tao_any, Messaging::ReplyHandler_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::ReplyHandler::_duplicate (_tao_elem); TAO_OutputCDR stream; - if (stream << *_tao_obj_ptr) + if (stream << _tao_elem) { _tao_any._tao_replace ( - Messaging::_tc_ReplyHandler, + Messaging::_tc_ReplyHandler, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void Messaging::ReplyHandler::_tao_any_destructor (void *x) +{ + Messaging::ReplyHandler *tmp = ACE_static_cast(Messaging::ReplyHandler*,x); + CORBA::release (tmp); } 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->equivalent (Messaging::_tc_ReplyHandler, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -3812,24 +3230,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::ReplyHandler_ { _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)->_tao_replace ( Messaging::_tc_ReplyHandler, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + Messaging::ReplyHandler::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = Messaging::ReplyHandler::_nil (); return 0; } @@ -3846,47 +3257,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::ReplyHandler_ void operator<<= (CORBA::Any &_tao_any, Messaging::Poller_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::Poller::_duplicate (_tao_elem); TAO_OutputCDR stream; - if (stream << *_tao_obj_ptr) + if (stream << _tao_elem) { _tao_any._tao_replace ( - Messaging::_tc_Poller, + Messaging::_tc_Poller, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_obj_ptr; } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void Messaging::Poller::_tao_any_destructor (void *x) +{ + Messaging::Poller *tmp = ACE_static_cast(Messaging::Poller*,x); + CORBA::release (tmp); } 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->equivalent (Messaging::_tc_Poller, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -3899,24 +3294,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::Poller_ptr &_ { _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)->_tao_replace ( Messaging::_tc_Poller, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + Messaging::Poller::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = Messaging::Poller::_nil (); return 0; } diff --git a/TAO/tao/MessagingC.h b/TAO/tao/MessagingC.h index 2b84fe64d57..5688d9ff7c2 100644 --- a/TAO/tao/MessagingC.h +++ b/TAO/tao/MessagingC.h @@ -189,6 +189,7 @@ TAO_NAMESPACE Messaging CORBA::Environment::default_environment () ); static RebindPolicy_ptr _nil (void); + static void _tao_any_destructor (void *); virtual RebindMode rebind_mode ( CORBA::Environment &ACE_TRY_ENV = @@ -282,6 +283,7 @@ TAO_NAMESPACE Messaging CORBA::Environment::default_environment () ); static SyncScopePolicy_ptr _nil (void); + static void _tao_any_destructor (void *); virtual SyncScope synchronization ( CORBA::Environment &ACE_TRY_ENV = @@ -311,6 +313,8 @@ TAO_NAMESPACE Messaging struct TAO_Export PriorityRange { + static void _tao_any_destructor (void *); + Priority min; Priority max; }; @@ -412,6 +416,7 @@ TAO_NAMESPACE Messaging CORBA::Environment::default_environment () ); static RequestPriorityPolicy_ptr _nil (void); + static void _tao_any_destructor (void *); virtual PriorityRange priority_range ( CORBA::Environment &ACE_TRY_ENV = @@ -505,6 +510,7 @@ TAO_NAMESPACE Messaging CORBA::Environment::default_environment () ); static ReplyPriorityPolicy_ptr _nil (void); + static void _tao_any_destructor (void *); virtual PriorityRange priority_range ( CORBA::Environment &ACE_TRY_ENV = @@ -598,6 +604,7 @@ TAO_NAMESPACE Messaging CORBA::Environment::default_environment () ); static RequestStartTimePolicy_ptr _nil (void); + static void _tao_any_destructor (void *); virtual TimeBase::UtcT start_time ( CORBA::Environment &ACE_TRY_ENV = @@ -691,6 +698,7 @@ TAO_NAMESPACE Messaging CORBA::Environment::default_environment () ); static RequestEndTimePolicy_ptr _nil (void); + static void _tao_any_destructor (void *); virtual TimeBase::UtcT end_time ( CORBA::Environment &ACE_TRY_ENV = @@ -784,6 +792,7 @@ TAO_NAMESPACE Messaging CORBA::Environment::default_environment () ); static ReplyStartTimePolicy_ptr _nil (void); + static void _tao_any_destructor (void *); virtual TimeBase::UtcT start_time ( CORBA::Environment &ACE_TRY_ENV = @@ -877,6 +886,7 @@ TAO_NAMESPACE Messaging CORBA::Environment::default_environment () ); static ReplyEndTimePolicy_ptr _nil (void); + static void _tao_any_destructor (void *); virtual TimeBase::UtcT end_time ( CORBA::Environment &ACE_TRY_ENV = @@ -970,6 +980,7 @@ TAO_NAMESPACE Messaging CORBA::Environment::default_environment () ); static RelativeRequestTimeoutPolicy_ptr _nil (void); + static void _tao_any_destructor (void *); virtual TimeBase::TimeT relative_expiry ( CORBA::Environment &ACE_TRY_ENV = @@ -1063,6 +1074,7 @@ TAO_NAMESPACE Messaging CORBA::Environment::default_environment () ); static RelativeRoundtripTimeoutPolicy_ptr _nil (void); + static void _tao_any_destructor (void *); virtual TimeBase::TimeT relative_expiry ( CORBA::Environment &ACE_TRY_ENV = @@ -1092,6 +1104,8 @@ TAO_NAMESPACE Messaging struct TAO_Export RoutingTypeRange { + static void _tao_any_destructor (void *); + RoutingType min; RoutingType max; }; @@ -1193,6 +1207,7 @@ TAO_NAMESPACE Messaging CORBA::Environment::default_environment () ); static RoutingPolicy_ptr _nil (void); + static void _tao_any_destructor (void *); virtual RoutingTypeRange routing_range ( CORBA::Environment &ACE_TRY_ENV = @@ -1286,6 +1301,7 @@ TAO_NAMESPACE Messaging CORBA::Environment::default_environment () ); static MaxHopsPolicy_ptr _nil (void); + static void _tao_any_destructor (void *); virtual CORBA::UShort max_hops ( CORBA::Environment &ACE_TRY_ENV = @@ -1379,6 +1395,7 @@ TAO_NAMESPACE Messaging CORBA::Environment::default_environment () ); static QueueOrderPolicy_ptr _nil (void); + static void _tao_any_destructor (void *); virtual Ordering allowed_orders ( CORBA::Environment &ACE_TRY_ENV = @@ -1406,6 +1423,8 @@ TAO_NAMESPACE Messaging struct TAO_Export PolicyValue { + static void _tao_any_destructor (void *); + CORBA::PolicyType ptype; // ************************************************************* @@ -1505,6 +1524,8 @@ TAO_NAMESPACE Messaging ); PolicyValueSeq (const PolicyValueSeq &); // copy ctor ~PolicyValueSeq (void); // dtor + + static void _tao_any_destructor (void *); }; typedef PolicyValueSeq *PolicyValueSeq_ptr; @@ -1876,6 +1897,7 @@ TAO_NAMESPACE Messaging CORBA::Environment::default_environment () ); static ReplyHandler_ptr _nil (void); + static void _tao_any_destructor (void *); virtual CORBA::Boolean _is_a ( const CORBA::Char *type_id, @@ -1967,6 +1989,7 @@ TAO_NAMESPACE Messaging CORBA::Environment::default_environment () ); static Poller_ptr _nil (void); + static void _tao_any_destructor (void *); virtual CORBA::Object_ptr operation_target ( CORBA::Environment &ACE_TRY_ENV = diff --git a/TAO/tao/MessagingS.cpp b/TAO/tao/MessagingS.cpp index b177dca761f..cc3f5ef80e7 100644 --- a/TAO/tao/MessagingS.cpp +++ b/TAO/tao/MessagingS.cpp @@ -2179,37 +2179,27 @@ void POA_Messaging::Poller::_get_op_name_skel ( } void POA_Messaging::Poller::_is_a_skel ( - CORBA::ServerRequest &_tao_server_request, - void * _tao_object_reference, - void * /*context*/, - CORBA::Environment &ACE_TRY_ENV - ) + CORBA::ServerRequest &_tao_server_request, + void * _tao_object_reference, + void * /*context*/, + CORBA::Environment &ACE_TRY_ENV + ) { - static const TAO_Param_Data_Skel Messaging_Poller_is_a_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0}, - {CORBA::_tc_string, CORBA::ARG_IN, 0} - }; - static const TAO_Call_Data_Skel Messaging_Poller_is_a_calldata = - {"_is_a", 1, 2, Messaging_Poller_is_a_paramdata}; - POA_Messaging::Poller_ptr _tao_impl = (POA_Messaging::Poller_ptr) _tao_object_reference; - CORBA::Boolean _tao_retval; - CORBA::String_var _tao_value; - _tao_server_request.demarshal ( - ACE_TRY_ENV, - &Messaging_Poller_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_Messaging::Poller *_tao_impl = (POA_Messaging::Poller *) _tao_object_reference; + CORBA::Boolean _tao_retval = 0; + CORBA::String_var value; + if (!((_tao_in >> value.out ()))) + ACE_THROW (CORBA::MARSHAL ()); + + _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV); ACE_CHECK; - _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV); + + _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &Messaging_Poller_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } CORBA::Boolean POA_Messaging::Poller::_is_a ( @@ -2227,24 +2217,21 @@ CORBA::Boolean POA_Messaging::Poller::_is_a ( } void POA_Messaging::Poller::_non_existent_skel ( - CORBA::ServerRequest &_tao_server_request, - void * /* _tao_object_reference */ , - void * /*context*/, - CORBA::Environment &ACE_TRY_ENV - ) + CORBA::ServerRequest &_tao_server_request, + void * _tao_object_reference , + void * /*context*/, + CORBA::Environment &ACE_TRY_ENV + ) { - static const TAO_Param_Data_Skel Messaging_Poller_non_existent_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0} - }; - static const TAO_Call_Data_Skel Messaging_Poller_non_existent_calldata = - {"_non_existent", 1, 1, Messaging_Poller_non_existent_paramdata}; - CORBA::Boolean _tao_retval = 0; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &Messaging_Poller_non_existent_calldata, - &_tao_retval - ); + POA_Messaging::Poller *_tao_impl = (POA_Messaging::Poller *) _tao_object_reference; + CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV); + ACE_CHECK; + + _tao_server_request.init_reply (ACE_TRY_ENV); + ACE_CHECK; + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } void* POA_Messaging::Poller::_downcast ( diff --git a/TAO/tao/NVList.cpp b/TAO/tao/NVList.cpp index 90baedd7f5b..adbdc22bed2 100644 --- a/TAO/tao/NVList.cpp +++ b/TAO/tao/NVList.cpp @@ -9,6 +9,7 @@ #include "tao/Exception.h" #include "tao/Environment.h" #include "tao/ORB.h" +#include "tao/BoundsC.h" #include "tao/debug.h" #include "ace/Auto_Ptr.h" @@ -148,21 +149,9 @@ CORBA_NVList::add_value (const char *name, // The normal behaviour for parameters is that the ORB "borrows" // their memory for the duration of calls. // - if (value.value_) - { - nv->any_.replace (value.type_, - value.value_, - 0, - ACE_TRY_ENV); - } - else - { - nv->any_._tao_replace (value.type_, - value.byte_order_, - value.cdr_, - ACE_TRY_ENV); - } - ACE_CHECK_RETURN (0); + nv->any_._tao_replace (value.type_, + value.byte_order_, + value.cdr_); } return nv; } @@ -265,7 +254,7 @@ CORBA_NVList::item (CORBA::ULong n, CORBA::Environment &ACE_TRY_ENV) ACE_CHECK_RETURN (CORBA::NamedValue::_nil ()); if (n >= this->max_) // 0 based indexing - ACE_THROW_RETURN (CORBA::TypeCode::Bounds (), 0); + ACE_THROW_RETURN (CORBA::Bounds (), 0); CORBA::NamedValue_ptr *nv; diff --git a/TAO/tao/Object.cpp b/TAO/tao/Object.cpp index a4bbfc1fd80..dfb2fbfa7bb 100644 --- a/TAO/tao/Object.cpp +++ b/TAO/tao/Object.cpp @@ -20,7 +20,6 @@ #include "tao/InterfaceC.h" #endif /* TAO_HAS_INTERFACE_REPOSITORY == 1 */ - #include "ace/Auto_Ptr.h" #if !defined (__ACE_INLINE__) @@ -49,6 +48,13 @@ CORBA_Object::CORBA_Object (TAO_Stub *protocol_proxy, // implicitly takes a reference. } +void +CORBA_Object::_tao_any_destructor (void *x) +{ + CORBA_Object_ptr tmp = ACE_static_cast(CORBA_Object_ptr,x); + CORBA::release (tmp); +} + // IS_A ... ask the object if it's an instance of the type whose // logical type ID is passed as a parameter. diff --git a/TAO/tao/Object.h b/TAO/tao/Object.h index d3a35d7e4c8..e7939093ef2 100644 --- a/TAO/tao/Object.h +++ b/TAO/tao/Object.h @@ -55,6 +55,9 @@ public: TAO_default_environment ()); // no-op it is just here to simplify some templates. + static void _tao_any_destructor (void*); + // Used in the implementation of CORBA::Any + // These calls correspond to over-the-wire operations, or at least // do so in many common cases. The normal implementation assumes a // particular simple, efficient, protocol-neutral interface for diff --git a/TAO/tao/ObjectIDList.cpp b/TAO/tao/ObjectIDList.cpp index 4432a72ec46..23e3e73b4b1 100644 --- a/TAO/tao/ObjectIDList.cpp +++ b/TAO/tao/ObjectIDList.cpp @@ -86,19 +86,12 @@ void operator<<= ( const CORBA_ORB_ObjectIdList &_tao_elem ) // copying { - CORBA_ORB_ObjectIdList *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA_ORB_ObjectIdList (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { - _tao_any.replace (CORBA::ORB::_tc_ObjectIdList, _tao_any_val, 1, ACE_TRY_ENV); // copy the value - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; + TAO_OutputCDR stream; + stream << _tao_elem; + + _tao_any._tao_replace (CORBA::ORB::_tc_ObjectIdList, + TAO_ENCAP_BYTE_ORDER, + stream.begin ()); } CORBA::Boolean @@ -135,15 +128,23 @@ operator>> (TAO_InputCDR &strm, CORBA_ORB_ObjectIdList &_tao_sequence) return 0; // error } -void operator<<= (CORBA::Any &_tao_any, CORBA_ORB_ObjectIdList *_tao_elem) // non copying +void CORBA_ORB_ObjectIdList::_tao_any_destructor (void *x) { - ACE_TRY_NEW_ENV - { - _tao_any.replace (CORBA::ORB::_tc_ObjectIdList, _tao_elem, 0, ACE_TRY_ENV); - ACE_TRY_CHECK; - } - ACE_CATCHANY {} - ACE_ENDTRY; + CORBA_ORB_ObjectIdList *tmp = ACE_static_cast(CORBA_ORB_ObjectIdList*,x); + delete tmp; +} + +void operator<<= (CORBA::Any &_tao_any, CORBA_ORB_ObjectIdList *_tao_elem) +{ + TAO_OutputCDR stream; + stream << *_tao_elem; + + _tao_any._tao_replace (CORBA::ORB::_tc_ObjectIdList, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + CORBA_ORB_ObjectIdList::_tao_any_destructor); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_ORB_ObjectIdList *&_tao_elem) @@ -163,11 +164,13 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_ORB_ObjectIdList * ACE_NEW_RETURN (_tao_elem, CORBA_ORB_ObjectIdList, 0); TAO_InputCDR stream (_tao_any._tao_get_cdr (), _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::ORB::_tc_ObjectIdList, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + if (stream >> *_tao_elem) { - ((CORBA::Any *)&_tao_any)->replace (CORBA::ORB::_tc_ObjectIdList, _tao_elem, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::ORB::_tc_ObjectIdList, + 1, + _tao_elem, + CORBA_ORB_ObjectIdList::_tao_any_destructor); return 1; } else diff --git a/TAO/tao/ObjectIDList.h b/TAO/tao/ObjectIDList.h index 1a96afa5ce1..3ccd57a2776 100644 --- a/TAO/tao/ObjectIDList.h +++ b/TAO/tao/ObjectIDList.h @@ -59,6 +59,8 @@ public: ); CORBA_ORB_ObjectIdList (const CORBA_ORB_ObjectIdList &); // copy ctor ~CORBA_ORB_ObjectIdList (void); // dtor + + static void _tao_any_destructor (void*); }; typedef CORBA_ORB_ObjectIdList *CORBA_ORB_ObjectIdList_ptr; @@ -127,14 +129,9 @@ private: #endif /* end #if !defined */ -#ifndef __ACE_INLINE__ - TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA_ORB_ObjectIdList &); // TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA_ORB_ObjectIdList &); -#endif /* __ACE_INLINE__ */ - - #if defined (__ACE_INLINE__) #include "tao/ObjectIDList.i" #endif /* defined INLINE */ diff --git a/TAO/tao/POAC.cpp b/TAO/tao/POAC.cpp index 4e338028c65..c578c0b354e 100644 --- a/TAO/tao/POAC.cpp +++ b/TAO/tao/POAC.cpp @@ -147,34 +147,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)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_tao_any_val; + stream << _tao_elem; _tao_any._tao_replace ( PortableServer::_tc_ForwardRequest, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void PortableServer::ForwardRequest::_tao_any_destructor (void *x) +{ + PortableServer::ForwardRequest *tmp = ACE_static_cast(PortableServer::ForwardRequest*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, PortableServer::ForwardRequest *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -183,16 +172,8 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::ForwardRequest *_tao_ele stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + PortableServer::ForwardRequest::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ForwardRequest *&_tao_elem) @@ -224,9 +205,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ForwardR PortableServer::_tc_ForwardRequest, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + PortableServer::ForwardRequest::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -275,9 +255,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::Fo PortableServer::_tc_ForwardRequest, 1, ACE_reinterpret_cast (void *, ACE_const_cast (PortableServer::ForwardRequest *&, _tao_elem)), - ACE_TRY_ENV + PortableServer::ForwardRequest::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -3204,40 +3183,19 @@ void operator<<= ( 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( PortableServer::_tc_ObjectId, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - 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 ( @@ -3246,16 +3204,8 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::ObjectId *_tao_elem) // stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + PortableServer::ObjectId::_tao_any_destructor ); - 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) @@ -3287,9 +3237,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ObjectId PortableServer::_tc_ObjectId, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + PortableServer::ObjectId::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -3338,9 +3287,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::Ob PortableServer::_tc_ObjectId, 1, ACE_reinterpret_cast (void *, ACE_const_cast (PortableServer::ObjectId *&, _tao_elem)), - ACE_TRY_ENV + PortableServer::ObjectId::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -3364,29 +3312,13 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::Ob 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; + stream << _tao_elem; _tao_any._tao_replace ( PortableServer::_tc_ThreadPolicyValue, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - 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) @@ -3418,47 +3350,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ThreadPo 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( PortableServer::_tc_ThreadPolicy, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void PortableServer::ThreadPolicy::_tao_any_destructor (void *x) +{ + PortableServer::ThreadPolicy *tmp = ACE_static_cast(PortableServer::ThreadPolicy*,x); + CORBA::release (tmp); } 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; @@ -3471,24 +3387,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ThreadPo { _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 + _tao_elem, + PortableServer::ThreadPolicy::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = PortableServer::ThreadPolicy::_nil (); return 0; } @@ -3501,29 +3410,13 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ThreadPo 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; + stream << _tao_elem; _tao_any._tao_replace ( PortableServer::_tc_LifespanPolicyValue, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - 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) @@ -3555,47 +3448,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::Lifespan 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( PortableServer::_tc_LifespanPolicy, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void PortableServer::LifespanPolicy::_tao_any_destructor (void *x) +{ + PortableServer::LifespanPolicy *tmp = ACE_static_cast(PortableServer::LifespanPolicy*,x); + CORBA::release (tmp); } 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; @@ -3608,24 +3485,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::Lifespan { _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 + _tao_elem, + PortableServer::LifespanPolicy::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = PortableServer::LifespanPolicy::_nil (); return 0; } @@ -3636,29 +3506,13 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::Lifespan 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; + stream << _tao_elem; _tao_any._tao_replace ( PortableServer::_tc_IdUniquenessPolicyValue, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - 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) @@ -3690,47 +3544,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::IdUnique 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( PortableServer::_tc_IdUniquenessPolicy, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_obj_ptr; } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void PortableServer::IdUniquenessPolicy::_tao_any_destructor (void *x) +{ + PortableServer::IdUniquenessPolicy *tmp = ACE_static_cast(PortableServer::IdUniquenessPolicy*,x); + CORBA::release (tmp); } 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; @@ -3743,24 +3581,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::IdUnique { _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 + _tao_elem, + PortableServer::IdUniquenessPolicy::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = PortableServer::IdUniquenessPolicy::_nil (); return 0; } @@ -3771,29 +3602,13 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::IdUnique 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; + stream << _tao_elem; _tao_any._tao_replace ( PortableServer::_tc_IdAssignmentPolicyValue, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - 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) @@ -3825,47 +3640,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::IdAssign 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( PortableServer::_tc_IdAssignmentPolicy, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_obj_ptr; } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void PortableServer::IdAssignmentPolicy::_tao_any_destructor (void *x) +{ + PortableServer::IdAssignmentPolicy *tmp = ACE_static_cast(PortableServer::IdAssignmentPolicy*,x); + CORBA::release (tmp); } 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; @@ -3878,24 +3677,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::IdAssign { _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 + _tao_elem, + PortableServer::IdAssignmentPolicy::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = PortableServer::IdAssignmentPolicy::_nil (); return 0; } @@ -3908,29 +3700,13 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::IdAssign 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; + stream << _tao_elem; _tao_any._tao_replace ( PortableServer::_tc_ImplicitActivationPolicyValue, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - 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) @@ -3962,47 +3738,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::Implicit 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( PortableServer::_tc_ImplicitActivationPolicy, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void PortableServer::ImplicitActivationPolicy::_tao_any_destructor (void *x) +{ + PortableServer::ImplicitActivationPolicy *tmp = ACE_static_cast(PortableServer::ImplicitActivationPolicy*,x); + CORBA::release (tmp); } 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; @@ -4015,24 +3775,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::Implicit { _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 + _tao_elem, + PortableServer::ImplicitActivationPolicy::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = PortableServer::ImplicitActivationPolicy::_nil (); return 0; } @@ -4043,29 +3796,13 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::Implicit 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; + stream << _tao_elem; _tao_any._tao_replace ( PortableServer::_tc_ServantRetentionPolicyValue, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - 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) @@ -4097,47 +3834,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ServantR 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( PortableServer::_tc_ServantRetentionPolicy, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void PortableServer::ServantRetentionPolicy::_tao_any_destructor (void *x) +{ + PortableServer::ServantRetentionPolicy *tmp = ACE_static_cast(PortableServer::ServantRetentionPolicy*,x); + CORBA::release (tmp); } 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; @@ -4150,24 +3871,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ServantR { _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 + _tao_elem, + PortableServer::ServantRetentionPolicy::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = PortableServer::ServantRetentionPolicy::_nil (); return 0; } @@ -4178,29 +3892,13 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ServantR 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; + stream << _tao_elem; _tao_any._tao_replace ( PortableServer::_tc_RequestProcessingPolicyValue, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - 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) @@ -4232,47 +3930,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::RequestP 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( PortableServer::_tc_RequestProcessingPolicy, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_obj_ptr; } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void PortableServer::RequestProcessingPolicy::_tao_any_destructor (void *x) +{ + PortableServer::RequestProcessingPolicy *tmp = ACE_static_cast(PortableServer::RequestProcessingPolicy*,x); + CORBA::release (tmp); } 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; @@ -4285,24 +3967,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::RequestP { _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 + _tao_elem, + PortableServer::RequestProcessingPolicy::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = PortableServer::RequestProcessingPolicy::_nil (); return 0; } @@ -4315,34 +3990,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::RequestP 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; + stream << _tao_elem; _tao_any._tao_replace ( PortableServer::POA::_tc_AdapterAlreadyExists, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void PortableServer::POA::AdapterAlreadyExists::_tao_any_destructor (void *x) +{ + PortableServer::POA::AdapterAlreadyExists *tmp = ACE_static_cast(PortableServer::POA::AdapterAlreadyExists*,x); + delete tmp; } 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 ( @@ -4351,16 +4015,8 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::POA::AdapterAlreadyExist stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + PortableServer::POA::AdapterAlreadyExists::_tao_any_destructor ); - 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) @@ -4392,9 +4048,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Ada PortableServer::POA::_tc_AdapterAlreadyExists, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + PortableServer::POA::AdapterAlreadyExists::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -4443,9 +4098,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO PortableServer::POA::_tc_AdapterAlreadyExists, 1, ACE_reinterpret_cast (void *, ACE_const_cast (PortableServer::POA::AdapterAlreadyExists *&, _tao_elem)), - ACE_TRY_ENV + PortableServer::POA::AdapterAlreadyExists::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -4469,34 +4123,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO 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; + stream << _tao_elem; _tao_any._tao_replace ( PortableServer::POA::_tc_AdapterInactive, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void PortableServer::POA::AdapterInactive::_tao_any_destructor (void *x) +{ + PortableServer::POA::AdapterInactive *tmp = ACE_static_cast(PortableServer::POA::AdapterInactive*,x); + delete tmp; } 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 ( @@ -4505,16 +4148,8 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::POA::AdapterInactive *_t stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + PortableServer::POA::AdapterInactive::_tao_any_destructor ); - 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) @@ -4546,9 +4181,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Ada PortableServer::POA::_tc_AdapterInactive, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + PortableServer::POA::AdapterInactive::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -4597,9 +4231,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO PortableServer::POA::_tc_AdapterInactive, 1, ACE_reinterpret_cast (void *, ACE_const_cast (PortableServer::POA::AdapterInactive *&, _tao_elem)), - ACE_TRY_ENV + PortableServer::POA::AdapterInactive::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -4623,34 +4256,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO 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; + stream << _tao_elem; _tao_any._tao_replace ( PortableServer::POA::_tc_AdapterNonExistent, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void PortableServer::POA::AdapterNonExistent::_tao_any_destructor (void *x) +{ + PortableServer::POA::AdapterNonExistent *tmp = ACE_static_cast(PortableServer::POA::AdapterNonExistent*,x); + delete tmp; } 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 ( @@ -4659,16 +4281,8 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::POA::AdapterNonExistent stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + PortableServer::POA::AdapterNonExistent::_tao_any_destructor ); - 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) @@ -4700,9 +4314,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Ada PortableServer::POA::_tc_AdapterNonExistent, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + PortableServer::POA::AdapterNonExistent::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -4751,9 +4364,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO PortableServer::POA::_tc_AdapterNonExistent, 1, ACE_reinterpret_cast (void *, ACE_const_cast (PortableServer::POA::AdapterNonExistent *&, _tao_elem)), - ACE_TRY_ENV + PortableServer::POA::AdapterNonExistent::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -4775,34 +4387,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO 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; + stream << _tao_elem; _tao_any._tao_replace ( PortableServer::POA::_tc_InvalidPolicy, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void PortableServer::POA::InvalidPolicy::_tao_any_destructor (void *x) +{ + PortableServer::POA::InvalidPolicy *tmp = ACE_static_cast(PortableServer::POA::InvalidPolicy*,x); + delete tmp; } 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 ( @@ -4811,16 +4412,8 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::POA::InvalidPolicy *_tao stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + PortableServer::POA::InvalidPolicy::_tao_any_destructor ); - 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) @@ -4852,9 +4445,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Inv PortableServer::POA::_tc_InvalidPolicy, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + PortableServer::POA::InvalidPolicy::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -4903,9 +4495,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO PortableServer::POA::_tc_InvalidPolicy, 1, ACE_reinterpret_cast (void *, ACE_const_cast (PortableServer::POA::InvalidPolicy *&, _tao_elem)), - ACE_TRY_ENV + PortableServer::POA::InvalidPolicy::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -4929,34 +4520,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO 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; + stream << _tao_elem; _tao_any._tao_replace ( PortableServer::POA::_tc_NoServant, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void PortableServer::POA::NoServant::_tao_any_destructor (void *x) +{ + PortableServer::POA::NoServant *tmp = ACE_static_cast(PortableServer::POA::NoServant*,x); + delete tmp; } 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 ( @@ -4965,16 +4545,8 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::POA::NoServant *_tao_ele stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + PortableServer::POA::NoServant::_tao_any_destructor ); - 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) @@ -5006,9 +4578,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::NoS PortableServer::POA::_tc_NoServant, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + PortableServer::POA::NoServant::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -5057,9 +4628,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO PortableServer::POA::_tc_NoServant, 1, ACE_reinterpret_cast (void *, ACE_const_cast (PortableServer::POA::NoServant *&, _tao_elem)), - ACE_TRY_ENV + PortableServer::POA::NoServant::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -5083,34 +4653,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO 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; + stream << _tao_elem; _tao_any._tao_replace ( PortableServer::POA::_tc_ObjectAlreadyActive, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void PortableServer::POA::ObjectAlreadyActive::_tao_any_destructor (void *x) +{ + PortableServer::POA::ObjectAlreadyActive *tmp = ACE_static_cast(PortableServer::POA::ObjectAlreadyActive*,x); + delete tmp; } 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 ( @@ -5119,77 +4678,23 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::POA::ObjectAlreadyActive stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + PortableServer::POA::ObjectAlreadyActive::_tao_any_destructor ); - 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; + return _tao_any >>= ACE_const_cast(const PortableServer::POA::ObjectAlreadyActive *&,_tao_elem); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::POA::ObjectAlreadyActive *&_tao_elem) { + _tao_elem = 0; 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; @@ -5200,34 +4705,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO } else { - ACE_NEW_RETURN (_tao_elem, PortableServer::POA::ObjectAlreadyActive, 0); + PortableServer::POA::ObjectAlreadyActive *tmp; + ACE_NEW_RETURN (tmp, PortableServer::POA::ObjectAlreadyActive, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); - if (stream >> *(PortableServer::POA::ObjectAlreadyActive *)_tao_elem) + if (stream >> *tmp) { ((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_reinterpret_cast (void *, tmp), + PortableServer::POA::ObjectAlreadyActive::_tao_any_destructor ); - ACE_TRY_CHECK; + _tao_elem = tmp; return 1; } else { - delete ACE_const_cast (PortableServer::POA::ObjectAlreadyActive *&, _tao_elem); - _tao_elem = 0; + delete tmp; } } } ACE_CATCHANY { - delete ACE_const_cast (PortableServer::POA::ObjectAlreadyActive *&, _tao_elem); - _tao_elem = 0; - return 0; } ACE_ENDTRY; return 0; @@ -5235,34 +4737,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO 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; + stream << _tao_elem; _tao_any._tao_replace ( PortableServer::POA::_tc_ObjectNotActive, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void PortableServer::POA::ObjectNotActive::_tao_any_destructor (void *x) +{ + PortableServer::POA::ObjectNotActive *tmp = ACE_static_cast(PortableServer::POA::ObjectNotActive*,x); + delete tmp; } 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 ( @@ -5271,77 +4762,23 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::POA::ObjectNotActive *_t stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + PortableServer::POA::ObjectNotActive::_tao_any_destructor ); - 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; + return _tao_any >>= ACE_const_cast(const PortableServer::POA::ObjectNotActive *&,_tao_elem); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::POA::ObjectNotActive *&_tao_elem) { + _tao_elem = 0; 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; @@ -5352,34 +4789,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO } else { - ACE_NEW_RETURN (_tao_elem, PortableServer::POA::ObjectNotActive, 0); + PortableServer::POA::ObjectNotActive *tmp; + ACE_NEW_RETURN (tmp, PortableServer::POA::ObjectNotActive, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); - if (stream >> *(PortableServer::POA::ObjectNotActive *)_tao_elem) + if (stream >> *tmp) { ((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_reinterpret_cast (void *, tmp), + PortableServer::POA::ObjectNotActive::_tao_any_destructor ); - ACE_TRY_CHECK; + _tao_elem = tmp; return 1; } else { - delete ACE_const_cast (PortableServer::POA::ObjectNotActive *&, _tao_elem); - _tao_elem = 0; + delete tmp; } } } ACE_CATCHANY { - delete ACE_const_cast (PortableServer::POA::ObjectNotActive *&, _tao_elem); - _tao_elem = 0; - return 0; } ACE_ENDTRY; return 0; @@ -5387,34 +4821,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO 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; + stream << _tao_elem; _tao_any._tao_replace ( PortableServer::POA::_tc_ServantAlreadyActive, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void PortableServer::POA::ServantAlreadyActive::_tao_any_destructor (void *x) +{ + PortableServer::POA::ServantAlreadyActive *tmp = ACE_static_cast(PortableServer::POA::ServantAlreadyActive*,x); + delete tmp; } 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 ( @@ -5423,77 +4846,23 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::POA::ServantAlreadyActiv stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + PortableServer::POA::ServantAlreadyActive::_tao_any_destructor ); - 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; + return _tao_any >>= ACE_const_cast(const PortableServer::POA::ServantAlreadyActive *&,_tao_elem); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::POA::ServantAlreadyActive *&_tao_elem) { + _tao_elem = 0; 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; @@ -5504,34 +4873,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO } else { - ACE_NEW_RETURN (_tao_elem, PortableServer::POA::ServantAlreadyActive, 0); + PortableServer::POA::ServantAlreadyActive *tmp; + ACE_NEW_RETURN (tmp, PortableServer::POA::ServantAlreadyActive, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); - if (stream >> *(PortableServer::POA::ServantAlreadyActive *)_tao_elem) + if (stream >> *tmp) { ((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_reinterpret_cast (void *, tmp), + PortableServer::POA::ServantAlreadyActive::_tao_any_destructor ); - ACE_TRY_CHECK; + _tao_elem = tmp; return 1; } else { - delete ACE_const_cast (PortableServer::POA::ServantAlreadyActive *&, _tao_elem); - _tao_elem = 0; + delete tmp; } } } ACE_CATCHANY { - delete ACE_const_cast (PortableServer::POA::ServantAlreadyActive *&, _tao_elem); - _tao_elem = 0; - return 0; } ACE_ENDTRY; return 0; @@ -5539,34 +4905,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO 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; + stream << _tao_elem; _tao_any._tao_replace ( PortableServer::POA::_tc_ServantNotActive, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void PortableServer::POA::ServantNotActive::_tao_any_destructor (void *x) +{ + PortableServer::POA::ServantNotActive *tmp = ACE_static_cast(PortableServer::POA::ServantNotActive*,x); + delete tmp; } 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 ( @@ -5575,77 +4930,23 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::POA::ServantNotActive *_ stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + PortableServer::POA::ServantNotActive::_tao_any_destructor ); - 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; + return _tao_any >>= ACE_const_cast(const PortableServer::POA::ServantNotActive *&,_tao_elem); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::POA::ServantNotActive *&_tao_elem) { + _tao_elem = 0; 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; @@ -5656,34 +4957,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO } else { - ACE_NEW_RETURN (_tao_elem, PortableServer::POA::ServantNotActive, 0); + PortableServer::POA::ServantNotActive *tmp; + ACE_NEW_RETURN (tmp, PortableServer::POA::ServantNotActive, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); - if (stream >> *(PortableServer::POA::ServantNotActive *)_tao_elem) + if (stream >> *tmp) { ((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_reinterpret_cast (void *, tmp), + PortableServer::POA::ServantNotActive::_tao_any_destructor ); - ACE_TRY_CHECK; + _tao_elem = tmp; return 1; } else { - delete ACE_const_cast (PortableServer::POA::ServantNotActive *&, _tao_elem); - _tao_elem = 0; + delete tmp; } } } ACE_CATCHANY { - delete ACE_const_cast (PortableServer::POA::ServantNotActive *&, _tao_elem); - _tao_elem = 0; - return 0; } ACE_ENDTRY; return 0; @@ -5691,34 +4989,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO 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; + stream << _tao_elem; _tao_any._tao_replace ( PortableServer::POA::_tc_WrongAdapter, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void PortableServer::POA::WrongAdapter::_tao_any_destructor (void *x) +{ + PortableServer::POA::WrongAdapter *tmp = ACE_static_cast(PortableServer::POA::WrongAdapter*,x); + delete tmp; } 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 ( @@ -5727,77 +5014,23 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::POA::WrongAdapter *_tao_ stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + PortableServer::POA::WrongAdapter::_tao_any_destructor ); - 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; + return _tao_any >>= ACE_const_cast(const PortableServer::POA::WrongAdapter *&,_tao_elem); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::POA::WrongAdapter *&_tao_elem) { + _tao_elem = 0; 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; @@ -5808,34 +5041,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO } else { - ACE_NEW_RETURN (_tao_elem, PortableServer::POA::WrongAdapter, 0); + PortableServer::POA::WrongAdapter *tmp; + ACE_NEW_RETURN (tmp, PortableServer::POA::WrongAdapter, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); - if (stream >> *(PortableServer::POA::WrongAdapter *)_tao_elem) + if (stream >> *tmp) { ((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_reinterpret_cast (void *, tmp), + PortableServer::POA::WrongAdapter::_tao_any_destructor ); - ACE_TRY_CHECK; + _tao_elem = tmp; return 1; } else { - delete ACE_const_cast (PortableServer::POA::WrongAdapter *&, _tao_elem); - _tao_elem = 0; + delete tmp; } } } ACE_CATCHANY { - delete ACE_const_cast (PortableServer::POA::WrongAdapter *&, _tao_elem); - _tao_elem = 0; - return 0; } ACE_ENDTRY; return 0; @@ -5843,34 +5073,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO 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; + stream << _tao_elem; _tao_any._tao_replace ( PortableServer::POA::_tc_WrongPolicy, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void PortableServer::POA::WrongPolicy::_tao_any_destructor (void *x) +{ + PortableServer::POA::WrongPolicy *tmp = ACE_static_cast(PortableServer::POA::WrongPolicy*,x); + delete tmp; } 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 ( @@ -5879,77 +5098,23 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::POA::WrongPolicy *_tao_e stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + PortableServer::POA::WrongPolicy::_tao_any_destructor ); - 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; + return _tao_any >>= ACE_const_cast(const PortableServer::POA::WrongPolicy *&,_tao_elem); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::POA::WrongPolicy *&_tao_elem) { + _tao_elem = 0; 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; @@ -5960,34 +5125,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO } else { - ACE_NEW_RETURN (_tao_elem, PortableServer::POA::WrongPolicy, 0); + PortableServer::POA::WrongPolicy *tmp; + ACE_NEW_RETURN (tmp, PortableServer::POA::WrongPolicy, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); - if (stream >> *(PortableServer::POA::WrongPolicy *)_tao_elem) + if (stream >> *tmp) { ((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_reinterpret_cast (void *, tmp), + PortableServer::POA::WrongPolicy::_tao_any_destructor ); - ACE_TRY_CHECK; + _tao_elem = tmp; return 1; } else { - delete ACE_const_cast (PortableServer::POA::WrongPolicy *&, _tao_elem); - _tao_elem = 0; + delete tmp; } } } ACE_CATCHANY { - delete ACE_const_cast (PortableServer::POA::WrongPolicy *&, _tao_elem); - _tao_elem = 0; - return 0; } ACE_ENDTRY; return 0; @@ -5995,34 +5157,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO 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; + stream << _tao_elem; _tao_any._tao_replace ( PortableServer::Current::_tc_NoContext, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void PortableServer::Current::NoContext::_tao_any_destructor (void *x) +{ + PortableServer::Current::NoContext *tmp = ACE_static_cast(PortableServer::Current::NoContext*,x); + delete tmp; } 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 ( @@ -6031,77 +5182,23 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::Current::NoContext *_tao stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + PortableServer::Current::NoContext::_tao_any_destructor ); - 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; + return _tao_any >>= ACE_const_cast(const PortableServer::Current::NoContext *&,_tao_elem); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::Current::NoContext *&_tao_elem) { + _tao_elem = 0; 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; @@ -6112,34 +5209,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::Cu } else { - ACE_NEW_RETURN (_tao_elem, PortableServer::Current::NoContext, 0); + PortableServer::Current::NoContext *tmp; + ACE_NEW_RETURN (tmp, PortableServer::Current::NoContext, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); - if (stream >> *(PortableServer::Current::NoContext *)_tao_elem) + if (stream >> *tmp) { ((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_reinterpret_cast (void *, tmp), + PortableServer::Current::NoContext::_tao_any_destructor ); - ACE_TRY_CHECK; + _tao_elem = tmp; return 1; } else { - delete ACE_const_cast (PortableServer::Current::NoContext *&, _tao_elem); - _tao_elem = 0; + delete tmp; } } } ACE_CATCHANY { - delete ACE_const_cast (PortableServer::Current::NoContext *&, _tao_elem); - _tao_elem = 0; - return 0; } ACE_ENDTRY; return 0; @@ -6147,47 +5241,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::Cu 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( PortableServer::_tc_Current, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void PortableServer::Current::_tao_any_destructor (void *x) +{ + PortableServer::Current *tmp = ACE_static_cast(PortableServer::Current*,x); + CORBA::release (tmp); } 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; @@ -6200,24 +5278,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::Current_ { _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 + _tao_elem, + PortableServer::Current::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = PortableServer::Current::_nil (); return 0; } @@ -6228,47 +5299,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::Current_ 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( PortableServer::_tc_POAManager, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void PortableServer::POAManager::_tao_any_destructor (void *x) +{ + PortableServer::POAManager *tmp = ACE_static_cast(PortableServer::POAManager*,x); + CORBA::release (tmp); } 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; @@ -6281,24 +5336,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POAManag { _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 + _tao_elem, + PortableServer::POAManager::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = PortableServer::POAManager::_nil (); return 0; } @@ -6309,29 +5357,13 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POAManag 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; + stream << _tao_elem; _tao_any._tao_replace ( PortableServer::POAManager::_tc_State, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - 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) @@ -6363,34 +5395,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POAManag 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; + stream << _tao_elem; _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; + stream.begin () + ); +} + +void PortableServer::POAManager::AdapterInactive::_tao_any_destructor (void *x) +{ + PortableServer::POAManager::AdapterInactive *tmp = ACE_static_cast(PortableServer::POAManager::AdapterInactive*,x); + delete tmp; } 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 ( @@ -6399,77 +5420,23 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::POAManager::AdapterInact stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + PortableServer::POAManager::AdapterInactive::_tao_any_destructor ); - 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; + return _tao_any >>= ACE_const_cast(const PortableServer::POAManager::AdapterInactive *&,_tao_elem); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::POAManager::AdapterInactive *&_tao_elem) { + _tao_elem = 0; 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; @@ -6480,34 +5447,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO } else { - ACE_NEW_RETURN (_tao_elem, PortableServer::POAManager::AdapterInactive, 0); + PortableServer::POAManager::AdapterInactive *tmp; + ACE_NEW_RETURN (tmp, PortableServer::POAManager::AdapterInactive, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () ); - if (stream >> *(PortableServer::POAManager::AdapterInactive *)_tao_elem) + if (stream >> *tmp) { ((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_reinterpret_cast (void *, tmp), + PortableServer::POAManager::AdapterInactive::_tao_any_destructor ); - ACE_TRY_CHECK; + _tao_elem = tmp; return 1; } else { - delete ACE_const_cast (PortableServer::POAManager::AdapterInactive *&, _tao_elem); - _tao_elem = 0; + delete tmp; } } } ACE_CATCHANY { - delete ACE_const_cast (PortableServer::POAManager::AdapterInactive *&, _tao_elem); - _tao_elem = 0; - return 0; } ACE_ENDTRY; return 0; @@ -6517,47 +5481,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( PortableServer::_tc_AdapterActivator, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_obj_ptr; } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void PortableServer::AdapterActivator::_tao_any_destructor (void *x) +{ + PortableServer::AdapterActivator *tmp = ACE_static_cast(PortableServer::AdapterActivator*,x); + CORBA::release (tmp); } 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; @@ -6570,24 +5518,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::AdapterA { _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 + _tao_elem, + PortableServer::AdapterActivator::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = PortableServer::AdapterActivator::_nil (); return 0; } @@ -6598,47 +5539,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::AdapterA 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( PortableServer::_tc_ServantLocator, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_obj_ptr; } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void PortableServer::ServantLocator::_tao_any_destructor (void *x) +{ + PortableServer::ServantLocator *tmp = ACE_static_cast(PortableServer::ServantLocator*,x); + CORBA::release (tmp); } 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; @@ -6651,24 +5576,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ServantL { _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 + _tao_elem, + PortableServer::ServantLocator::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = PortableServer::ServantLocator::_nil (); return 0; } @@ -6679,47 +5597,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ServantL 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( PortableServer::_tc_ServantManager, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_obj_ptr; } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void PortableServer::ServantManager::_tao_any_destructor (void *x) +{ + PortableServer::ServantManager *tmp = ACE_static_cast(PortableServer::ServantManager*,x); + CORBA::release (tmp); } 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; @@ -6732,24 +5634,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ServantM { _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 + _tao_elem, + PortableServer::ServantManager::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = PortableServer::ServantManager::_nil (); return 0; } @@ -6760,47 +5655,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ServantM 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( PortableServer::_tc_ServantActivator, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void PortableServer::ServantActivator::_tao_any_destructor (void *x) +{ + PortableServer::ServantActivator *tmp = ACE_static_cast(PortableServer::ServantActivator*,x); + CORBA::release (tmp); } 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; @@ -6813,24 +5692,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ServantA { _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 + _tao_elem, + PortableServer::ServantActivator::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = PortableServer::ServantActivator::_nil (); return 0; } @@ -6843,47 +5715,31 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ServantA 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( PortableServer::_tc_POA, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_obj_ptr, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_obj_ptr; } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; +} + +void PortableServer::POA::_tao_any_destructor (void *x) +{ + PortableServer::POA *tmp = ACE_static_cast(PortableServer::POA*,x); + CORBA::release (tmp); } 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; @@ -6896,24 +5752,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA_ptr { _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 + _tao_elem, + PortableServer::POA::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = PortableServer::POA::_nil (); return 0; } diff --git a/TAO/tao/POAC.h b/TAO/tao/POAC.h index 2d29219b805..714cb183b18 100644 --- a/TAO/tao/POAC.h +++ b/TAO/tao/POAC.h @@ -233,6 +233,7 @@ TAO_NAMESPACE PortableServer{ CORBA::Environment &); static ForwardRequest *_narrow (CORBA::Exception *); + static void _tao_any_destructor (void*); ForwardRequest( const CORBA::Object_ptr _tao_forward_reference @@ -358,6 +359,7 @@ TAO_NAMESPACE PortableServer{ static ThreadPolicy_ptr _duplicate (ThreadPolicy_ptr obj); static ThreadPolicy_ptr _narrow (CORBA::Object_ptr obj, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); static ThreadPolicy_ptr _nil (void); + static void _tao_any_destructor (void*); #if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES) virtual ThreadPolicyValue value (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); @@ -467,6 +469,7 @@ TAO_NAMESPACE PortableServer{ static LifespanPolicy_ptr _duplicate (LifespanPolicy_ptr obj); static LifespanPolicy_ptr _narrow (CORBA::Object_ptr obj, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); static LifespanPolicy_ptr _nil (void); + static void _tao_any_destructor (void*); #if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES) virtual LifespanPolicyValue value (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); @@ -576,6 +579,7 @@ TAO_NAMESPACE PortableServer{ static IdUniquenessPolicy_ptr _duplicate (IdUniquenessPolicy_ptr obj); static IdUniquenessPolicy_ptr _narrow (CORBA::Object_ptr obj, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); static IdUniquenessPolicy_ptr _nil (void); + static void _tao_any_destructor (void*); #if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES) virtual IdUniquenessPolicyValue value (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); @@ -685,6 +689,7 @@ TAO_NAMESPACE PortableServer{ static IdAssignmentPolicy_ptr _duplicate (IdAssignmentPolicy_ptr obj); static IdAssignmentPolicy_ptr _narrow (CORBA::Object_ptr obj, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); static IdAssignmentPolicy_ptr _nil (void); + static void _tao_any_destructor (void*); #if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES) virtual IdAssignmentPolicyValue value (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); @@ -797,6 +802,7 @@ TAO_NAMESPACE PortableServer{ static ImplicitActivationPolicy_ptr _duplicate (ImplicitActivationPolicy_ptr obj); static ImplicitActivationPolicy_ptr _narrow (CORBA::Object_ptr obj, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); static ImplicitActivationPolicy_ptr _nil (void); + static void _tao_any_destructor (void*); #if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES) virtual ImplicitActivationPolicyValue value (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); @@ -911,6 +917,7 @@ TAO_NAMESPACE PortableServer{ static ServantRetentionPolicy_ptr _duplicate (ServantRetentionPolicy_ptr obj); static ServantRetentionPolicy_ptr _narrow (CORBA::Object_ptr obj, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); static ServantRetentionPolicy_ptr _nil (void); + static void _tao_any_destructor (void*); #if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES) virtual ServantRetentionPolicyValue value (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); @@ -1026,6 +1033,7 @@ TAO_NAMESPACE PortableServer{ static RequestProcessingPolicy_ptr _duplicate (RequestProcessingPolicy_ptr obj); static RequestProcessingPolicy_ptr _narrow (CORBA::Object_ptr obj, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); static RequestProcessingPolicy_ptr _nil (void); + static void _tao_any_destructor (void*); #if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES) virtual RequestProcessingPolicyValue value (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); @@ -1136,6 +1144,7 @@ TAO_NAMESPACE PortableServer{ static POAManager_ptr _duplicate (POAManager_ptr obj); static POAManager_ptr _narrow (CORBA::Object_ptr obj, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); static POAManager_ptr _nil (void); + static void _tao_any_destructor (void*); #if !defined (_PORTABLESERVER_POAMANAGER_ADAPTERINACTIVE___PTR_CH_) @@ -1164,6 +1173,7 @@ TAO_NAMESPACE PortableServer{ CORBA::Environment &); static AdapterInactive *_narrow (CORBA::Exception *); + static void _tao_any_destructor (void*); // = TAO extension static CORBA::Exception *_alloc (void); @@ -1283,6 +1293,7 @@ TAO_NAMESPACE PortableServer{ static AdapterActivator_ptr _duplicate (AdapterActivator_ptr obj); static AdapterActivator_ptr _narrow (CORBA::Object_ptr obj, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); static AdapterActivator_ptr _nil (void); + static void _tao_any_destructor (void*); virtual CORBA::Boolean unknown_adapter (POA_ptr parent, const char *name, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; virtual CORBA::Boolean _is_a (const CORBA::Char *type_id, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); @@ -1381,6 +1392,7 @@ TAO_NAMESPACE PortableServer{ static ServantManager_ptr _duplicate (ServantManager_ptr obj); static ServantManager_ptr _narrow (CORBA::Object_ptr obj, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); static ServantManager_ptr _nil (void); + static void _tao_any_destructor (void*); virtual CORBA::Boolean _is_a (const CORBA::Char *type_id, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); virtual const char* _interface_repository_id (void) const; @@ -1477,6 +1489,7 @@ TAO_NAMESPACE PortableServer{ static ServantActivator_ptr _duplicate (ServantActivator_ptr obj); static ServantActivator_ptr _narrow (CORBA::Object_ptr obj, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); static ServantActivator_ptr _nil (void); + static void _tao_any_destructor (void*); virtual Servant incarnate (const ObjectId &oid, POA_ptr adapter, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; virtual void etherealize (const ObjectId &oid, POA_ptr adapter, Servant serv, CORBA::Boolean cleanup_in_progress, CORBA::Boolean remaining_activations, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; @@ -1578,6 +1591,7 @@ TAO_NAMESPACE PortableServer{ static ServantLocator_ptr _duplicate (ServantLocator_ptr obj); static ServantLocator_ptr _narrow (CORBA::Object_ptr obj, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); static ServantLocator_ptr _nil (void); + static void _tao_any_destructor (void*); virtual Servant preinvoke (const ObjectId &oid, POA_ptr adapter, const char *operation, Cookie & the_cookie, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; virtual void postinvoke (const ObjectId &oid, POA_ptr adapter, const char *operation, Cookie the_cookie, Servant the_servant, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; @@ -1677,6 +1691,7 @@ TAO_NAMESPACE PortableServer{ static POA_ptr _duplicate (POA_ptr obj); static POA_ptr _narrow (CORBA::Object_ptr obj, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); static POA_ptr _nil (void); + static void _tao_any_destructor (void*); #if !defined (_PORTABLESERVER_POA_ADAPTERALREADYEXISTS___PTR_CH_) @@ -1705,6 +1720,7 @@ TAO_NAMESPACE PortableServer{ CORBA::Environment &); static AdapterAlreadyExists *_narrow (CORBA::Exception *); + static void _tao_any_destructor (void*); // = TAO extension static CORBA::Exception *_alloc (void); @@ -1745,6 +1761,7 @@ TAO_NAMESPACE PortableServer{ CORBA::Environment &); static AdapterInactive *_narrow (CORBA::Exception *); + static void _tao_any_destructor (void*); // = TAO extension static CORBA::Exception *_alloc (void); @@ -1790,6 +1807,7 @@ TAO_NAMESPACE PortableServer{ CORBA::Environment &); static AdapterNonExistent *_narrow (CORBA::Exception *); + static void _tao_any_destructor (void*); // = TAO extension static CORBA::Exception *_alloc (void); @@ -1833,6 +1851,7 @@ TAO_NAMESPACE PortableServer{ CORBA::Environment &); static InvalidPolicy *_narrow (CORBA::Exception *); + static void _tao_any_destructor (void*); InvalidPolicy( CORBA::UShort _tao_index @@ -1884,6 +1903,7 @@ TAO_NAMESPACE PortableServer{ CORBA::Environment &); static NoServant *_narrow (CORBA::Exception *); + static void _tao_any_destructor (void*); // = TAO extension static CORBA::Exception *_alloc (void); @@ -1929,6 +1949,7 @@ TAO_NAMESPACE PortableServer{ CORBA::Environment &); static ObjectAlreadyActive *_narrow (CORBA::Exception *); + static void _tao_any_destructor (void*); // = TAO extension static CORBA::Exception *_alloc (void); @@ -1972,6 +1993,7 @@ TAO_NAMESPACE PortableServer{ CORBA::Environment &); static ObjectNotActive *_narrow (CORBA::Exception *); + static void _tao_any_destructor (void*); // = TAO extension static CORBA::Exception *_alloc (void); @@ -2015,6 +2037,7 @@ TAO_NAMESPACE PortableServer{ CORBA::Environment &); static ServantAlreadyActive *_narrow (CORBA::Exception *); + static void _tao_any_destructor (void*); // = TAO extension static CORBA::Exception *_alloc (void); @@ -2058,6 +2081,7 @@ TAO_NAMESPACE PortableServer{ CORBA::Environment &); static ServantNotActive *_narrow (CORBA::Exception *); + static void _tao_any_destructor (void*); // = TAO extension static CORBA::Exception *_alloc (void); @@ -2101,6 +2125,7 @@ TAO_NAMESPACE PortableServer{ CORBA::Environment &); static WrongAdapter *_narrow (CORBA::Exception *); + static void _tao_any_destructor (void*); // = TAO extension static CORBA::Exception *_alloc (void); @@ -2144,6 +2169,7 @@ TAO_NAMESPACE PortableServer{ CORBA::Environment &); static WrongPolicy *_narrow (CORBA::Exception *); + static void _tao_any_destructor (void*); // = TAO extension static CORBA::Exception *_alloc (void); @@ -2304,6 +2330,7 @@ TAO_NAMESPACE PortableServer{ static Current_ptr _duplicate (Current_ptr obj); static Current_ptr _narrow (CORBA::Object_ptr obj, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); static Current_ptr _nil (void); + static void _tao_any_destructor (void*); #if !defined (_PORTABLESERVER_CURRENT_NOCONTEXT___PTR_CH_) @@ -2332,6 +2359,7 @@ TAO_NAMESPACE PortableServer{ CORBA::Environment &); static NoContext *_narrow (CORBA::Exception *); + static void _tao_any_destructor (void*); // = TAO extension static CORBA::Exception *_alloc (void); @@ -2607,7 +2635,7 @@ TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::ForwardReq 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_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 &); diff --git a/TAO/tao/POAS.cpp b/TAO/tao/POAS.cpp index 0fcd784cdac..83fc211a96b 100644 --- a/TAO/tao/POAS.cpp +++ b/TAO/tao/POAS.cpp @@ -133,58 +133,45 @@ void POA_PortableServer::ThreadPolicy::_get_value_skel ( } void POA_PortableServer::ThreadPolicy::_is_a_skel ( - CORBA::ServerRequest &_tao_server_request, - void * _tao_object_reference, - void * /*context*/, - CORBA::Environment &ACE_TRY_ENV - ) -{ - static const TAO_Param_Data_Skel PortableServer_ThreadPolicy_is_a_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0}, - {CORBA::_tc_string, CORBA::ARG_IN, 0} - }; - static const TAO_Call_Data_Skel PortableServer_ThreadPolicy_is_a_calldata = - {"_is_a", 1, 2, PortableServer_ThreadPolicy_is_a_paramdata}; - POA_PortableServer::ThreadPolicy_ptr _tao_impl = (POA_PortableServer::ThreadPolicy_ptr) _tao_object_reference; - CORBA::Boolean _tao_retval; - CORBA::String_var _tao_value; - _tao_server_request.demarshal ( - ACE_TRY_ENV, - &PortableServer_ThreadPolicy_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + CORBA::ServerRequest &_tao_server_request, + void * _tao_object_reference, + void * /*context*/, + CORBA::Environment &ACE_TRY_ENV + ) +{ + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_PortableServer::ThreadPolicy *_tao_impl = (POA_PortableServer::ThreadPolicy *) _tao_object_reference; + CORBA::Boolean _tao_retval = 0; + CORBA::String_var value; + if (!((_tao_in >> value.out ()))) + ACE_THROW (CORBA::MARSHAL ()); + + _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV); ACE_CHECK; - _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV); + + _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &PortableServer_ThreadPolicy_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } void POA_PortableServer::ThreadPolicy::_non_existent_skel ( CORBA::ServerRequest &_tao_server_request, - void * /* _tao_object_reference */ , + void * _tao_object_reference , void * /*context*/, CORBA::Environment &ACE_TRY_ENV ) { - static const TAO_Param_Data_Skel PortableServer_ThreadPolicy_non_existent_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0} - }; - static const TAO_Call_Data_Skel PortableServer_ThreadPolicy_non_existent_calldata = - {"_non_existent", 1, 1, PortableServer_ThreadPolicy_non_existent_paramdata}; - CORBA::Boolean _tao_retval = 0; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &PortableServer_ThreadPolicy_non_existent_calldata, - &_tao_retval - ); + POA_PortableServer::ThreadPolicy *_tao_impl = (POA_PortableServer::ThreadPolicy *) _tao_object_reference; + CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV); + ACE_CHECK; + + _tao_server_request.init_reply (ACE_TRY_ENV); + ACE_CHECK; + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } #endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */ @@ -429,58 +416,45 @@ void POA_PortableServer::LifespanPolicy::_get_value_skel ( } void POA_PortableServer::LifespanPolicy::_is_a_skel ( - CORBA::ServerRequest &_tao_server_request, - void * _tao_object_reference, - void * /*context*/, - CORBA::Environment &ACE_TRY_ENV - ) -{ - static const TAO_Param_Data_Skel PortableServer_LifespanPolicy_is_a_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0}, - {CORBA::_tc_string, CORBA::ARG_IN, 0} - }; - static const TAO_Call_Data_Skel PortableServer_LifespanPolicy_is_a_calldata = - {"_is_a", 1, 2, PortableServer_LifespanPolicy_is_a_paramdata}; - POA_PortableServer::LifespanPolicy_ptr _tao_impl = (POA_PortableServer::LifespanPolicy_ptr) _tao_object_reference; - CORBA::Boolean _tao_retval; - CORBA::String_var _tao_value; - _tao_server_request.demarshal ( - ACE_TRY_ENV, - &PortableServer_LifespanPolicy_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + CORBA::ServerRequest &_tao_server_request, + void * _tao_object_reference, + void * /*context*/, + CORBA::Environment &ACE_TRY_ENV + ) +{ + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_PortableServer::LifespanPolicy *_tao_impl = (POA_PortableServer::LifespanPolicy *) _tao_object_reference; + CORBA::Boolean _tao_retval = 0; + CORBA::String_var value; + if (!((_tao_in >> value.out ()))) + ACE_THROW (CORBA::MARSHAL ()); + + _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV); ACE_CHECK; - _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV); + + _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &PortableServer_LifespanPolicy_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } void POA_PortableServer::LifespanPolicy::_non_existent_skel ( CORBA::ServerRequest &_tao_server_request, - void * /* _tao_object_reference */ , + void * _tao_object_reference , void * /*context*/, CORBA::Environment &ACE_TRY_ENV ) { - static const TAO_Param_Data_Skel PortableServer_LifespanPolicy_non_existent_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0} - }; - static const TAO_Call_Data_Skel PortableServer_LifespanPolicy_non_existent_calldata = - {"_non_existent", 1, 1, PortableServer_LifespanPolicy_non_existent_paramdata}; - CORBA::Boolean _tao_retval = 0; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &PortableServer_LifespanPolicy_non_existent_calldata, - &_tao_retval - ); + POA_PortableServer::LifespanPolicy *_tao_impl = (POA_PortableServer::LifespanPolicy *) _tao_object_reference; + CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV); + ACE_CHECK; + + _tao_server_request.init_reply (ACE_TRY_ENV); + ACE_CHECK; + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } #endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */ @@ -722,58 +696,45 @@ void POA_PortableServer::IdUniquenessPolicy::_get_value_skel ( } void POA_PortableServer::IdUniquenessPolicy::_is_a_skel ( - CORBA::ServerRequest &_tao_server_request, - void * _tao_object_reference, - void * /*context*/, - CORBA::Environment &ACE_TRY_ENV - ) -{ - static const TAO_Param_Data_Skel PortableServer_IdUniquenessPolicy_is_a_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0}, - {CORBA::_tc_string, CORBA::ARG_IN, 0} - }; - static const TAO_Call_Data_Skel PortableServer_IdUniquenessPolicy_is_a_calldata = - {"_is_a", 1, 2, PortableServer_IdUniquenessPolicy_is_a_paramdata}; - POA_PortableServer::IdUniquenessPolicy_ptr _tao_impl = (POA_PortableServer::IdUniquenessPolicy_ptr) _tao_object_reference; - CORBA::Boolean _tao_retval; - CORBA::String_var _tao_value; - _tao_server_request.demarshal ( - ACE_TRY_ENV, - &PortableServer_IdUniquenessPolicy_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + CORBA::ServerRequest &_tao_server_request, + void * _tao_object_reference, + void * /*context*/, + CORBA::Environment &ACE_TRY_ENV + ) +{ + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_PortableServer::IdUniquenessPolicy *_tao_impl = (POA_PortableServer::IdUniquenessPolicy *) _tao_object_reference; + CORBA::Boolean _tao_retval = 0; + CORBA::String_var value; + if (!((_tao_in >> value.out ()))) + ACE_THROW (CORBA::MARSHAL ()); + + _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV); ACE_CHECK; - _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV); + + _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &PortableServer_IdUniquenessPolicy_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } void POA_PortableServer::IdUniquenessPolicy::_non_existent_skel ( CORBA::ServerRequest &_tao_server_request, - void * /* _tao_object_reference */ , + void * _tao_object_reference , void * /*context*/, CORBA::Environment &ACE_TRY_ENV ) { - static const TAO_Param_Data_Skel PortableServer_IdUniquenessPolicy_non_existent_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0} - }; - static const TAO_Call_Data_Skel PortableServer_IdUniquenessPolicy_non_existent_calldata = - {"_non_existent", 1, 1, PortableServer_IdUniquenessPolicy_non_existent_paramdata}; - CORBA::Boolean _tao_retval = 0; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &PortableServer_IdUniquenessPolicy_non_existent_calldata, - &_tao_retval - ); + POA_PortableServer::IdUniquenessPolicy *_tao_impl = (POA_PortableServer::IdUniquenessPolicy *) _tao_object_reference; + CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV); + ACE_CHECK; + + _tao_server_request.init_reply (ACE_TRY_ENV); + ACE_CHECK; + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } #endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */ @@ -1018,58 +979,45 @@ void POA_PortableServer::IdAssignmentPolicy::_get_value_skel ( } void POA_PortableServer::IdAssignmentPolicy::_is_a_skel ( - CORBA::ServerRequest &_tao_server_request, - void * _tao_object_reference, - void * /*context*/, - CORBA::Environment &ACE_TRY_ENV - ) -{ - static const TAO_Param_Data_Skel PortableServer_IdAssignmentPolicy_is_a_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0}, - {CORBA::_tc_string, CORBA::ARG_IN, 0} - }; - static const TAO_Call_Data_Skel PortableServer_IdAssignmentPolicy_is_a_calldata = - {"_is_a", 1, 2, PortableServer_IdAssignmentPolicy_is_a_paramdata}; - POA_PortableServer::IdAssignmentPolicy_ptr _tao_impl = (POA_PortableServer::IdAssignmentPolicy_ptr) _tao_object_reference; - CORBA::Boolean _tao_retval; - CORBA::String_var _tao_value; - _tao_server_request.demarshal ( - ACE_TRY_ENV, - &PortableServer_IdAssignmentPolicy_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + CORBA::ServerRequest &_tao_server_request, + void * _tao_object_reference, + void * /*context*/, + CORBA::Environment &ACE_TRY_ENV + ) +{ + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_PortableServer::IdAssignmentPolicy *_tao_impl = (POA_PortableServer::IdAssignmentPolicy *) _tao_object_reference; + CORBA::Boolean _tao_retval = 0; + CORBA::String_var value; + if (!((_tao_in >> value.out ()))) + ACE_THROW (CORBA::MARSHAL ()); + + _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV); ACE_CHECK; - _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV); + + _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &PortableServer_IdAssignmentPolicy_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } void POA_PortableServer::IdAssignmentPolicy::_non_existent_skel ( CORBA::ServerRequest &_tao_server_request, - void * /* _tao_object_reference */ , + void * _tao_object_reference , void * /*context*/, CORBA::Environment &ACE_TRY_ENV ) { - static const TAO_Param_Data_Skel PortableServer_IdAssignmentPolicy_non_existent_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0} - }; - static const TAO_Call_Data_Skel PortableServer_IdAssignmentPolicy_non_existent_calldata = - {"_non_existent", 1, 1, PortableServer_IdAssignmentPolicy_non_existent_paramdata}; - CORBA::Boolean _tao_retval = 0; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &PortableServer_IdAssignmentPolicy_non_existent_calldata, - &_tao_retval - ); + POA_PortableServer::IdAssignmentPolicy *_tao_impl = (POA_PortableServer::IdAssignmentPolicy *) _tao_object_reference; + CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV); + ACE_CHECK; + + _tao_server_request.init_reply (ACE_TRY_ENV); + ACE_CHECK; + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } #endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */ @@ -1315,58 +1263,45 @@ void POA_PortableServer::ImplicitActivationPolicy::_get_value_skel ( } void POA_PortableServer::ImplicitActivationPolicy::_is_a_skel ( - CORBA::ServerRequest &_tao_server_request, - void * _tao_object_reference, - void * /*context*/, - CORBA::Environment &ACE_TRY_ENV - ) -{ - static const TAO_Param_Data_Skel PortableServer_ImplicitActivationPolicy_is_a_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0}, - {CORBA::_tc_string, CORBA::ARG_IN, 0} - }; - static const TAO_Call_Data_Skel PortableServer_ImplicitActivationPolicy_is_a_calldata = - {"_is_a", 1, 2, PortableServer_ImplicitActivationPolicy_is_a_paramdata}; - POA_PortableServer::ImplicitActivationPolicy_ptr _tao_impl = (POA_PortableServer::ImplicitActivationPolicy_ptr) _tao_object_reference; - CORBA::Boolean _tao_retval; - CORBA::String_var _tao_value; - _tao_server_request.demarshal ( - ACE_TRY_ENV, - &PortableServer_ImplicitActivationPolicy_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + CORBA::ServerRequest &_tao_server_request, + void * _tao_object_reference, + void * /*context*/, + CORBA::Environment &ACE_TRY_ENV + ) +{ + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_PortableServer::ImplicitActivationPolicy *_tao_impl = (POA_PortableServer::ImplicitActivationPolicy *) _tao_object_reference; + CORBA::Boolean _tao_retval = 0; + CORBA::String_var value; + if (!((_tao_in >> value.out ()))) + ACE_THROW (CORBA::MARSHAL ()); + + _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV); ACE_CHECK; - _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV); + + _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &PortableServer_ImplicitActivationPolicy_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } void POA_PortableServer::ImplicitActivationPolicy::_non_existent_skel ( CORBA::ServerRequest &_tao_server_request, - void * /* _tao_object_reference */ , + void * _tao_object_reference , void * /*context*/, CORBA::Environment &ACE_TRY_ENV ) { - static const TAO_Param_Data_Skel PortableServer_ImplicitActivationPolicy_non_existent_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0} - }; - static const TAO_Call_Data_Skel PortableServer_ImplicitActivationPolicy_non_existent_calldata = - {"_non_existent", 1, 1, PortableServer_ImplicitActivationPolicy_non_existent_paramdata}; - CORBA::Boolean _tao_retval = 0; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &PortableServer_ImplicitActivationPolicy_non_existent_calldata, - &_tao_retval - ); + POA_PortableServer::ImplicitActivationPolicy *_tao_impl = (POA_PortableServer::ImplicitActivationPolicy *) _tao_object_reference; + CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV); + ACE_CHECK; + + _tao_server_request.init_reply (ACE_TRY_ENV); + ACE_CHECK; + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } #endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */ @@ -1610,58 +1545,45 @@ void POA_PortableServer::ServantRetentionPolicy::_get_value_skel ( } void POA_PortableServer::ServantRetentionPolicy::_is_a_skel ( - CORBA::ServerRequest &_tao_server_request, - void * _tao_object_reference, - void * /*context*/, - CORBA::Environment &ACE_TRY_ENV - ) -{ - static const TAO_Param_Data_Skel PortableServer_ServantRetentionPolicy_is_a_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0}, - {CORBA::_tc_string, CORBA::ARG_IN, 0} - }; - static const TAO_Call_Data_Skel PortableServer_ServantRetentionPolicy_is_a_calldata = - {"_is_a", 1, 2, PortableServer_ServantRetentionPolicy_is_a_paramdata}; - POA_PortableServer::ServantRetentionPolicy_ptr _tao_impl = (POA_PortableServer::ServantRetentionPolicy_ptr) _tao_object_reference; - CORBA::Boolean _tao_retval; - CORBA::String_var _tao_value; - _tao_server_request.demarshal ( - ACE_TRY_ENV, - &PortableServer_ServantRetentionPolicy_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + CORBA::ServerRequest &_tao_server_request, + void * _tao_object_reference, + void * /*context*/, + CORBA::Environment &ACE_TRY_ENV + ) +{ + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_PortableServer::ServantRetentionPolicy *_tao_impl = (POA_PortableServer::ServantRetentionPolicy *) _tao_object_reference; + CORBA::Boolean _tao_retval = 0; + CORBA::String_var value; + if (!((_tao_in >> value.out ()))) + ACE_THROW (CORBA::MARSHAL ()); + + _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV); ACE_CHECK; - _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV); + + _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &PortableServer_ServantRetentionPolicy_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } void POA_PortableServer::ServantRetentionPolicy::_non_existent_skel ( CORBA::ServerRequest &_tao_server_request, - void * /* _tao_object_reference */ , + void * _tao_object_reference , void * /*context*/, CORBA::Environment &ACE_TRY_ENV ) { - static const TAO_Param_Data_Skel PortableServer_ServantRetentionPolicy_non_existent_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0} - }; - static const TAO_Call_Data_Skel PortableServer_ServantRetentionPolicy_non_existent_calldata = - {"_non_existent", 1, 1, PortableServer_ServantRetentionPolicy_non_existent_paramdata}; - CORBA::Boolean _tao_retval = 0; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &PortableServer_ServantRetentionPolicy_non_existent_calldata, - &_tao_retval - ); + POA_PortableServer::ServantRetentionPolicy *_tao_impl = (POA_PortableServer::ServantRetentionPolicy *) _tao_object_reference; + CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV); + ACE_CHECK; + + _tao_server_request.init_reply (ACE_TRY_ENV); + ACE_CHECK; + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } #endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */ @@ -1905,58 +1827,45 @@ void POA_PortableServer::RequestProcessingPolicy::_get_value_skel ( } void POA_PortableServer::RequestProcessingPolicy::_is_a_skel ( - CORBA::ServerRequest &_tao_server_request, - void * _tao_object_reference, - void * /*context*/, - CORBA::Environment &ACE_TRY_ENV - ) -{ - static const TAO_Param_Data_Skel PortableServer_RequestProcessingPolicy_is_a_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0}, - {CORBA::_tc_string, CORBA::ARG_IN, 0} - }; - static const TAO_Call_Data_Skel PortableServer_RequestProcessingPolicy_is_a_calldata = - {"_is_a", 1, 2, PortableServer_RequestProcessingPolicy_is_a_paramdata}; - POA_PortableServer::RequestProcessingPolicy_ptr _tao_impl = (POA_PortableServer::RequestProcessingPolicy_ptr) _tao_object_reference; - CORBA::Boolean _tao_retval; - CORBA::String_var _tao_value; - _tao_server_request.demarshal ( - ACE_TRY_ENV, - &PortableServer_RequestProcessingPolicy_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + CORBA::ServerRequest &_tao_server_request, + void * _tao_object_reference, + void * /*context*/, + CORBA::Environment &ACE_TRY_ENV + ) +{ + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_PortableServer::RequestProcessingPolicy *_tao_impl = (POA_PortableServer::RequestProcessingPolicy *) _tao_object_reference; + CORBA::Boolean _tao_retval = 0; + CORBA::String_var value; + if (!((_tao_in >> value.out ()))) + ACE_THROW (CORBA::MARSHAL ()); + + _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV); ACE_CHECK; - _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV); + + _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &PortableServer_RequestProcessingPolicy_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } void POA_PortableServer::RequestProcessingPolicy::_non_existent_skel ( CORBA::ServerRequest &_tao_server_request, - void * /* _tao_object_reference */ , + void * _tao_object_reference , void * /*context*/, CORBA::Environment &ACE_TRY_ENV ) { - static const TAO_Param_Data_Skel PortableServer_RequestProcessingPolicy_non_existent_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0} - }; - static const TAO_Call_Data_Skel PortableServer_RequestProcessingPolicy_non_existent_calldata = - {"_non_existent", 1, 1, PortableServer_RequestProcessingPolicy_non_existent_paramdata}; - CORBA::Boolean _tao_retval = 0; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &PortableServer_RequestProcessingPolicy_non_existent_calldata, - &_tao_retval - ); + POA_PortableServer::RequestProcessingPolicy *_tao_impl = (POA_PortableServer::RequestProcessingPolicy *) _tao_object_reference; + CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV); + ACE_CHECK; + + _tao_server_request.init_reply (ACE_TRY_ENV); + ACE_CHECK; + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } #endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */ diff --git a/TAO/tao/PolicyC.cpp b/TAO/tao/PolicyC.cpp index 8454e32b9ef..bdd93d93a04 100644 --- a/TAO/tao/PolicyC.cpp +++ b/TAO/tao/PolicyC.cpp @@ -610,34 +610,23 @@ const char* CORBA_PolicyCurrent::_interface_repository_id (void) const 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)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_tao_any_val; + stream << _tao_elem; _tao_any._tao_replace ( CORBA::_tc_PolicyError, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void CORBA::PolicyError::_tao_any_destructor (void *x) +{ + CORBA::PolicyError *tmp = ACE_static_cast(CORBA::PolicyError*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, CORBA::PolicyError *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -646,16 +635,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::PolicyError *_tao_elem) // non co stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::PolicyError::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PolicyError *&_tao_elem) @@ -687,9 +668,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PolicyError *&_ta CORBA::_tc_PolicyError, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::PolicyError::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -703,7 +683,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PolicyError *&_ta { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -738,9 +718,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::PolicyError CORBA::_tc_PolicyError, 1, ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::PolicyError *&, _tao_elem)), - ACE_TRY_ENV + CORBA::PolicyError::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -754,7 +733,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::PolicyError { delete ACE_const_cast (CORBA::PolicyError *&, _tao_elem); _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -762,34 +741,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::PolicyError 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; + stream << _tao_elem; _tao_any._tao_replace ( CORBA::_tc_InvalidPolicies, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void CORBA::InvalidPolicies::_tao_any_destructor (void *x) +{ + CORBA::InvalidPolicies *tmp = ACE_static_cast(CORBA::InvalidPolicies*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, CORBA::InvalidPolicies *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -798,16 +766,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::InvalidPolicies *_tao_elem) // no stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::InvalidPolicies::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InvalidPolicies *&_tao_elem) @@ -839,9 +799,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InvalidPolicies * CORBA::_tc_InvalidPolicies, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::InvalidPolicies::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -855,7 +814,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InvalidPolicies * { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -890,9 +849,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::InvalidPoli CORBA::_tc_InvalidPolicies, 1, ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::InvalidPolicies *&, _tao_elem)), - ACE_TRY_ENV + CORBA::InvalidPolicies::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -906,58 +864,45 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::InvalidPoli { delete ACE_const_cast (CORBA::InvalidPolicies *&, _tao_elem); _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; } +void CORBA::Policy::_tao_any_destructor (void *x) +{ + CORBA::Policy *tmp = ACE_static_cast(CORBA::Policy*,x); + CORBA::release (tmp); +} + 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_OutputCDR stream; - if (stream << *_tao_obj_ptr) + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_Policy, + CORBA::_tc_Policy, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, - _tao_obj_ptr, - ACE_TRY_ENV + _tao_elem, + CORBA::Policy::_tao_any_destructor ); - 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::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 (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (CORBA::_tc_Policy, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -970,24 +915,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Policy_ptr &_tao_ { _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)->_tao_replace ( CORBA::_tc_Policy, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + CORBA::Policy::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = CORBA::Policy::_nil (); return 0; } @@ -1003,40 +941,25 @@ void operator<<= ( const CORBA::PolicyList &_tao_elem ) // copying { - CORBA::PolicyList *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA::PolicyList (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - if (stream << *_tao_any_val) + if (stream << _tao_elem) { _tao_any._tao_replace ( CORBA::_tc_PolicyList, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; } - else - { - delete _tao_any_val; - } - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void CORBA::PolicyList::_tao_any_destructor (void *x) +{ + CORBA::PolicyList *tmp = ACE_static_cast(CORBA::PolicyList*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, CORBA::PolicyList *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -1045,16 +968,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::PolicyList *_tao_elem) // non cop stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::PolicyList::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PolicyList *&_tao_elem) @@ -1086,9 +1001,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PolicyList *&_tao CORBA::_tc_PolicyList, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::PolicyList::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -1102,7 +1016,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PolicyList *&_tao { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -1137,9 +1051,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::PolicyList CORBA::_tc_PolicyList, 1, ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::PolicyList *&, _tao_elem)), - ACE_TRY_ENV + CORBA::PolicyList::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -1153,7 +1066,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::PolicyList { delete ACE_const_cast (CORBA::PolicyList *&, _tao_elem); _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -1164,40 +1077,25 @@ void operator<<= ( const CORBA::PolicyTypeSeq &_tao_elem ) // copying { - CORBA::PolicyTypeSeq *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA::PolicyTypeSeq (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - if (stream << *_tao_any_val) + if (stream << _tao_elem) { _tao_any._tao_replace ( CORBA::_tc_PolicyTypeSeq, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - else - { - delete _tao_any_val; } - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void CORBA::PolicyTypeSeq::_tao_any_destructor (void *x) +{ + CORBA::PolicyTypeSeq *tmp = ACE_static_cast(CORBA::PolicyTypeSeq*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, CORBA::PolicyTypeSeq *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -1206,16 +1104,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::PolicyTypeSeq *_tao_elem) // non stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::PolicyTypeSeq::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PolicyTypeSeq *&_tao_elem) @@ -1247,9 +1137,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PolicyTypeSeq *&_ CORBA::_tc_PolicyTypeSeq, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::PolicyTypeSeq::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -1263,7 +1152,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PolicyTypeSeq *&_ { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -1298,9 +1187,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::PolicyTypeS CORBA::_tc_PolicyTypeSeq, 1, ACE_reinterpret_cast (void *, ACE_const_cast (CORBA::PolicyTypeSeq *&, _tao_elem)), - ACE_TRY_ENV + CORBA::PolicyTypeSeq::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -1314,7 +1202,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::PolicyTypeS { delete ACE_const_cast (CORBA::PolicyTypeSeq *&, _tao_elem); _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -1322,29 +1210,13 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::PolicyTypeS void operator<<= (CORBA::Any &_tao_any, CORBA::SetOverrideType _tao_elem) { - CORBA::SetOverrideType *_tao_any_val; - ACE_NEW (_tao_any_val, CORBA::SetOverrideType (_tao_elem)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_tao_any_val; + stream << _tao_elem; _tao_any._tao_replace ( CORBA::_tc_SetOverrideType, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - // free allocated storage - delete _tao_any_val; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::SetOverrideType &_tao_elem) @@ -1414,49 +1286,36 @@ operator>> ( return 0; } +void CORBA::PolicyManager::_tao_any_destructor (void *x) +{ + CORBA::PolicyManager *tmp = ACE_static_cast(CORBA::PolicyManager*,x); + CORBA::release (tmp); +} + 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_PolicyManager, + CORBA::_tc_PolicyManager, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, - _tao_obj_ptr, - ACE_TRY_ENV + _tao_elem, + CORBA::PolicyManager::_tao_any_destructor ); - 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; @@ -1469,24 +1328,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PolicyManager_ptr { _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 + _tao_elem, + CORBA::PolicyManager::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = CORBA::PolicyManager::_nil (); return 0; } @@ -1495,49 +1347,36 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PolicyManager_ptr return 0; } +void CORBA::PolicyCurrent::_tao_any_destructor (void *x) +{ + CORBA::PolicyCurrent *tmp = ACE_static_cast(CORBA::PolicyCurrent*,x); + CORBA::release (tmp); +} + 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) + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_PolicyCurrent, + CORBA::_tc_PolicyCurrent, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, - _tao_obj_ptr, - ACE_TRY_ENV + _tao_elem, + CORBA::PolicyCurrent::_tao_any_destructor ); - 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; @@ -1550,24 +1389,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PolicyCurrent_ptr { _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 + _tao_elem, + CORBA::PolicyCurrent::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = CORBA::PolicyCurrent::_nil (); return 0; } diff --git a/TAO/tao/PolicyC.h b/TAO/tao/PolicyC.h index ec2710f5e32..d168a380f35 100644 --- a/TAO/tao/PolicyC.h +++ b/TAO/tao/PolicyC.h @@ -40,6 +40,7 @@ public: CORBA::Environment &); static CORBA_PolicyError *_narrow (CORBA::Exception *); + static void _tao_any_destructor (void*); CORBA_PolicyError( CORBA::PolicyErrorCode _tao_reason); @@ -88,6 +89,7 @@ public: CORBA::Environment &); static CORBA_InvalidPolicies *_narrow (CORBA::Exception *); + static void _tao_any_destructor (void*); CORBA_InvalidPolicies( const _tao_seq_UShort & _tao_indices); @@ -159,6 +161,7 @@ public: TAO_default_environment () ); static CORBA_Policy_ptr _nil (void); + static void _tao_any_destructor (void*); #if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES) virtual CORBA::PolicyType policy_type ( @@ -228,6 +231,8 @@ public: ); CORBA_PolicyList (const CORBA_PolicyList &); // copy ctor ~CORBA_PolicyList (void); // dtor + + static void _tao_any_destructor (void*); }; typedef CORBA_PolicyList *CORBA_PolicyList_ptr; @@ -299,6 +304,8 @@ public: ); CORBA_PolicyTypeSeq (const CORBA_PolicyTypeSeq &); // copy ctor ~CORBA_PolicyTypeSeq (void); // dtor + + static void _tao_any_destructor (void*); }; typedef CORBA_PolicyTypeSeq *CORBA_PolicyTypeSeq_ptr; @@ -411,6 +418,7 @@ public: TAO_default_environment () ); static CORBA_PolicyManager_ptr _nil (void); + static void _tao_any_destructor (void*); virtual CORBA_PolicyList * get_policy_overrides ( const CORBA_PolicyTypeSeq & ts, @@ -501,6 +509,7 @@ public: TAO_default_environment () ); static CORBA_PolicyCurrent_ptr _nil (void); + static void _tao_any_destructor (void*); virtual CORBA::Boolean _is_a ( const CORBA::Char *type_id, @@ -524,11 +533,11 @@ private: TAO_Export void operator<<= (CORBA::Any &, const CORBA::PolicyError &); -TAO_Export void operator<<= (CORBA::Any &, +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 &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::PolicyError *&); TAO_Export void operator<<= (CORBA::Any &, const CORBA::InvalidPolicies &); @@ -536,7 +545,7 @@ 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 &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::InvalidPolicies *&); // Any operators for interface CORBA::Policy @@ -550,7 +559,7 @@ 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 &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::PolicyList *&); TAO_Export void operator<<= (CORBA::Any &, const CORBA::PolicyTypeSeq &); @@ -558,20 +567,20 @@ 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 &, +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 &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::PolicyManager_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::PolicyManager *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::PolicyCurrent_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::PolicyCurrent *&); // **************************************************************** diff --git a/TAO/tao/PolicyS.cpp b/TAO/tao/PolicyS.cpp index 3e022a5d9a1..dbd2a47d92f 100644 --- a/TAO/tao/PolicyS.cpp +++ b/TAO/tao/PolicyS.cpp @@ -182,52 +182,39 @@ void POA_CORBA::Policy::_is_a_skel ( CORBA::Environment &ACE_TRY_ENV ) { - static const TAO_Param_Data_Skel CORBA_Policy_is_a_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0}, - {CORBA::_tc_string, CORBA::ARG_IN, 0} - }; - static const TAO_Call_Data_Skel CORBA_Policy_is_a_calldata = - {"_is_a", 1, 2, CORBA_Policy_is_a_paramdata}; - POA_CORBA::Policy_ptr _tao_impl = (POA_CORBA::Policy_ptr) _tao_object_reference; - CORBA::Boolean _tao_retval; - CORBA::String_var _tao_value; - _tao_server_request.demarshal ( - ACE_TRY_ENV, - &CORBA_Policy_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_CORBA::Policy *_tao_impl = (POA_CORBA::Policy *) _tao_object_reference; + CORBA::Boolean _tao_retval = 0; + CORBA::String_var value; + if (!((_tao_in >> value.out ()))) + ACE_THROW (CORBA::MARSHAL ()); + + _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV); ACE_CHECK; - _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV); + + _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &CORBA_Policy_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } void POA_CORBA::Policy::_non_existent_skel ( CORBA::ServerRequest &_tao_server_request, - void * /* _tao_object_reference */ , + void * _tao_object_reference , void * /*context*/, CORBA::Environment &ACE_TRY_ENV ) { - static const TAO_Param_Data_Skel CORBA_Policy_non_existent_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0} - }; - static const TAO_Call_Data_Skel CORBA_Policy_non_existent_calldata = - {"_non_existent", 1, 1, CORBA_Policy_non_existent_paramdata}; - CORBA::Boolean _tao_retval = 0; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &CORBA_Policy_non_existent_calldata, - &_tao_retval - ); + POA_CORBA::Policy *_tao_impl = (POA_CORBA::Policy *) _tao_object_reference; + CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV); + ACE_CHECK; + + _tao_server_request.init_reply (ACE_TRY_ENV); + ACE_CHECK; + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } void POA_CORBA::Policy::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &ACE_TRY_ENV) diff --git a/TAO/tao/PollableC.cpp b/TAO/tao/PollableC.cpp index c7bc2e24b5a..a2db69f73d1 100644 --- a/TAO/tao/PollableC.cpp +++ b/TAO/tao/PollableC.cpp @@ -889,49 +889,36 @@ const char* CORBA_PollableSet::_interface_repository_id (void) const return "IDL:omg.org/CORBA/PollableSet:1.0"; } +void CORBA::Pollable::_tao_any_destructor (void *x) +{ + CORBA::Pollable *tmp = ACE_static_cast(CORBA::Pollable*,x); + CORBA::release (tmp); +} + 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_OutputCDR stream; - if (stream << *_tao_obj_ptr) + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_Pollable, + CORBA::_tc_Pollable, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, - _tao_obj_ptr, - ACE_TRY_ENV + _tao_elem, + CORBA::Pollable::_tao_any_destructor ); - 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::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 (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (CORBA::_tc_Pollable, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -944,24 +931,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Pollable_ptr &_ta { _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)->_tao_replace ( CORBA::_tc_Pollable, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + CORBA::Pollable::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = CORBA::Pollable::_nil (); return 0; } @@ -982,49 +962,37 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Pollable_ptr &_ta CORBA::DIIPollable_ptr (*_TAO_collocation_CORBA_DIIPollable_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ) = 0; + +void CORBA::DIIPollable::_tao_any_destructor (void *x) +{ + CORBA::DIIPollable *tmp = ACE_static_cast(CORBA::DIIPollable*,x); + CORBA::release (tmp); +} + void operator<<= (CORBA::Any &_tao_any, CORBA::DIIPollable_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::DIIPollable::_duplicate (_tao_elem); TAO_OutputCDR stream; - if (stream << *_tao_obj_ptr) + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_DIIPollable, + CORBA::_tc_DIIPollable, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, - _tao_obj_ptr, - ACE_TRY_ENV + _tao_elem, + CORBA::DIIPollable::_tao_any_destructor ); - 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::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->equivalent (CORBA::_tc_DIIPollable, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -1037,24 +1005,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::DIIPollable_ptr & { _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)->_tao_replace ( CORBA::_tc_DIIPollable, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + CORBA::DIIPollable::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = CORBA::DIIPollable::_nil (); return 0; } @@ -1075,49 +1036,37 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::DIIPollable_ptr & CORBA::PollableSet_ptr (*_TAO_collocation_CORBA_PollableSet_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ) = 0; + +void CORBA::PollableSet::_tao_any_destructor (void *x) +{ + CORBA::PollableSet *tmp = ACE_static_cast(CORBA::PollableSet*,x); + CORBA::release (tmp); +} + 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_OutputCDR stream; - if (stream << *_tao_obj_ptr) + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_PollableSet, + CORBA::_tc_PollableSet, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, - _tao_obj_ptr, - ACE_TRY_ENV + _tao_elem, + CORBA::PollableSet::_tao_any_destructor ); - 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::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 (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (CORBA::_tc_PollableSet, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -1130,24 +1079,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PollableSet_ptr & { _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)->_tao_replace ( CORBA::_tc_PollableSet, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + CORBA::PollableSet::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = CORBA::PollableSet::_nil (); return 0; } @@ -1167,34 +1109,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PollableSet_ptr & 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)); - if (!_tao_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_tao_any_val; + stream << _tao_elem; _tao_any._tao_replace ( CORBA::PollableSet::_tc_NoPossiblePollable, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; } void operator<<= (CORBA::Any &_tao_any, CORBA::PollableSet::NoPossiblePollable *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -1203,16 +1128,14 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::PollableSet::NoPossiblePollable * stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::PollableSet::NoPossiblePollable::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; +} + +void CORBA::PollableSet::NoPossiblePollable::_tao_any_destructor (void *x) +{ + CORBA::PollableSet::NoPossiblePollable *tmp = ACE_static_cast(CORBA::PollableSet::NoPossiblePollable*,x); + delete tmp; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PollableSet::NoPossiblePollable *&_tao_elem) @@ -1244,9 +1167,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PollableSet::NoPo CORBA::PollableSet::_tc_NoPossiblePollable, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::PollableSet::NoPossiblePollable::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -1260,7 +1182,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PollableSet::NoPo { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -1268,85 +1190,28 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PollableSet::NoPo CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::PollableSet::NoPossiblePollable *&_tao_elem) { - ACE_TRY_NEW_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; + return _tao_any >>= ACE_const_cast(CORBA::PollableSet::NoPossiblePollable *&,_tao_elem); } 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; + stream << _tao_elem; _tao_any._tao_replace ( CORBA::PollableSet::_tc_UnknownPollable, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _tao_any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_any_val; - } - ACE_ENDTRY; +} + +void CORBA::PollableSet::UnknownPollable::_tao_any_destructor (void +{ + CORBA::PollableSet::UnknownPollable *tmp = ACE_static_cast(CORBA::PollableSet::UnknownPollable*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, CORBA::PollableSet::UnknownPollable *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -1355,16 +1220,8 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::PollableSet::UnknownPollable *_ta stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + CORBA::PollableSet::UnknownPollable::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PollableSet::UnknownPollable *&_tao_elem) @@ -1396,9 +1253,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PollableSet::Unkn CORBA::PollableSet::_tc_UnknownPollable, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + CORBA::PollableSet::UnknownPollable::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -1412,7 +1268,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PollableSet::Unkn { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -1420,53 +1276,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PollableSet::Unkn 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; + return _tao_any >>= ACE_const_cast(CORBA::PollableSet::UnknownPollable *&,_tao_elem); } // **************************************************************** diff --git a/TAO/tao/PollableC.h b/TAO/tao/PollableC.h index 648e8f2c262..313c7a23d04 100644 --- a/TAO/tao/PollableC.h +++ b/TAO/tao/PollableC.h @@ -156,6 +156,7 @@ class TAO_Export CORBA_Pollable : public virtual CORBA_Object TAO_default_environment () ); static CORBA_Pollable_ptr _nil (void); + static void _tao_any_destructor (void*); virtual CORBA::Boolean is_ready ( CORBA::ULong timeout, @@ -250,6 +251,7 @@ public: TAO_default_environment () ); static CORBA_DIIPollable_ptr _nil (void); + static void _tao_any_destructor (void*); virtual CORBA::Boolean _is_a ( const CORBA::Char *type_id, @@ -290,6 +292,7 @@ public: TAO_default_environment () ); static CORBA_PollableSet_ptr _nil (void); + static void _tao_any_destructor (void*); class NoPossiblePollable; typedef NoPossiblePollable *NoPossiblePollable_ptr; @@ -318,6 +321,7 @@ public: CORBA::Environment &); static NoPossiblePollable *_narrow (CORBA::Exception *); + static void _tao_any_destructor (void*); // = TAO extension @@ -354,6 +358,7 @@ public: CORBA::Environment &); static UnknownPollable *_narrow (CORBA::Exception *); + static void _tao_any_destructor (void*); // = TAO extension @@ -406,37 +411,37 @@ private: }; // Any operators for interface CORBA_Pollable -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA_Pollable_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_Pollable *&); // Any operators for interface CORBA::DIIPollable -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA::DIIPollable_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::DIIPollable *&); // Any operators for interface CORBA_PollableSet -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA_PollableSet_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_PollableSet *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA_PollableSet::NoPossiblePollable &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA_PollableSet::NoPossiblePollable*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_PollableSet::NoPossiblePollable *&); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::PollableSet::NoPossiblePollable *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const CORBA_PollableSet::UnknownPollable &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, CORBA_PollableSet::UnknownPollable*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_PollableSet::UnknownPollable *&); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::PollableSet::UnknownPollable *&); #ifndef __ACE_INLINE__ diff --git a/TAO/tao/PollableS.cpp b/TAO/tao/PollableS.cpp index 482ff6114fe..022540596c5 100644 --- a/TAO/tao/PollableS.cpp +++ b/TAO/tao/PollableS.cpp @@ -179,31 +179,21 @@ void POA_CORBA::Pollable::_is_a_skel ( CORBA::Environment &ACE_TRY_ENV ) { - static const TAO_Param_Data_Skel CORBA_Pollable_is_a_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0}, - {CORBA::_tc_string, CORBA::ARG_IN, 0} - }; - static const TAO_Call_Data_Skel CORBA_Pollable_is_a_calldata = - {"_is_a", 1, 2, CORBA_Pollable_is_a_paramdata}; - POA_CORBA::Pollable_ptr _tao_impl = (POA_CORBA::Pollable_ptr) _tao_object_reference; - CORBA::Boolean _tao_retval; - CORBA::String_var _tao_value; - _tao_server_request.demarshal ( - ACE_TRY_ENV, - &CORBA_Pollable_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_CORBA::Pollable *_tao_impl = (POA_CORBA::Pollable *) _tao_object_reference; + CORBA::Boolean _tao_retval = 0; + CORBA::String_var value; + if (!((_tao_in >> value.out ()))) + ACE_THROW (CORBA::MARSHAL ()); + + _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV); ACE_CHECK; - _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV); + + _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &CORBA_Pollable_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } CORBA::Boolean POA_CORBA::Pollable::_is_a ( @@ -221,23 +211,20 @@ CORBA::Boolean POA_CORBA::Pollable::_is_a ( void POA_CORBA::Pollable::_non_existent_skel ( CORBA::ServerRequest &_tao_server_request, - void * /* _tao_object_reference */ , + void * _tao_object_reference, void * /*context*/, CORBA::Environment &ACE_TRY_ENV ) { - static const TAO_Param_Data_Skel CORBA_Pollable_non_existent_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0} - }; - static const TAO_Call_Data_Skel CORBA_Pollable_non_existent_calldata = - {"_non_existent", 1, 1, CORBA_Pollable_non_existent_paramdata}; - CORBA::Boolean _tao_retval = 0; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &CORBA_Pollable_non_existent_calldata, - &_tao_retval - ); + POA_CORBA::Pollable *_tao_impl = (POA_CORBA::Pollable *) _tao_object_reference; + CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV); + ACE_CHECK; + + _tao_server_request.init_reply (ACE_TRY_ENV); + ACE_CHECK; + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } void* POA_CORBA::Pollable::_downcast ( @@ -429,31 +416,21 @@ void POA_CORBA::DIIPollable::_is_a_skel ( CORBA::Environment &ACE_TRY_ENV ) { - static const TAO_Param_Data_Skel CORBA_DIIPollable_is_a_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0}, - {CORBA::_tc_string, CORBA::ARG_IN, 0} - }; - static const TAO_Call_Data_Skel CORBA_DIIPollable_is_a_calldata = - {"_is_a", 1, 2, CORBA_DIIPollable_is_a_paramdata}; - POA_CORBA::DIIPollable_ptr _tao_impl = (POA_CORBA::DIIPollable_ptr) _tao_object_reference; - CORBA::Boolean _tao_retval; - CORBA::String_var _tao_value; - _tao_server_request.demarshal ( - ACE_TRY_ENV, - &CORBA_DIIPollable_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_CORBA::DIIPollable *_tao_impl = (POA_CORBA::DIIPollable *) _tao_object_reference; + CORBA::Boolean _tao_retval = 0; + CORBA::String_var value; + if (!((_tao_in >> value.out ()))) + ACE_THROW (CORBA::MARSHAL ()); + + _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV); ACE_CHECK; - _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV); + + _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &CORBA_DIIPollable_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } CORBA::Boolean POA_CORBA::DIIPollable::_is_a ( @@ -472,23 +449,20 @@ CORBA::Boolean POA_CORBA::DIIPollable::_is_a ( void POA_CORBA::DIIPollable::_non_existent_skel ( CORBA::ServerRequest &_tao_server_request, - void * /* _tao_object_reference */ , + void * _tao_object_reference , void * /*context*/, CORBA::Environment &ACE_TRY_ENV ) { - static const TAO_Param_Data_Skel CORBA_DIIPollable_non_existent_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0} - }; - static const TAO_Call_Data_Skel CORBA_DIIPollable_non_existent_calldata = - {"_non_existent", 1, 1, CORBA_DIIPollable_non_existent_paramdata}; - CORBA::Boolean _tao_retval = 0; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &CORBA_DIIPollable_non_existent_calldata, - &_tao_retval - ); + POA_CORBA::DIIPollable *_tao_impl = (POA_CORBA::DIIPollable *) _tao_object_reference; + CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV); + ACE_CHECK; + + _tao_server_request.init_reply (ACE_TRY_ENV); + ACE_CHECK; + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } void* POA_CORBA::DIIPollable::_downcast ( @@ -787,31 +761,21 @@ void POA_CORBA::PollableSet::_is_a_skel ( CORBA::Environment &ACE_TRY_ENV ) { - static const TAO_Param_Data_Skel CORBA_PollableSet_is_a_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0}, - {CORBA::_tc_string, CORBA::ARG_IN, 0} - }; - static const TAO_Call_Data_Skel CORBA_PollableSet_is_a_calldata = - {"_is_a", 1, 2, CORBA_PollableSet_is_a_paramdata}; - POA_CORBA::PollableSet_ptr _tao_impl = (POA_CORBA::PollableSet_ptr) _tao_object_reference; - CORBA::Boolean _tao_retval; - CORBA::String_var _tao_value; - _tao_server_request.demarshal ( - ACE_TRY_ENV, - &CORBA_PollableSet_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_CORBA::PollableSet *_tao_impl = (POA_CORBA::PollableSet *) _tao_object_reference; + CORBA::Boolean _tao_retval = 0; + CORBA::String_var value; + if (!((_tao_in >> value.out ()))) + ACE_THROW (CORBA::MARSHAL ()); + + _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV); ACE_CHECK; - _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV); + + _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &CORBA_PollableSet_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } CORBA::Boolean POA_CORBA::PollableSet::_is_a ( @@ -829,23 +793,20 @@ CORBA::Boolean POA_CORBA::PollableSet::_is_a ( void POA_CORBA::PollableSet::_non_existent_skel ( CORBA::ServerRequest &_tao_server_request, - void * /* _tao_object_reference */ , + void * _tao_object_reference , void * /*context*/, CORBA::Environment &ACE_TRY_ENV ) { - static const TAO_Param_Data_Skel CORBA_PollableSet_non_existent_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0} - }; - static const TAO_Call_Data_Skel CORBA_PollableSet_non_existent_calldata = - {"_non_existent", 1, 1, CORBA_PollableSet_non_existent_paramdata}; - CORBA::Boolean _tao_retval = 0; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &CORBA_PollableSet_non_existent_calldata, - &_tao_retval - ); + POA_CORBA::PollableSet *_tao_impl = (POA_CORBA::PollableSet *) _tao_object_reference; + CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV); + ACE_CHECK; + + _tao_server_request.init_reply (ACE_TRY_ENV); + ACE_CHECK; + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } void* POA_CORBA::PollableSet::_downcast ( diff --git a/TAO/tao/SHMIOP_Profile.cpp b/TAO/tao/SHMIOP_Profile.cpp index ea53d973578..03a705424fe 100644 --- a/TAO/tao/SHMIOP_Profile.cpp +++ b/TAO/tao/SHMIOP_Profile.cpp @@ -175,7 +175,7 @@ TAO_SHMIOP_Profile::decode (TAO_InputCDR& cdr) return -1; } - if (this->object_addr_.set (this->port_, + if (this->object_addr_.set (this->port_, this->host_.in ()) == -1) { if (TAO_debug_level > 0) @@ -305,7 +305,7 @@ TAO_SHMIOP_Profile::parse_string (const char *string, this->host_ = tmp._retn (); - if (this->object_addr_.set (this->port_, + if (this->object_addr_.set (this->port_, this->host_.in ()) == -1) { if (TAO_debug_level > 0) @@ -405,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/Sequence.cpp b/TAO/tao/Sequence.cpp index b43ee0505d3..5038b29c4f1 100644 --- a/TAO/tao/Sequence.cpp +++ b/TAO/tao/Sequence.cpp @@ -68,7 +68,7 @@ TAO_Unbounded_String_Sequence (const TAO_Unbounded_String_Sequence &rhs) { if (rhs.buffer_ != 0) { - char* *tmp1 = + char* *tmp1 = TAO_Unbounded_String_Sequence::allocbuf (this->maximum_); char ** const tmp2 = @@ -290,11 +290,11 @@ TAO_Unbounded_WString_Sequence (const TAO_Unbounded_WString_Sequence &rhs) { if (rhs.buffer_ != 0) { - CORBA::WChar* *tmp1 = + CORBA::WChar* *tmp1 = TAO_Unbounded_WString_Sequence::allocbuf (this->maximum_); CORBA::WChar ** const tmp2 = - ACE_reinterpret_cast (CORBA::WChar ** ACE_CAST_CONST, + ACE_reinterpret_cast (CORBA::WChar ** ACE_CAST_CONST, rhs.buffer_); for (CORBA::ULong i = 0; i < rhs.length_; ++i) @@ -324,7 +324,7 @@ operator= (const TAO_Unbounded_WString_Sequence &rhs) if (this->release_) { - CORBA::WChar **tmp = ACE_reinterpret_cast (CORBA::WChar **, + CORBA::WChar **tmp = ACE_reinterpret_cast (CORBA::WChar **, this->buffer_); for (CORBA::ULong i = 0; i < this->length_; ++i) @@ -347,7 +347,7 @@ operator= (const TAO_Unbounded_WString_Sequence &rhs) TAO_Unbounded_Base_Sequence::operator= (rhs); - CORBA::WChar **tmp1 = ACE_reinterpret_cast (CORBA::WChar **, + CORBA::WChar **tmp1 = ACE_reinterpret_cast (CORBA::WChar **, this->buffer_); CORBA::WChar ** const tmp2 = ACE_reinterpret_cast (CORBA::WChar ** ACE_CAST_CONST, rhs.buffer_); @@ -416,7 +416,7 @@ TAO_Unbounded_WString_Sequence::get_buffer (CORBA::Boolean orphan) } else { - result = ACE_reinterpret_cast (CORBA::WChar**, + result = ACE_reinterpret_cast (CORBA::WChar**, this->buffer_); } } @@ -426,7 +426,7 @@ TAO_Unbounded_WString_Sequence::get_buffer (CORBA::Boolean orphan) { // We set the state back to default and relinquish // ownership. - result = ACE_reinterpret_cast (CORBA::WChar**, + result = ACE_reinterpret_cast (CORBA::WChar**, this->buffer_); this->maximum_ = 0; this->length_ = 0; @@ -440,7 +440,7 @@ TAO_Unbounded_WString_Sequence::get_buffer (CORBA::Boolean orphan) const CORBA::WChar** TAO_Unbounded_WString_Sequence::get_buffer (void) const { - return ACE_reinterpret_cast (const CORBA::WChar** ACE_CAST_CONST, + return ACE_reinterpret_cast (const CORBA::WChar** ACE_CAST_CONST, this->buffer_); } @@ -451,7 +451,7 @@ TAO_Unbounded_WString_Sequence::_allocate_buffer (CORBA::ULong length) if (this->buffer_ != 0) { - CORBA::WChar* *old = ACE_reinterpret_cast (CORBA::WChar **, + CORBA::WChar* *old = ACE_reinterpret_cast (CORBA::WChar **, this->buffer_); for (CORBA::ULong i = 0; i < this->length_; ++i) @@ -477,7 +477,7 @@ TAO_Unbounded_WString_Sequence::_deallocate_buffer (void) if (this->buffer_ == 0 || this->release_ == 0) return; - CORBA::WChar **tmp = ACE_reinterpret_cast (CORBA::WChar **, + CORBA::WChar **tmp = ACE_reinterpret_cast (CORBA::WChar **, this->buffer_); for (CORBA::ULong i = 0; @@ -496,7 +496,7 @@ void TAO_Unbounded_WString_Sequence::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol) { - CORBA::WChar **tmp = ACE_reinterpret_cast (CORBA::WChar **, + CORBA::WChar **tmp = ACE_reinterpret_cast (CORBA::WChar **, this->buffer_); for (CORBA::ULong i = nl; i < ol; ++i) { @@ -515,17 +515,17 @@ TAO_Unbounded_Sequence (const TAO_Unbounded_Sequence<CORBA::Octet> &rhs) { if (rhs.buffer_ != 0) { - CORBA::Octet *tmp1 = + CORBA::Octet *tmp1 = TAO_Unbounded_Sequence<CORBA::Octet>::allocbuf (this->maximum_); - CORBA::Octet * const tmp2 = - ACE_reinterpret_cast (CORBA::Octet * ACE_CAST_CONST, + CORBA::Octet * const tmp2 = + ACE_reinterpret_cast (CORBA::Octet * ACE_CAST_CONST, rhs.buffer_); if (rhs.mb_ == 0) { - ACE_OS::memcpy (tmp1, - tmp2, + ACE_OS::memcpy (tmp1, + tmp2, this->length_); } else @@ -535,8 +535,8 @@ TAO_Unbounded_Sequence (const TAO_Unbounded_Sequence<CORBA::Octet> &rhs) i != 0; i = i->cont ()) { - ACE_OS::memcpy (tmp1 + offset, - i->rd_ptr (), + ACE_OS::memcpy (tmp1 + offset, + i->rd_ptr (), i->length ()); offset += i->length (); @@ -621,6 +621,13 @@ TAO_Unbounded_Sequence<CORBA::Octet>::~TAO_Unbounded_Sequence (void) } void +TAO_Unbounded_Sequence<CORBA::Octet>::_tao_any_destructor (void *x) +{ + TAO_Unbounded_Sequence<CORBA::Octet> *tmp = ACE_static_cast(TAO_Unbounded_Sequence<CORBA::Octet>*,x); + delete tmp; +} + +void TAO_Unbounded_Sequence<CORBA::Octet>::_allocate_buffer (CORBA::ULong length) { CORBA::Octet *tmp = TAO_Unbounded_Sequence<CORBA::Octet>::allocbuf (length); diff --git a/TAO/tao/Sequence.h b/TAO/tao/Sequence.h index 1230368ad39..03018ece9b4 100644 --- a/TAO/tao/Sequence.h +++ b/TAO/tao/Sequence.h @@ -490,6 +490,10 @@ public: virtual ~TAO_Unbounded_Sequence (void); // see TAO_Unbounded_Sequence in "Sequence_T.h" + static void _tao_any_destructor (void*); + // Use in the implementation of insertion and extraction operators + // from CORBA::Any + TAO_Unbounded_Sequence (const TAO_Unbounded_Sequence<CORBA::Octet> &); TAO_Unbounded_Sequence<CORBA::Octet>& operator= (const TAO_Unbounded_Sequence<CORBA::Octet> &); // The copy constructor and assignment operators *do* copy the data, diff --git a/TAO/tao/Server_Request.h b/TAO/tao/Server_Request.h index b464aab654b..2e415965ddc 100644 --- a/TAO/tao/Server_Request.h +++ b/TAO/tao/Server_Request.h @@ -68,39 +68,6 @@ public: // whether we own it or not }; -class TAO_Call_Data_Skel -{ - // = TITLE - // Descriptions of operations, as used by the stub interpreter. - // Only interpretive marshaling/unmarshaling is used, and the - // stubs don't know what particular on-the-wire protocol is being - // used. - // - // = DESCRIPTION - // When using C++ exceptions, many C++ compilers will require the - // use of compiled code throw the exception. As binary standards - // for exception throwing evolve, it may become practical to - // interpretively throw exceptions. -public: - const char *opname; - // Operation name. - - CORBA::Boolean is_roundtrip; - // !oneway - - // When constructing tables of parameters, put them in the same - // order they appear in the IDL spec: return value, then parameters - // left to right. Other orders may produce illegal IIOP protocol - // messages. - - CORBA::ULong param_count; - // # parameters. - - const TAO_Param_Data_Skel *params; - // Their descriptions. - -}; - class TAO_Export CORBA_ServerRequest { // = TITLE @@ -193,17 +160,6 @@ public: virtual CORBA::ORB_ptr orb (void) = 0; // get the underlying ORB - virtual void demarshal (CORBA_Environment &ACE_TRY_ENV, - const TAO_Call_Data_Skel *info, - ...) = 0; - // demarshal incoming parameters - - virtual void marshal (CORBA_Environment &ACE_TRY_ENV, - // CORBA_Environment &skel_env, - const TAO_Call_Data_Skel *info, - ...) = 0; - // marshal outgoing parameters - virtual TAO_InputCDR &incoming (void) = 0; // Retrieve the incoming stream. diff --git a/TAO/tao/Services.cpp b/TAO/tao/Services.cpp index 9151bf96840..501cddbd6ed 100644 --- a/TAO/tao/Services.cpp +++ b/TAO/tao/Services.cpp @@ -250,32 +250,33 @@ CORBA::ServiceInformation::_tao_seq_ServiceDetail::~_tao_seq_ServiceDetail (void #endif /* end #if !defined */ -void operator<<= (CORBA::Any &_tao_any, const CORBA::ServiceDetail &_tao_elem) // copying +void operator<<= (CORBA::Any &_tao_any, const CORBA::ServiceDetail &_tao_elem) { - CORBA::ServiceDetail *_any_val; - ACE_NEW (_any_val, CORBA::ServiceDetail (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { - _tao_any.replace (CORBA::_tc_ServiceDetail, _any_val, 1, ACE_TRY_ENV); // copy the value - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _any_val; - } - ACE_ENDTRY; + TAO_OutputCDR stream; + stream << _tao_elem; + + _tao_any._tao_replace (CORBA::_tc_ServiceDetail, + TAO_ENCAP_BYTE_ORDER, + stream.begin ()); +} + +void CORBA::ServiceDetail::_tao_any_destructor (void *x) +{ + CORBA::ServiceDetail *tmp = ACE_static_cast(CORBA::ServiceDetail*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, CORBA::ServiceDetail *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { - _tao_any.replace (CORBA::_tc_ServiceDetail, _tao_elem, 1, ACE_TRY_ENV); // consume it - ACE_TRY_CHECK; - } - ACE_CATCHANY {} - ACE_ENDTRY; + TAO_OutputCDR stream; + stream << *_tao_elem; + + _tao_any._tao_replace (CORBA::_tc_ServiceDetail, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + CORBA::ServiceDetail::_tao_any_destructor); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ServiceDetail *&_tao_elem) @@ -295,11 +296,13 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ServiceDetail *&_ ACE_NEW_RETURN (_tao_elem, CORBA::ServiceDetail, 0); TAO_InputCDR stream (_tao_any._tao_get_cdr (), _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_ServiceDetail, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + if (stream >> *_tao_elem) { - ((CORBA::Any *)&_tao_any)->replace (CORBA::_tc_ServiceDetail, _tao_elem, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ServiceDetail, + 1, + _tao_elem, + CORBA::ServiceDetail::_tao_any_destructor); return 1; } else @@ -319,30 +322,30 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ServiceDetail *&_ void operator<<= (CORBA::Any &_tao_any, const CORBA::ServiceInformation &_tao_elem) // copying { - CORBA::ServiceInformation *_any_val; - ACE_NEW (_any_val, CORBA::ServiceInformation (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { - _tao_any.replace (CORBA::_tc_ServiceInformation, _any_val, 1, ACE_TRY_ENV); // copy the value - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _any_val; - } - ACE_ENDTRY; + TAO_OutputCDR stream; + stream << _tao_elem; + + _tao_any._tao_replace (CORBA::_tc_ServiceInformation, + TAO_ENCAP_BYTE_ORDER, + stream.begin ()); +} + +void CORBA::ServiceInformation::_tao_any_destructor (void *x) +{ + CORBA::ServiceInformation *tmp = ACE_static_cast(CORBA::ServiceInformation*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, CORBA::ServiceInformation *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { - _tao_any.replace (CORBA::_tc_ServiceInformation, _tao_elem, 1, ACE_TRY_ENV); // consume it - ACE_TRY_CHECK; - } - ACE_CATCHANY {} - ACE_ENDTRY; + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace (CORBA::_tc_ServiceInformation, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + CORBA::ServiceInformation::_tao_any_destructor); } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ServiceInformation *&_tao_elem) @@ -362,11 +365,13 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ServiceInformatio ACE_NEW_RETURN (_tao_elem, CORBA::ServiceInformation, 0); TAO_InputCDR stream (_tao_any._tao_get_cdr (), _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_ServiceInformation, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + if (stream >> *_tao_elem) { - ((CORBA::Any *)&_tao_any)->replace (CORBA::_tc_ServiceInformation, _tao_elem, 1, ACE_TRY_ENV); - ACE_TRY_CHECK; + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ServiceInformation, + 1, + _tao_elem, + CORBA::ServiceInformation::_tao_any_destructor); return 1; } else @@ -384,7 +389,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ServiceInformatio return 0; } -ACE_INLINE CORBA::Boolean operator<< ( +CORBA::Boolean operator<< ( TAO_OutputCDR &strm, const CORBA_ServiceDetail::_tao_seq_Octet &_tao_sequence ) @@ -411,7 +416,7 @@ ACE_INLINE CORBA::Boolean operator<< ( return 0; // error } -ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_ServiceDetail::_tao_seq_Octet &_tao_sequence) +CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_ServiceDetail::_tao_seq_Octet &_tao_sequence) { CORBA::ULong _tao_seq_len; if (strm >> _tao_seq_len) diff --git a/TAO/tao/Services.h b/TAO/tao/Services.h index 1b19a42ba86..de6fc4f2fc2 100644 --- a/TAO/tao/Services.h +++ b/TAO/tao/Services.h @@ -34,6 +34,8 @@ struct TAO_Export CORBA_ServiceDetail { + static void _tao_any_destructor (void*); + CORBA::ServiceDetailType service_detail_type; #if !defined (_CORBA_SERVICEDETAIL__TAO_SEQ_OCTET_CH_) @@ -183,6 +185,7 @@ class CORBA_ServiceDetail_out struct CORBA_ServiceInformation { + static void _tao_any_destructor (void*); #if !defined (TAO_USE_SEQUENCE_TEMPLATES) @@ -519,29 +522,22 @@ void operator<<= (CORBA::Any &, const CORBA_ServiceInformation &); // copying v void operator<<= (CORBA::Any &, CORBA_ServiceInformation*); // noncopying version CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_ServiceInformation *&); -#ifndef __ACE_INLINE__ - CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA_ServiceDetail &); // CORBA::Boolean operator>> (TAO_InputCDR &, CORBA_ServiceDetail &); CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA_ServiceDetail::_tao_seq_Octet &); // CORBA::Boolean operator>> (TAO_InputCDR &, CORBA_ServiceDetail::_tao_seq_Octet &); + CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA_ServiceInformation &); - // CORBA::Boolean operator>> (TAO_InputCDR &, CORBA_ServiceInformation &); -CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA_ServiceInformation::_tao_seq_ServiceOption &); // +CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA_ServiceInformation::_tao_seq_ServiceOption &); CORBA::Boolean operator>> (TAO_InputCDR &, CORBA_ServiceInformation::_tao_seq_ServiceOption &); -CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA_ServiceInformation::_tao_seq_ServiceDetail &); // +CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA_ServiceInformation::_tao_seq_ServiceDetail &); CORBA::Boolean operator>> (TAO_InputCDR &, CORBA_ServiceInformation::_tao_seq_ServiceDetail &); -#endif /* __ACE_INLINE__ */ - #if defined (__ACE_INLINE__) - #include "tao/Services.i" #endif /* defined INLINE */ - - #if defined(_MSC_VER) && (_MSC_VER >= 1200) #pragma warning(pop) #endif /* _MSC_VER */ diff --git a/TAO/tao/Stub.cpp b/TAO/tao/Stub.cpp index 71974cf51a1..b4159603327 100644 --- a/TAO/tao/Stub.cpp +++ b/TAO/tao/Stub.cpp @@ -30,41 +30,8 @@ # include "tao/Stub.i" #endif /* ! __ACE_INLINE__ */ -#include "tao/Timeprobe.h" - ACE_RCSID(tao, TAO_Stub, "$Id$") -#if defined (ACE_ENABLE_TIMEPROBES) - -static const char *TAO_TAO_Stub_Timeprobe_Description[] = - { - "TAO_Stub::do_static_call - start", - "TAO_Stub::do_static_call - end", - "TAO_Stub::do_static_call - set_cancel", - "TAO_Stub::do_static_call - grab_orb_core", - "TAO_Stub::do_static_call - invocation_ctor", - "TAO_Stub::do_static_call - invocation_start", - "TAO_Stub::do_static_call - put_params" - }; - -enum - { - // Timeprobe description table start key - TAO_STUB_OBJECT_DO_STATIC_CALL_START = 500, - TAO_STUB_OBJECT_DO_STATIC_CALL_END, - TAO_STUB_OBJECT_DO_STATIC_CALL_SET_CANCEL, - TAO_STUB_OBJECT_DO_STATIC_CALL_GRAB_ORB_CORE, - TAO_STUB_OBJECT_DO_STATIC_CALL_INVOCATION_CTOR, - TAO_STUB_OBJECT_DO_STATIC_CALL_INVOCATION_START, - TAO_STUB_OBJECT_DO_STATIC_CALL_PUT_PARAMS - }; - -// Setup Timeprobes -ACE_TIMEPROBE_EVENT_DESCRIPTIONS (TAO_TAO_Stub_Timeprobe_Description, - TAO_STUB_OBJECT_DO_STATIC_CALL_START); - -#endif /* ACE_ENABLE_TIMEPROBES */ - TAO_Stub::TAO_Stub (char *repository_id, const TAO_MProfile &profiles, TAO_ORB_Core* orb_core) @@ -296,288 +263,6 @@ private: int old_type_; }; -// "Stub interpreter" for static stubs. IDL compiler (or human -// equivalent thereof :-) should just dump a read-only description of -// the call into "calldata" and do varargs calls to this routine, -// which does all the work. - -void -TAO_Stub::do_static_call (CORBA::Environment &ACE_TRY_ENV, - const TAO_Call_Data *info, - void** args) - -{ - ACE_FUNCTION_TIMEPROBE (TAO_STUB_OBJECT_DO_STATIC_CALL_START); - - TAO_Synchronous_Cancellation_Required NOT_USED; - - ACE_TIMEPROBE (TAO_STUB_OBJECT_DO_STATIC_CALL_SET_CANCEL); - - ACE_TIMEPROBE (TAO_STUB_OBJECT_DO_STATIC_CALL_GRAB_ORB_CORE); - - // Do a locate_request if necessary/wanted. - // Suspect that you will be forwarded, so be proactive! - // strategy for reducing overhead when you think a request will - // be forwarded. No standard way now to know. - if (this->use_locate_request_ && this->first_locate_request_) - { - TAO_GIOP_Locate_Request_Invocation call (this, - this->orb_core_); - - // Simply let these exceptions propagate up - // (if any of them occurs.) - call.start (ACE_TRY_ENV); - ACE_CHECK; - - call.invoke (ACE_TRY_ENV); - ACE_CHECK; - - this->first_locate_request_ = 0; - } - - if (info->is_roundtrip) - { - TAO_GIOP_Twoway_Invocation call (this, - info->opname, - ACE_OS::strlen (info->opname), - this->orb_core_); - - ACE_TIMEPROBE (TAO_STUB_OBJECT_DO_STATIC_CALL_INVOCATION_CTOR); - - // We may need to loop through here more than once if we're - // forwarded to some other object reference. - // - // NOTE: A quality-of-service policy may be useful to establish - // here, specifically one controlling how many times the call is - // reissued before failing the call on the assumption that - // something is broken. - // - // NOTE: something missing is a dynamic way to change the policy - // of whether to issue LocateRequest messages or not. This code - // uses a simple, fixed policy: never use LocateRequest - // messages. - // - for (;;) - { - call.start (ACE_TRY_ENV); - ACE_CHECK; - - CORBA::Short flag = 131; - - call.prepare_header (ACE_static_cast (CORBA::Octet, flag), - ACE_TRY_ENV); - ACE_CHECK; - - ACE_TIMEPROBE (TAO_STUB_OBJECT_DO_STATIC_CALL_INVOCATION_START); - - // Make the call ... blocking for the response. - this->put_params (ACE_TRY_ENV, info, call, args); - ACE_CHECK; - - ACE_TIMEPROBE (TAO_STUB_OBJECT_DO_STATIC_CALL_PUT_PARAMS); - - int status = - call.invoke (info->excepts, - info->except_count, - ACE_TRY_ENV); - ACE_CHECK; - - if (status == TAO_INVOKE_RESTART) - continue; - - if (status == TAO_INVOKE_EXCEPTION) - return; // Shouldn't happen - - if (status != TAO_INVOKE_OK) - ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_MAYBE)); - - // The only case left is status == TAO_INVOKE_OK, exit the - // loop. We cannot retry because at this point we either - // got a reply or something with an status of - // COMPLETED_MAYBE, thus we cannot reissue the request if we - // are to satisfy the "at most once" semantics. - break; - } - - // Now, get all the "return", "out", and "inout" parameters - // from the response message body ... return parameter is - // first, the rest are in the order defined in the IDL spec - // (which is also the order that DII users are required to - // use). - - const TAO_Param_Data *pdp = info->params; - for (void** i = args; - i != args + info->param_count; - i++, pdp++) - { - void *ptr = *i; - - // if it is an inout parameter, it would become - // necessary to first release the "in" memory - if (pdp->mode == PARAM_INOUT) - { - // @@ TODO - add others as we test each case - // (ASG) will do 03/22/98. - // @@ IMHO this should be handled in the stub - // (coryan) - CORBA::TCKind kind = pdp->tc->kind (ACE_TRY_ENV); - ACE_CHECK; - - switch (kind) - { - case CORBA::tk_string: - CORBA::string_free (*(char **) ptr); - *(char **)ptr = 0; - break; - case CORBA::tk_objref: - CORBA::release (*(CORBA::Object_ptr *) ptr); - break; - case CORBA::tk_any: - break; - default: - break; - } - } - - if (pdp->mode == PARAM_RETURN - || pdp->mode == PARAM_OUT - || pdp->mode == PARAM_INOUT) - { - // The language mapping's memory allocation - // policy says that some data is heap-allocated. - // This interpreter is told about the relevant - // policy by whoever built the operation - // description (e.g. the IDL compiler) so it - // doesn't have to know the policy associated - // with a particular language binding - // (e.g. C/C++ differ, and C++ even has - // different policies for different kinds of - // structures). - if (pdp->value_size == 0) - { - (void) call.inp_stream ().decode (pdp->tc, - ptr, - 0, - ACE_TRY_ENV); - ACE_CHECK; - } - else - { - // @@ (ASG) - I think we must completely - // get rid of this case because IDL compiler - // generated stubs will use this function - // and they better allocate all the memory. - - // assert (value_size == tc->size()); - ACE_NEW (*(void **)ptr, - CORBA::Octet [pdp->value_size]); - - (void) call.inp_stream ().decode (pdp->tc, - *(void**)ptr, - 0, - ACE_TRY_ENV); - ACE_CHECK; - } - } - } - } // if (two way) - else - { - TAO_GIOP_Oneway_Invocation call (this, - info->opname, - ACE_OS::strlen (info->opname), - this->orb_core_); - - ACE_TIMEPROBE (TAO_STUB_OBJECT_DO_STATIC_CALL_INVOCATION_CTOR); - - for (;;) - { - call.start (ACE_TRY_ENV); - ACE_CHECK; - - CORBA::Octet flag = - ACE_static_cast (CORBA::Octet, - call.sync_scope ()); - - call.prepare_header (flag, - ACE_TRY_ENV); - ACE_CHECK; - - this->put_params (ACE_TRY_ENV, - info, - call, - args); - ACE_CHECK; - - ACE_TIMEPROBE (TAO_STUB_OBJECT_DO_STATIC_CALL_PUT_PARAMS); - - int status = call.invoke (ACE_TRY_ENV); - ACE_CHECK; - - if (status == TAO_INVOKE_RESTART) - continue; - - if (status == TAO_INVOKE_EXCEPTION) - return; // Shouldn't happen - - if (status != TAO_INVOKE_OK) - ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_MAYBE)); - - break; - } - } -} - -void -TAO_Stub::put_params (CORBA::Environment &ACE_TRY_ENV, - const TAO_Call_Data *info, - TAO_GIOP_Invocation &call, - void** args) -{ - // Now, put all "in" and "inout" parameters into the request - // message body. - // - // Some "inout" data have an extra level of indirection, - // specified by the language mapping's memory allocation - // policies ... the indirection only shows up here when it's - // needed later for allocating "out" memory, otherwise there's - // just one indirection. - - TAO_OutputCDR &cdr = call.out_stream (); - - const TAO_Param_Data *pdp = info->params; - for (void** i = args; - i != args + info->param_count; - i++, pdp++) - { - void *ptr = *i; - - if (pdp->mode == PARAM_IN) - { - (void) cdr.encode (pdp->tc, - ptr, - 0, - ACE_TRY_ENV); - } - else if (pdp->mode == PARAM_INOUT) - { - if (pdp->value_size == 0) - (void) cdr.encode (pdp->tc, - ptr, - 0, - ACE_TRY_ENV); - else - (void) cdr.encode (pdp->tc, - *(void**)ptr, - 0, - ACE_TRY_ENV); - } - ACE_CHECK; - } -} - #if !defined (TAO_HAS_MINIMUM_CORBA) // DII analogue of the above. diff --git a/TAO/tao/Stub.h b/TAO/tao/Stub.h index 6130834dbbd..d38bab61d9d 100644 --- a/TAO/tao/Stub.h +++ b/TAO/tao/Stub.h @@ -71,41 +71,6 @@ enum TAO_Param_Type class TAO_Profile; -struct TAO_Param_Data -{ - // = TITLE - // TAO_Param_Data - // - // = DESCRIPTION - // Description of a single parameter. - // - // If value_size is nonzero for OUT, INOUT, or RETURN parameters, - // it's (a) an indicator that the ORB returns a pointer-to-value - // for this parameter, and also (b) is the size of the top-level - // of the value that's returned (e.g. ignoring nested sequence - // buffers). That is, it moves CPU cycles from runtime -- some - // calls to tc->size() -- to compile time where they're - // cheap/free. - // - // It _must_ only be set for cases where the ORB allocates the - // return value, which must then be ORB::free()d ... e.g. where - // the value is a pointer to data such as a struct, sequence, or - // union. (The CORBA C++ mapping doesn't require that for all - // "out" structs; only those of "variable size".) If this value - // is nonzero, the value passed to do_static_call() must be the address - // of a pointer. - - CORBA::TypeCode_ptr tc; - // TypeCode for the parameter - - TAO_Param_Type mode; - // Its mode. - - size_t value_size; - // zero or tc->size (). For SII, we always know its size since it is the IDL - // compiler which generates the stub code. -}; - // Function pointer returning a pointer to CORBA::Exception. This is used to // describe the allocator for user-defined exceptions that are used internally // by the interpreter. @@ -131,80 +96,6 @@ struct TAO_Exception_Data // the allocator for this exception }; -struct TAO_Call_Data -{ - // = TITLE - // TAO_Call_Data - // - // = DESCRIPTION - // Descriptions of operations, as used by the stub interpreter. - // Only interpretive marshaling/unmarshaling is used, and the - // stubs don't know what particular on-the-wire protocol is being - // used. - // - // When using C++ exceptions, many C++ compilers will require the - // use of compiled code throw the exception. As binary standards - // for exception throwing evolve, it may become practical to - // interpretively throw exceptions. - - const char *opname; - // Operation name. - - CORBA::Boolean is_roundtrip; - // !oneway - - // When constructing tables of parameters, put them in the same - // order they appear in the IDL spec: return value, then parameters - // left to right. Other orders may produce illegal protocol - // messages. - - u_int param_count; - // # parameters. - - const TAO_Param_Data *params; - // Their descriptions. - - // The exceptions allowed by this operation can be listed in any - // order, and need not include the system exceptions which may be - // returned by OMG-IDL operations. If an operation tries to return - // any exception not allowed by its type signature, this causes a a - // system exception to be reported. - - u_int except_count; - // # exceptions. - - // CORBA::TypeCode_ptr *excepts; - TAO_Exception_Data *excepts; - // Their descriptions. -}; - -struct TAO_Skel_Entry -{ - // = TITLE - // TAO_Skel_Entry - // - // = DESCRIPTION - // Skeletons map "ServerRequest" generic signatures to the static - // call signature required by the implementation's methods. table - // of these per implementation - // - // There are several optimizations that'd be desirable for use by - // "static skeletons", notably (a) passing of per-object data held - // by the OA so that the method doesn't need to look it up itself, - // (b) removing all mandatory heap allocation of data, and of - // course (c) handling all the built-in ORB calls like "is_a" and - // "get_implementation". This code is currently set up only for - // Dynamic Skeletons and bridging, for which none of those are - // real issues. - - const TAO_Call_Data *op_descriptor; - // pointer to the calldata structure that holds information about all the - // parameters - - TAO_Skeleton impl_skeleton; - // skeleton corresponding to the operation -}; - class TAO_Export TAO_Stub { // = TITLE @@ -223,26 +114,6 @@ class TAO_Export TAO_Stub // The stub and DII interpreter APIs are member functions of this // type. public: - void do_static_call (CORBA_Environment &ACE_TRY_ENV, - const TAO_Call_Data *info, - void** args); - // The "stub interpreter" method parameters are: - // - // - ACE_TRY_ENV ... used for exception reporting - // - info ... describes the call - // - args parameters follow - // - // The varargs parameters are pointers to data instances as - // described by info->params. (If the value_size is nonzero, the - // data instance is itself a pointer.) The order on the call stack - // must be exactly the order they're listed in info->params; - // normally this is the order the values are listed in the OMG-IDL - // operation specification. - // - // NOTE: This can be sped up by eliminating some parameter - // shuffling. The stub and "do_static_call" parameters are all but the - // same, except that their order is different. - #if !defined (TAO_HAS_MINIMUM_CORBA) void do_dynamic_call (const char *opname, @@ -425,13 +296,6 @@ public: // temporary. protected: - void put_params (CORBA_Environment &ACE_TRY_ENV, - const TAO_Call_Data *info, - TAO_GIOP_Invocation &call, - void** args); - // Helper method to factor out common code in static oneway - // vs. twoway invocations. - #if !defined (TAO_HAS_MINIMUM_CORBA) void put_params (TAO_GIOP_Invocation &call, diff --git a/TAO/tao/TAOC.cpp b/TAO/tao/TAOC.cpp index 7b309b53287..70d3f875b52 100644 --- a/TAO/tao/TAOC.cpp +++ b/TAO/tao/TAOC.cpp @@ -142,36 +142,26 @@ TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) TAO_NAMESPACE_BEGIN (TAO) TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ClientPriorityPolicy, &_tc_TAO_tc_TAO_ClientPriorityPolicy) TAO_NAMESPACE_END + void operator<<= (CORBA::Any &_tao_any, const TAO::PrioritySpecification &_tao_elem) // copying { - TAO::PrioritySpecification *_any_val = 0; - ACE_NEW (_any_val, TAO::PrioritySpecification (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_any_val; + stream << _tao_elem; _tao_any._tao_replace ( TAO::_tc_PrioritySpecification, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _any_val; - } - ACE_ENDTRY; +} + +void TAO::PrioritySpecification::_tao_any_destructor (void *x) +{ + TAO::PrioritySpecification *tmp = ACE_static_cast(TAO::PrioritySpecification*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, TAO::PrioritySpecification *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -180,16 +170,8 @@ void operator<<= (CORBA::Any &_tao_any, TAO::PrioritySpecification *_tao_elem) / stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + TAO::PrioritySpecification::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO::PrioritySpecification *&_tao_elem) @@ -221,9 +203,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO::PrioritySpecificati TAO::_tc_PrioritySpecification, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + TAO::PrioritySpecification::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -237,7 +218,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO::PrioritySpecificati { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -272,9 +253,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const TAO::PrioritySpeci TAO::_tc_PrioritySpecification, 1, ACE_reinterpret_cast (void *, ACE_const_cast (TAO::PrioritySpecification *&, _tao_elem)), - ACE_TRY_ENV + TAO::PrioritySpecification::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -288,58 +268,45 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const TAO::PrioritySpeci { delete ACE_const_cast (TAO::PrioritySpecification *&, _tao_elem); _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; } +void TAO::ClientPriorityPolicy::_tao_any_destructor (void *x) +{ + TAO::ClientPriorityPolicy *tmp = ACE_static_cast(TAO::ClientPriorityPolicy*,x); + CORBA::release (tmp); +} + 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; - ACE_TRY_NEW_ENV - { - ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); - *_tao_obj_ptr = TAO::ClientPriorityPolicy::_duplicate (_tao_elem); TAO_OutputCDR stream; - if (stream << *_tao_obj_ptr) + if (stream << _tao_elem) { _tao_any._tao_replace ( - TAO::_tc_ClientPriorityPolicy, + TAO::_tc_ClientPriorityPolicy, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, - _tao_obj_ptr, - ACE_TRY_ENV + _tao_elem, + TAO::ClientPriorityPolicy::_tao_any_destructor ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; } 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->equivalent (TAO::_tc_ClientPriorityPolicy, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -352,24 +319,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO::ClientPriorityPolic { _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)->_tao_replace ( TAO::_tc_ClientPriorityPolicy, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + TAO::ClientPriorityPolicy::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = TAO::ClientPriorityPolicy::_nil (); return 0; } @@ -524,36 +484,26 @@ TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) TAO_NAMESPACE_BEGIN (TAO) TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_BufferingConstraintPolicy, &_tc_TAO_tc_TAO_BufferingConstraintPolicy) TAO_NAMESPACE_END + void operator<<= (CORBA::Any &_tao_any, const TAO::BufferingConstraint &_tao_elem) // copying { - TAO::BufferingConstraint *_any_val = 0; - ACE_NEW (_any_val, TAO::BufferingConstraint (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_any_val; + stream << _tao_elem; _tao_any._tao_replace ( TAO::_tc_BufferingConstraint, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _any_val; - } - ACE_ENDTRY; +} + +void TAO::BufferingConstraint::_tao_any_destructor (void *x) +{ + TAO::BufferingConstraint *tmp = ACE_static_cast(TAO::BufferingConstraint*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, TAO::BufferingConstraint *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -562,16 +512,8 @@ void operator<<= (CORBA::Any &_tao_any, TAO::BufferingConstraint *_tao_elem) // stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + TAO::BufferingConstraint::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO::BufferingConstraint *&_tao_elem) @@ -603,9 +545,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO::BufferingConstraint TAO::_tc_BufferingConstraint, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + TAO::BufferingConstraint::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -619,7 +560,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO::BufferingConstraint { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -654,9 +595,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const TAO::BufferingCons TAO::_tc_BufferingConstraint, 1, ACE_reinterpret_cast (void *, ACE_const_cast (TAO::BufferingConstraint *&, _tao_elem)), - ACE_TRY_ENV + TAO::BufferingConstraint::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -670,58 +610,45 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const TAO::BufferingCons { delete ACE_const_cast (TAO::BufferingConstraint *&, _tao_elem); _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; } +void TAO::BufferingConstraintPolicy::_tao_any_destructor (void *x) +{ + TAO::BufferingConstraintPolicy *tmp = ACE_static_cast(TAO::BufferingConstraintPolicy*,x); + CORBA::release (tmp); +} + 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; - ACE_TRY_NEW_ENV - { - ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr); - *_tao_obj_ptr = TAO::BufferingConstraintPolicy::_duplicate (_tao_elem); TAO_OutputCDR stream; - if (stream << *_tao_obj_ptr) + if (stream << _tao_elem) { _tao_any._tao_replace ( - TAO::_tc_BufferingConstraintPolicy, + TAO::_tc_BufferingConstraintPolicy, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, - _tao_obj_ptr, - ACE_TRY_ENV + _tao_elem, + TAO::BufferingConstraintPolicy::_tao_any_destructor ); - ACE_TRY_CHECK; } - else - { - delete _tao_obj_ptr; - } - } - ACE_CATCHANY - { - delete _tao_obj_ptr; - } - ACE_ENDTRY; } 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->equivalent (TAO::_tc_BufferingConstraintPolicy, ACE_TRY_ENV)) // not equal { - delete tmp; return 0; } ACE_TRY_CHECK; @@ -734,24 +661,17 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO::BufferingConstraint { _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)->_tao_replace ( TAO::_tc_BufferingConstraintPolicy, 1, - tmp, - ACE_TRY_ENV + _tao_elem, + TAO::BufferingConstraintPolicy::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } - else // failure - { - delete tmp; - } } ACE_CATCHANY { - delete tmp; _tao_elem = TAO::BufferingConstraintPolicy::_nil (); return 0; } diff --git a/TAO/tao/TAOC.h b/TAO/tao/TAOC.h index f233e2abbf9..09c2bd5dff3 100644 --- a/TAO/tao/TAOC.h +++ b/TAO/tao/TAOC.h @@ -59,6 +59,8 @@ TAO_NAMESPACE TAO struct TAO_Export PrioritySpecification { + static void _tao_any_destructor (void*); + ACE_NESTED_CLASS (TAO, PrioritySelectionMode) mode; CORBA::Short min_priority; CORBA::Short max_priority; @@ -190,6 +192,7 @@ class TAO_Export ClientPriorityPolicy: public virtual CORBA::Policy { return (TAO::ClientPriorityPolicy_ptr)0; } + static void _tao_any_destructor (void*); virtual ACE_NESTED_CLASS (TAO, PrioritySpecification) priority_specification ( CORBA::Environment &ACE_TRY_ENV = @@ -234,6 +237,8 @@ class TAO_Export ClientPriorityPolicy: public virtual CORBA::Policy struct TAO_Export BufferingConstraint { + static void _tao_any_destructor (void*); + ACE_NESTED_CLASS (TAO, BufferingConstraintMode) mode; TimeBase::TimeT timeout; CORBA::ULong message_count; @@ -366,6 +371,7 @@ class TAO_Export BufferingConstraintPolicy: public virtual CORBA::Policy { return (TAO::BufferingConstraintPolicy_ptr)0; } + static void _tao_any_destructor (void*); virtual ACE_NESTED_CLASS (TAO, BufferingConstraint) buffering_constraint ( CORBA::Environment &ACE_TRY_ENV = @@ -422,33 +428,33 @@ TAO_NAMESPACE_CLOSE // module TAO #if (TAO_HAS_CORBA_MESSAGING == 1) -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const TAO::PrioritySpecification &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, TAO::PrioritySpecification*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, TAO::PrioritySpecification *&); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const TAO::PrioritySpecification *&); // Any operators for interface TAO::ClientPriorityPolicy -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, TAO::ClientPriorityPolicy_ptr); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, TAO::ClientPriorityPolicy *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const TAO::BufferingConstraint &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, TAO::BufferingConstraint*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, TAO::BufferingConstraint *&); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const TAO::BufferingConstraint *&); // Any operators for interface TAO::BufferingConstraintPolicy -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, TAO::BufferingConstraintPolicy_ptr); -CORBA::Boolean operator>>= (const CORBA::Any &, +CORBA::Boolean operator>>= (const CORBA::Any &, TAO::BufferingConstraintPolicy *&); #endif /* TAO_HAS_CORBA_MESSAGING == 1 */ diff --git a/TAO/tao/TAO_Static.dsp b/TAO/tao/TAO_Static.dsp index ebb4a689340..af0b312453c 100644 --- a/TAO/tao/TAO_Static.dsp +++ b/TAO/tao/TAO_Static.dsp @@ -106,6 +106,10 @@ SOURCE=.\Asynch_Invocation.cpp # End Source File
# Begin Source File
+SOURCE=.\BoundsC.cpp
+# End Source File
+# Begin Source File
+
SOURCE=.\Buffering_Constraint_Policy.cpp
# End Source File
# Begin Source File
@@ -158,14 +162,6 @@ SOURCE=.\debug.cpp # End Source File
# Begin Source File
-SOURCE=.\decode.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=.\deep_free.cpp
-# End Source File
-# Begin Source File
-
SOURCE=.\default_client.cpp
# End Source File
# Begin Source File
@@ -222,10 +218,6 @@ SOURCE=.\DynUnion_i.cpp # End Source File
# Begin Source File
-SOURCE=.\encode.cpp
-# End Source File
-# Begin Source File
-
SOURCE=.\Environment.cpp
# End Source File
# Begin Source File
@@ -722,6 +714,10 @@ SOURCE=.\Asynch_Invocation.h # End Source File
# Begin Source File
+SOURCE=.\BoundsC.h
+# End Source File
+# Begin Source File
+
SOURCE=.\Buffering_Constraint_Policy.h
# End Source File
# Begin Source File
@@ -1282,6 +1278,10 @@ SOURCE=.\Asynch_Invocation.i # End Source File
# Begin Source File
+SOURCE=.\BoundsC.i
+# End Source File
+# Begin Source File
+
SOURCE=.\Buffering_Constraint_Policy.i
# End Source File
# Begin Source File
diff --git a/TAO/tao/TimeBaseC.cpp b/TAO/tao/TimeBaseC.cpp index 2d0c76cb4b9..76ba10b4817 100644 --- a/TAO/tao/TimeBaseC.cpp +++ b/TAO/tao/TimeBaseC.cpp @@ -133,34 +133,23 @@ 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 = 0; - ACE_NEW (_any_val, TimeBase::UtcT (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_any_val; + stream << _tao_elem; _tao_any._tao_replace ( TimeBase::_tc_UtcT, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _any_val; - } - ACE_ENDTRY; +} + +void TimeBase::UtcT::_tao_any_destructor (void *x) +{ + TimeBase::UtcT *tmp = ACE_static_cast (TimeBase::UtcT*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, TimeBase::UtcT *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -169,16 +158,8 @@ void operator<<= (CORBA::Any &_tao_any, TimeBase::UtcT *_tao_elem) // non copyin stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + TimeBase::UtcT::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TimeBase::UtcT *&_tao_elem) @@ -210,9 +191,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TimeBase::UtcT *&_tao_el TimeBase::_tc_UtcT, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + TimeBase::UtcT::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -226,7 +206,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TimeBase::UtcT *&_tao_el { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -261,9 +241,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const TimeBase::UtcT *&_ TimeBase::_tc_UtcT, 1, ACE_reinterpret_cast (void *, ACE_const_cast (TimeBase::UtcT *&, _tao_elem)), - ACE_TRY_ENV + TimeBase::UtcT::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -277,7 +256,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const TimeBase::UtcT *&_ { delete ACE_const_cast (TimeBase::UtcT *&, _tao_elem); _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -285,34 +264,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const TimeBase::UtcT *&_ void operator<<= (CORBA::Any &_tao_any, const TimeBase::IntervalT &_tao_elem) // copying { - TimeBase::IntervalT *_any_val = 0; - ACE_NEW (_any_val, TimeBase::IntervalT (_tao_elem)); - if (!_any_val) return; - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; - stream << *_any_val; + stream << _tao_elem; _tao_any._tao_replace ( TimeBase::_tc_IntervalT, TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - _any_val, - ACE_TRY_ENV + stream.begin () ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _any_val; - } - ACE_ENDTRY; +} + +void TimeBase::IntervalT::_tao_any_destructor (void *x) +{ + TimeBase::IntervalT *tmp = ACE_static_cast (TimeBase::IntervalT*,x); + delete tmp; } void operator<<= (CORBA::Any &_tao_any, TimeBase::IntervalT *_tao_elem) // non copying { - ACE_TRY_NEW_ENV - { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( @@ -321,16 +289,8 @@ void operator<<= (CORBA::Any &_tao_any, TimeBase::IntervalT *_tao_elem) // non c stream.begin (), 1, _tao_elem, - ACE_TRY_ENV + TimeBase::IntervalT::_tao_any_destructor ); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - delete _tao_elem; - _tao_elem = 0; - } - ACE_ENDTRY; } CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TimeBase::IntervalT *&_tao_elem) @@ -362,9 +322,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TimeBase::IntervalT *&_t TimeBase::_tc_IntervalT, 1, ACE_reinterpret_cast (void *, _tao_elem), - ACE_TRY_ENV + TimeBase::IntervalT::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -378,7 +337,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TimeBase::IntervalT *&_t { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -413,9 +372,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const TimeBase::Interval TimeBase::_tc_IntervalT, 1, ACE_reinterpret_cast (void *, ACE_const_cast (TimeBase::IntervalT *&, _tao_elem)), - ACE_TRY_ENV + TimeBase::IntervalT::_tao_any_destructor ); - ACE_TRY_CHECK; return 1; } else @@ -429,9 +387,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const TimeBase::Interval { delete ACE_const_cast (TimeBase::IntervalT *&, _tao_elem); _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; } - diff --git a/TAO/tao/TimeBaseC.h b/TAO/tao/TimeBaseC.h index 0e9ae42c769..d88c8a4f723 100644 --- a/TAO/tao/TimeBaseC.h +++ b/TAO/tao/TimeBaseC.h @@ -57,6 +57,8 @@ TAO_NAMESPACE TimeBase struct TAO_Export UtcT { + static void _tao_any_destructor (void*); + TimeT time; CORBA::ULong inacclo; CORBA::UShort inacchi; @@ -96,6 +98,8 @@ TAO_NAMESPACE TimeBase struct TAO_Export IntervalT { + static void _tao_any_destructor (void*); + TimeT lower_bound; TimeT upper_bound; }; @@ -135,21 +139,21 @@ TAO_NAMESPACE TimeBase } TAO_NAMESPACE_CLOSE // module TimeBase -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const TimeBase::UtcT &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, TimeBase::UtcT*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, TimeBase::UtcT *&); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const TimeBase::UtcT *&); -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, const TimeBase::IntervalT &); // copying version -TAO_Export void operator<<= (CORBA::Any &, +TAO_Export void operator<<= (CORBA::Any &, TimeBase::IntervalT*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, TimeBase::IntervalT *&); -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const TimeBase::IntervalT *&); #if defined (__ACE_INLINE__) diff --git a/TAO/tao/Typecode.cpp b/TAO/tao/Typecode.cpp index 03b27e5742b..109d5ac79db 100644 --- a/TAO/tao/Typecode.cpp +++ b/TAO/tao/Typecode.cpp @@ -480,7 +480,7 @@ CORBA_TypeCode::skip_typecode (TAO_InputCDR &stream) case CORBA::tk_string: case CORBA::tk_wstring: case ~0u: - return stream.read_ulong (temp); + return (stream.read_ulong (temp) != 0); // The rest have "complex" parameter lists that are // encoded as bulk octets ... just skip them. @@ -1587,10 +1587,6 @@ CORBA_TypeCode::private_member_count (CORBA::Environment &ACE_TRY_ENV) const ACE_NOTREACHED (return 0); } -// NOTE special calling convention for stream.decode () when we're -// potentially deencapsulating an indirected typecode: the "data2" -// value indicates that this typecode is the parent. See comments at -// stream.decode () for further details. // // Applicable only to struct, union, and except // @@ -1647,27 +1643,14 @@ CORBA_TypeCode::private_member_type (CORBA::ULong slot, { if (!stream.skip_string ()) // skip the name ACE_THROW_RETURN (CORBA::BAD_TYPECODE (), 0); - CORBA::TypeCode::traverse_status status = - stream.decode (CORBA::_tc_TypeCode, - // the typecode will be - // retrieved at the i-th - // location. The decode - // routine will allocate the - // storage to hold a - // typecode - &this->private_state_-> - tc_member_type_list_[i], - this, - // pass ourselves since we - // will be the parent. This - // is the case where the 3rd - // parameter is used in a - // decode method - ACE_TRY_ENV); - ACE_CHECK_RETURN (0); - if (status != CORBA::TypeCode::TRAVERSE_CONTINUE) - ACE_THROW_RETURN (CORBA::BAD_TYPECODE (), 0); + CORBA::TypeCode_ptr& member_type = + this->private_state_->tc_member_type_list_[i]; + CORBA_TypeCode::_tao_decode (this, + stream, + member_type, + ACE_TRY_ENV); + ACE_CHECK_RETURN (0); } this->private_state_->tc_member_type_list_known_ = 1; @@ -1707,10 +1690,6 @@ CORBA_TypeCode::private_member_type (CORBA::ULong slot, else if (!stream.read_ulong (temp) // default used || !stream.read_ulong (temp)) // member count ACE_THROW_RETURN (CORBA::BAD_TYPECODE (), 0); - // Always big enough because labels can only be of a - // few different types of which "long" has the - // largest size. - CORBA::Long scratch; // get the typecode for the discriminator tc = this->discriminator_type (ACE_TRY_ENV); @@ -1722,7 +1701,7 @@ CORBA_TypeCode::private_member_type (CORBA::ULong slot, // the ith entry will have the typecode of the ith guy { CORBA::TypeCode::traverse_status status = - stream.decode (tc.in (), &scratch, this, ACE_TRY_ENV); + stream.skip (tc.in (), ACE_TRY_ENV); // member label ACE_CHECK_RETURN (0); @@ -1730,21 +1709,20 @@ CORBA_TypeCode::private_member_type (CORBA::ULong slot, || !stream.skip_string ()) // skip the name ACE_THROW_RETURN (CORBA::BAD_TYPECODE (), 0); - status = stream.decode (CORBA::_tc_TypeCode, // get the typecode - &private_state_->tc_member_type_list_[i], - this, - ACE_TRY_ENV); + CORBA::TypeCode_ptr& member_type = + this->private_state_->tc_member_type_list_[i]; + CORBA_TypeCode::_tao_decode (this, + stream, + member_type, + ACE_TRY_ENV); ACE_CHECK_RETURN (0); - - if (status != CORBA::TypeCode::TRAVERSE_CONTINUE) - ACE_THROW_RETURN (CORBA::BAD_TYPECODE (), 0); } this->private_state_->tc_member_type_list_known_ = 1; if (slot < mcount) return this->private_state_->tc_member_type_list_[slot]; else - ACE_THROW_RETURN (CORBA::TypeCode::Bounds (), (CORBA::TypeCode_ptr)0); + ACE_THROW_RETURN (CORBA::TypeCode::Bounds (), 0); } ACE_NOTREACHED (break); @@ -1908,10 +1886,6 @@ CORBA_TypeCode::private_member_name (CORBA::ULong slot, ACE_THROW_RETURN (CORBA::BAD_TYPECODE (), 0); else { - CORBA::Long scratch; // always big enough because labels can - // only be of a few different types of - // which "long" has the largest size - // get the typecode for the discriminator tc = this->discriminator_type (ACE_TRY_ENV); // compute the name for all the members and return the @@ -1922,10 +1896,8 @@ CORBA_TypeCode::private_member_name (CORBA::ULong slot, { // the ith entry will have the name of the ith member CORBA::TypeCode::traverse_status status = - stream.decode (tc.in (), - &scratch, - this, - ACE_TRY_ENV); // member label + stream.skip (tc.in (), + ACE_TRY_ENV); // member label ACE_CHECK_RETURN (0); if (status != CORBA::TypeCode::TRAVERSE_CONTINUE) @@ -2092,12 +2064,15 @@ CORBA_TypeCode::private_discriminator_type (CORBA::Environment &ACE_TRY_ENV) con // skip ID and name, and then get the discriminant TC if (!stream.skip_string () // type ID, hidden - || !stream.skip_string () // typedef name - || stream.decode (CORBA::_tc_TypeCode, - &this->private_state_->tc_discriminator_type_, this, - ACE_TRY_ENV) != CORBA::TypeCode::TRAVERSE_CONTINUE) + || !stream.skip_string ()) // typedef name ACE_THROW_RETURN (CORBA::BAD_TYPECODE (), 0); + CORBA_TypeCode::_tao_decode (this, + stream, + this->private_state_->tc_discriminator_type_, + ACE_TRY_ENV); + ACE_CHECK_RETURN (0); + this->private_state_->tc_discriminator_type_known_ = 1; return this->private_state_->tc_discriminator_type_; } @@ -2184,8 +2159,6 @@ CORBA_TypeCode::private_content_type (CORBA::Environment &ACE_TRY_ENV) const { TAO_InputCDR stream (this->buffer_+4, this->length_-4, this->byte_order_); - CORBA::TypeCode::traverse_status status = CORBA::TypeCode::TRAVERSE_STOP; - switch (kind_) { case CORBA::tk_sequence: @@ -2198,18 +2171,14 @@ CORBA_TypeCode::private_content_type (CORBA::Environment &ACE_TRY_ENV) const return this->private_state_->tc_content_type_; // retrieve the content type - status = stream.decode (CORBA::_tc_TypeCode, - &this->private_state_->tc_content_type_, - this, ACE_TRY_ENV); + CORBA_TypeCode::_tao_decode (this, + stream, + this->private_state_->tc_content_type_, + ACE_TRY_ENV); ACE_CHECK_RETURN (0); - if (status != CORBA::TypeCode::TRAVERSE_CONTINUE) // element type - ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0); - else - { - this->private_state_->tc_content_type_known_ = 1; - return this->private_state_->tc_content_type_; - } + this->private_state_->tc_content_type_known_ = 1; + return this->private_state_->tc_content_type_; } ACE_NOTREACHED (break); @@ -2225,18 +2194,14 @@ CORBA_TypeCode::private_content_type (CORBA::Environment &ACE_TRY_ENV) const || !stream.skip_string ()) // name ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0); - status = stream.decode (CORBA::_tc_TypeCode, - &this->private_state_->tc_content_type_, this, - ACE_TRY_ENV); + CORBA_TypeCode::_tao_decode (this, + stream, + this->private_state_->tc_content_type_, + ACE_TRY_ENV); ACE_CHECK_RETURN (0); - if (status != CORBA::TypeCode::TRAVERSE_CONTINUE) - ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0); - else - { - this->private_state_->tc_content_type_known_ = 1; - return this->private_state_->tc_content_type_; - } + this->private_state_->tc_content_type_known_ = 1; + return this->private_state_->tc_content_type_; } /*NOTREACHED*/ @@ -2271,6 +2236,248 @@ CORBA_TypeCode::private_discrim_pad_size (CORBA::Environment &ACE_TRY_ENV) this->private_state_->tc_discrim_pad_size_ = discrim_size; return discrim_size; } + +// **************************************************************** + +void +CORBA_TypeCode::_tao_decode (const CORBA_TypeCode *parent, + TAO_InputCDR &cdr, + CORBA_TypeCode *&x, + CORBA::Environment &ACE_TRY_ENV) +{ + x = 0; + CORBA::ULong kind; + + if (!cdr.read_ulong (kind)) + ACE_THROW (CORBA::BAD_TYPECODE ()); + + static CORBA::TypeCode_ptr tc_consts [CORBA::TC_KIND_COUNT] = + { + CORBA::_tc_null, + CORBA::_tc_void, + CORBA::_tc_short, + CORBA::_tc_long, + CORBA::_tc_ushort, + + CORBA::_tc_ulong, + CORBA::_tc_float, + CORBA::_tc_double, + CORBA::_tc_boolean, + CORBA::_tc_char, + + CORBA::_tc_octet, + CORBA::_tc_any, + CORBA::_tc_TypeCode, + CORBA::_tc_Principal, + + 0, // CORBA::_tc_Object ... type ID is CORBA_Object + 0, // CORBA_tk_struct + 0, // CORBA_tk_union + 0, // CORBA_tk_enum + 0, // CORBA::_tc_string ... unbounded + 0, // CORBA_tk_sequence + 0, // CORBA_tk_array + 0, // CORBA_tk_alias + 0, // CORBA_tk_except + + CORBA::_tc_longlong, + CORBA::_tc_ulonglong, + CORBA::_tc_longdouble, + CORBA::_tc_wchar, + 0 // CORBA::_tc_wstring ... unbounded + }; + + if (kind < CORBA::TC_KIND_COUNT && tc_consts [kind] != 0) + { + // Easy case, the CDR contains no more data, and we can simply + // duplicate one of the TypeCode constants... + x = CORBA::TypeCode::_duplicate (tc_consts [kind]); + return; + } + + if (kind != ~0u && kind >= CORBA::TC_KIND_COUNT) + { + // Invalid kind.... cannot even determine what portion of the + // CDR corresponds to the typecode.... + ACE_THROW (CORBA::BAD_TYPECODE ()); + } + + if (kind == ~0u) + { + // Get the long indicating the encapsulation offset, + // then set up indirection stream that's like "stream" + // but has space enough only for the typecode and the + // length for the encapsulated parameters. + // + // The offset must be negative + CORBA::Long offset; + + if (!cdr.read_long (offset) || offset >= 0) + { + // Since indirected typecodes cannot occur at the + // topmost level, they can occur starting only at the + // second and subsequent levels. This means that a + // normal encoding of that typecode occurred somewhere + // before in the stream. As a result the offset field + // must always be negative. See the CORBA spec for details. + ACE_THROW (CORBA::BAD_TYPECODE ()); + } + + // Slava Galperin <galperin@teknowledge.com> clarifies + // this: + // CORBA Spec says: + // + // The encoding of such an indirection is as a + // TypeCode with a TCKind value that has the special + // value 2^32 -1 (0xffffffff, all ones). Such + // typecodes have a single (simple) parameter, which + // is the long offset (in units of octets) from the + // simple parameter. (This means that an offset of + // negative four (-4) is illegal because it will be + // self-indirecting.) + // (CORBA V2.2 CDR Transfer Syntax February 1998 page 13-17) + // + // This apparently assumes offset from the <em> + // beginning </em> of the simple parameter. + // [Right, because otherwise the value -8 would be + // illegal] + // Because at this point stream is positioned after + // the parameter, we need to account for that when + // constructing indir_stream by subtracting 4 (length + // of the offset parameter itself). + + // TAO_InputCDR indir_stream (*stream, 8, offset + // - 4); + ACE_Message_Block *mb = (ACE_Message_Block *)cdr.start (); + TAO_InputCDR indir_stream (mb->rd_ptr () + offset - 4, + -1 * (offset - 4)); + + if (!indir_stream.good_bit ()) + ACE_THROW (CORBA::BAD_TYPECODE ()); + + // Get "kind" and length of target typecode + // + // XXX this currently assumes the TCKind to which we + // indirect is the same byte order as the "parent" + // typecode -- not the right assumption; see how the + // TypeCode interpreter does it. + + CORBA::ULong indir_kind = 0; + CORBA::ULong indir_len = 0; + + if (!indir_stream.read_ulong (indir_kind) + || indir_kind >= CORBA::TC_KIND_COUNT // no double indirections + || !indir_stream.read_ulong (indir_len)) + ACE_THROW (CORBA::BAD_TYPECODE ()); + + // Now construct indirected typecode. This shares the + // typecode octets with the "parent" typecode, + // increasing the amount of memory sharing and + // reducing the cost of getting typecodes. + ACE_NEW (x, + CORBA::TypeCode ((CORBA::TCKind) indir_kind, + indir_len, + indir_stream.rd_ptr(), + 0, + 0, + // @@ TODO + // Here we lose the parent + // typecode... + ACE_const_cast(CORBA_TypeCode*,parent))); + return; + } + + // The other cases.... + switch (kind) + { + default: + ACE_THROW (CORBA::INTERNAL ()); + + // Some have "simple" parameter lists ... some of these + // also have preallocated constants that could be used. + case CORBA::tk_string: + case CORBA::tk_wstring: + { + CORBA::ULong bound; + + if (!cdr.read_ulong (bound)) + ACE_THROW (CORBA::BAD_TYPECODE ()); + + if (bound == 0) + { + // unbounded string. Let us reuse the ORB owned + // _tc_string or _tc_wstring + if (kind == CORBA::tk_string) + x = CORBA::TypeCode::_duplicate (CORBA::_tc_string); + else + x = CORBA::TypeCode::_duplicate (CORBA::_tc_wstring); + } + else + { + // bounded string. Create a TypeCode. If it is does not + // have a parent, then the application must free it. + + // allocate a new TypeCode + + // This may produce a memory leak, because + // callers are sloppy about removing these + // objects. + CORBA::Long _oc_bounded_string [] = + {TAO_ENCAP_BYTE_ORDER, 0}; + // Bounded string. Save the bounds + _oc_bounded_string [1] = (CORBA::Long) bound; + ACE_NEW (x, + CORBA::TypeCode (ACE_static_cast(CORBA::TCKind, kind), + 8, + ACE_reinterpret_cast(char*,_oc_bounded_string), + 0, + sizeof (CORBA::String_var), + 0)); + } + } + break; + + // The rest have "complex" parameter lists that are + // encoded as bulk octets ... + case CORBA::tk_objref: + case CORBA::tk_struct: + case CORBA::tk_union: + case CORBA::tk_enum: + case CORBA::tk_sequence: + case CORBA::tk_array: + case CORBA::tk_alias: + case CORBA::tk_except: + { + CORBA::ULong length; + + // get the encapsulation length + if (!cdr.read_ulong (length)) + ACE_THROW (CORBA::BAD_TYPECODE ()); + + // If the length is greater that the containing CDR stream + // that is an error... + if (length > cdr.length ()) + ACE_THROW (CORBA::BAD_TYPECODE ()); + + // create a new typecode + ACE_NEW (x, + CORBA::TypeCode ((CORBA::TCKind) kind, + length, + cdr.rd_ptr (), + 0, + 0, + ACE_const_cast (CORBA_TypeCode*,parent))); + // skip length number of bytes in the stream, otherwise we may + // leave the stream in an undefined state + (void) cdr.skip_bytes (length); + } + break; + } // end of switch +} + +// **************************************************************** + + // ************ The following are deprecated **************** // say how many parameters this typecode has; normally a fixed number, @@ -2439,28 +2646,68 @@ CORBA::TypeCode::private_alignment (CORBA::Environment &ACE_TRY_ENV) CORBA::Boolean operator<< (TAO_OutputCDR& cdr, const CORBA::TypeCode *x) { - ACE_TRY_NEW_ENV - { - // @@ This function should *not* use the interpreter, there must - // be a way to do this with just CDR operations!!!! - CORBA::TypeCode::traverse_status status = - TAO_MARSHAL_TYPECODE::instance ()->encode (0, - &x, - 0, - &cdr, - ACE_TRY_ENV); - ACE_TRY_CHECK; + CORBA::ULong kind = + x->kind_; - if (status == CORBA::TypeCode::TRAVERSE_CONTINUE) - return 1; - // else return 0 at the end of the function - } - ACE_CATCH (CORBA_Exception, ex) + if (!cdr.write_ulong (kind)) + return 0; + + switch (kind) { + default: + break; + + // Indirected typecodes can't occur at "top level" like + // this, only nested inside others! + case ~0u: + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, + "indirected typecode at top level!\n")); return 0; + break; + + // A few have "simple" parameter lists + case CORBA::tk_string: + case CORBA::tk_wstring: + { + ACE_TRY_NEW_ENV + { + CORBA::ULong length = + x->length (ACE_TRY_ENV); + ACE_TRY_CHECK; + + if (!cdr.write_ulong (length)) + return 0; + } + ACE_CATCHANY + { + return 0; + } + ACE_ENDTRY; + } + break; + + // The rest have "complex" parameter lists that are + // already encoded as bulk octets ... put length, then + // octets. + case CORBA::tk_objref: + case CORBA::tk_struct: + case CORBA::tk_union: + case CORBA::tk_enum: + case CORBA::tk_sequence: + case CORBA::tk_array: + case CORBA::tk_alias: + case CORBA::tk_except: + { + if (!cdr.write_ulong (x->length_) + || !cdr.write_octet_array ((CORBA::Octet*)x->buffer_, + x->length_)) + return 0; + } + break; } - ACE_ENDTRY; - return 0; + + return 1; } CORBA::Boolean @@ -2468,23 +2715,14 @@ operator>> (TAO_InputCDR& cdr, CORBA::TypeCode *&x) { ACE_TRY_NEW_ENV { - CORBA::TypeCode::traverse_status status = - TAO_MARSHAL_TYPECODE::instance ()->decode (0, - &x, - 0, - &cdr, - ACE_TRY_ENV); + CORBA_TypeCode::_tao_decode (0, cdr, x, ACE_TRY_ENV); ACE_TRY_CHECK; - - if (status != CORBA::TypeCode::TRAVERSE_CONTINUE) - return 0; } - ACE_CATCH (CORBA_Exception, ex) + ACE_CATCHANY { return 0; } ACE_ENDTRY; - return 1; } diff --git a/TAO/tao/Typecode.h b/TAO/tao/Typecode.h index 9b7445ba02c..4d6242c34ba 100644 --- a/TAO/tao/Typecode.h +++ b/TAO/tao/Typecode.h @@ -246,6 +246,13 @@ public: // Deprecated, CORBA 1.2, not fully usable. Returns the number of // parameters that the typecode takes. + static void _tao_decode (const CORBA_TypeCode *parent, + TAO_InputCDR &cdr, + CORBA_TypeCode *&child, + CORBA::Environment &ACE_TRY_ENV); + // CDR decoding: the >> operator is not enough because we must also + // respect the parent/child relationship among TypeCodes. + // private: // // = The guts of the typecode implementation class diff --git a/TAO/tao/UIOP_Profile.cpp b/TAO/tao/UIOP_Profile.cpp index 47747dbbb6e..bdbab63624a 100644 --- a/TAO/tao/UIOP_Profile.cpp +++ b/TAO/tao/UIOP_Profile.cpp @@ -24,7 +24,7 @@ static const char prefix_[] = "uiop"; const char TAO_UIOP_Profile::object_key_delimiter_ = '|'; -char +char TAO_UIOP_Profile::object_key_delimiter (void) const { return TAO_UIOP_Profile::object_key_delimiter_; @@ -316,7 +316,7 @@ TAO_UIOP_Profile::decode (TAO_InputCDR& cdr) if (minor <= TAO_DEF_GIOP_MINOR) this->version_.minor = minor; - + char *rendezvous = 0; // Get rendezvous_point @@ -325,7 +325,7 @@ TAO_UIOP_Profile::decode (TAO_InputCDR& cdr) ACE_DEBUG ((LM_DEBUG, "error decoding UIOP rendezvous_point")); return -1; } - + if (this->object_addr_.set (rendezvous) == -1) { if (TAO_debug_level > 0) diff --git a/TAO/tao/append.cpp b/TAO/tao/append.cpp index 2fdf7870a95..fb30811a89c 100644 --- a/TAO/tao/append.cpp +++ b/TAO/tao/append.cpp @@ -103,27 +103,20 @@ TAO_Marshal_Any::append (CORBA::TypeCode_ptr, // Typecode of the element that makes the Any. CORBA::TypeCode_var elem_tc; - // Status of append operation. - // Decode the typecode description for the element so that we can append the - // data appropriately + if (!(*src >> elem_tc.inout ())) + ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, + CORBA::COMPLETED_MAYBE), + CORBA::TypeCode::TRAVERSE_STOP); + + if (!(*dest << elem_tc.in ())) + ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, + CORBA::COMPLETED_MAYBE), + CORBA::TypeCode::TRAVERSE_STOP); + + // append the data CORBA::TypeCode::traverse_status retval = - src->decode (CORBA::_tc_TypeCode, - &elem_tc.inout (), - 0, - ACE_TRY_ENV); + dest->append (elem_tc.in (), src, ACE_TRY_ENV); ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - if (retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - // encode the typecode - retval = dest->encode (CORBA::_tc_TypeCode, &elem_tc, 0, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - if (retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - // append the data - retval = dest->append (elem_tc.in (), src, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - } - } if (retval != CORBA::TypeCode::TRAVERSE_CONTINUE) { @@ -357,163 +350,221 @@ TAO_Marshal_Struct::append (CORBA::TypeCode_ptr tc, // Encode unions. CORBA::TypeCode::traverse_status -TAO_Marshal_Union::append (CORBA::TypeCode_ptr tc, +TAO_Marshal_Union::append (CORBA::TypeCode_ptr tc, TAO_InputCDR *src, TAO_OutputCDR *dest, CORBA::Environment &ACE_TRY_ENV) { - CORBA::TypeCode::traverse_status retval = - CORBA::TypeCode::TRAVERSE_CONTINUE; + CORBA::TypeCode_ptr discrim_tc = + tc->discriminator_type (ACE_TRY_ENV); + ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - CORBA::TypeCode_ptr discrim_tc; - CORBA::TypeCode_var member_tc; - CORBA::Any_ptr member_label; - CORBA::ULongLong discrim_val; - CORBA::ULong member_count; - CORBA::Long default_index; - CORBA::ULong i; - CORBA::TypeCode_ptr default_tc = 0; - CORBA::Boolean discrim_matched = 0; - - // get the discriminator type - discrim_tc = tc->discriminator_type (ACE_TRY_ENV); + CORBA::ULong kind = + discrim_tc->kind (ACE_TRY_ENV); ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - // decode the discriminator value - retval = src->decode (discrim_tc, &discrim_val, 0, ACE_TRY_ENV); + // Save the discriminator value in a temporary variable... + CORBA::Short short_v; + CORBA::UShort ushort_v; + CORBA::Long long_v; + CORBA::ULong ulong_v; + CORBA::ULong enum_v; + CORBA::Char char_v; + CORBA::WChar wchar_v; + CORBA::Boolean boolean_v; + + switch (kind) + { + case CORBA::tk_short: + { + if (!src->read_short (short_v) + || !dest->write_short (short_v)) + return CORBA::TypeCode::TRAVERSE_STOP; + } + break; + + case CORBA::tk_ushort: + { + if (!src->read_ushort (ushort_v) + || !dest->write_ushort (ushort_v)) + return CORBA::TypeCode::TRAVERSE_STOP; + } + break; + + case CORBA::tk_long: + { + if (!src->read_long (long_v) + || !dest->write_long (long_v)) + return CORBA::TypeCode::TRAVERSE_STOP; + } + break; + + case CORBA::tk_ulong: + { + if (!src->read_ulong (ulong_v) + || !dest->write_ulong (ulong_v)) + return CORBA::TypeCode::TRAVERSE_STOP; + } + break; + + case CORBA::tk_enum: + { + if (!src->read_ulong (enum_v) + || !dest->write_ulong (enum_v)) + return CORBA::TypeCode::TRAVERSE_STOP; + } + break; + + case CORBA::tk_char: + { + if (!src->read_char (char_v) + || !dest->write_char (char_v)) + return CORBA::TypeCode::TRAVERSE_STOP; + } + break; + + case CORBA::tk_wchar: + { + if (!src->read_wchar (wchar_v) + || !dest->write_wchar (wchar_v)) + return CORBA::TypeCode::TRAVERSE_STOP; + } + break; + + case CORBA::tk_boolean: + { + if (!src->read_boolean (boolean_v) + || !dest->write_boolean (boolean_v)) + return CORBA::TypeCode::TRAVERSE_STOP; + } + break; + + default: + return CORBA::TypeCode::TRAVERSE_STOP; + } + + CORBA::ULong member_count = + tc->member_count (ACE_TRY_ENV); ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - if (retval == CORBA::TypeCode::TRAVERSE_CONTINUE) + + CORBA::ULong current_member = ~0UL; + CORBA::ULong default_member = ~0UL; + for (CORBA::ULong i = 0; + i != member_count && current_member == ~0UL; + ++i) { - // write the discriminant back to the dest - retval = dest->encode (discrim_tc, &discrim_val, 0, ACE_TRY_ENV); + CORBA::Any *any = + tc->member_label (i, ACE_TRY_ENV); ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - if (retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - // now get ready to marshal the actual union value - default_index = tc->default_index (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - member_count = tc->member_count (ACE_TRY_ENV); + CORBA::Octet o; + if ((*any >>= CORBA::Any::to_octet (o)) && o == 0) + { + CORBA::ULong default_index = + tc->default_index (ACE_TRY_ENV); ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - // check which label value matches with the discriminator - // value. Accordingly, marshal the corresponding - // member_type. If none match, check if default exists - // and marshal accordingly. Otherwise it is an error. + if (i != default_index) + ACE_THROW_RETURN (CORBA::BAD_TYPECODE (), + CORBA::TypeCode::TRAVERSE_STOP); + // Found the default branch, save its position and continue + // trying to find the current value... + default_member = i; + continue; + } - for (i = 0; member_count-- != 0; i++) - { - member_label = tc->member_label (i, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - CORBA::TypeCode_var type = member_label->type (); - // do the matching - switch (type->kind (ACE_TRY_ENV)) - { - case CORBA::tk_short: - { - CORBA::Short s; - *member_label >>= s; - if (s == *(CORBA::Short *) &discrim_val) - discrim_matched = 1; - } - break; - case CORBA::tk_ushort: - { - CORBA::UShort s; - *member_label >>= s; - if (s == *(CORBA::UShort *) &discrim_val) - discrim_matched = 1; - } - break; - case CORBA::tk_long: - { - CORBA::Long l; - *member_label >>= l; - if (l == *(CORBA::Long *) &discrim_val) - discrim_matched = 1; - } - break; - case CORBA::tk_ulong: - { - CORBA::ULong l; - *member_label >>= l; - if (l == *(CORBA::ULong *) &discrim_val) - discrim_matched = 1; - } - break; - case CORBA::tk_enum: - { - CORBA::Long l; - TAO_InputCDR stream (member_label->_tao_get_cdr (), - member_label->_tao_byte_order ()); - (void)stream.decode (discrim_tc, &l, 0, ACE_TRY_ENV); - if (l == *(CORBA::Long *) &discrim_val) - discrim_matched = 1; - } - break; - case CORBA::tk_char: - { - CORBA::Char c; - *member_label >>= CORBA::Any::to_char (c); - if (c == *(CORBA::Char *) &discrim_val) - discrim_matched = 1; - } - break; - case CORBA::tk_wchar: - { - CORBA::WChar wc; - *member_label >>= CORBA::Any::to_wchar (wc); - if (wc == *(CORBA::WChar *) &discrim_val) - discrim_matched = 1; - } - break; - case CORBA::tk_boolean: - { - CORBA::Boolean b; - *member_label >>= CORBA::Any::to_boolean (b); - if (b == *(CORBA::Boolean *) &discrim_val) - discrim_matched = 1; - } - break; - default: - ACE_THROW_RETURN (CORBA::BAD_TYPECODE (), - CORBA::TypeCode::TRAVERSE_STOP); - }// end of switch - - // get the member typecode - member_tc = tc->member_type (i, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - if (default_index >= 0 && default_index-- == 0) - // have we reached the default label?, if so, - // save a handle to the typecode for the default - default_tc = member_tc.in (); - if (discrim_matched) - { - // marshal according to the matched typecode - return dest->append (member_tc.in (), src, ACE_TRY_ENV); - } - } // end of for loop - // we are here only if there was no match - if (default_tc) - { - return dest->append (default_tc, src, ACE_TRY_ENV); - } - else - return CORBA::TypeCode::TRAVERSE_CONTINUE; + switch (kind) + { + case CORBA::tk_short: + { + CORBA::Short d; + if ((*any >>= d) && d == short_v) + current_member = i; + } + break; + + case CORBA::tk_ushort: + { + CORBA::UShort d; + if ((*any >>= d) && d == ushort_v) + current_member = i; + } + break; + + case CORBA::tk_long: + { + CORBA::Long d; + if ((*any >>= d) && d == long_v) + current_member = i; + } + break; + + case CORBA::tk_ulong: + { + CORBA::ULong d; + if ((*any >>= d) && d == ulong_v) + current_member = i; + } + break; + + case CORBA::tk_enum: + { + CORBA::ULong d; + // @@ Will this work???? + if ((*any >>= d) && d == enum_v) + current_member = i; + } + break; + + case CORBA::tk_char: + { + CORBA::Char d; + if ((*any >>= CORBA::Any::to_char (d)) && d == char_v) + current_member = i; + } + break; + + case CORBA::tk_wchar: + { + CORBA::WChar d; + if ((*any >>= CORBA::Any::to_wchar (d)) && d == wchar_v) + current_member = i; + } + break; + + case CORBA::tk_boolean: + { + CORBA::Boolean d; + if ((*any >>= CORBA::Any::to_boolean (d)) && d == boolean_v) + current_member = i; + } + break; + + default: + return CORBA::TypeCode::TRAVERSE_STOP; } - else + } + + if (current_member == ~0UL) + { + // Cannot find the current member, check if there is a + // default... + if (default_member != ~0UL) { - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_MAYBE), - CORBA::TypeCode::TRAVERSE_STOP); + // Good, use the default to append... + CORBA::TypeCode_ptr member_tc = + tc->member_type (default_member, ACE_TRY_ENV); + ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); + return dest->append (member_tc, src, ACE_TRY_ENV); } + return CORBA::TypeCode::TRAVERSE_STOP; } - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_MAYBE), - CORBA::TypeCode::TRAVERSE_STOP); + // If we found the member successfully then just use that one... + CORBA::TypeCode_ptr member_tc = + tc->member_type (current_member, ACE_TRY_ENV); + ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); + return dest->append (member_tc, src, ACE_TRY_ENV); } // decode string diff --git a/TAO/tao/decode.cpp b/TAO/tao/decode.cpp deleted file mode 100644 index 54a67bba637..00000000000 --- a/TAO/tao/decode.cpp +++ /dev/null @@ -1,1483 +0,0 @@ -// $Id$ - -// ============================================================================ -// -// = LIBRARY -// TAO -// -// = FILENAME -// decode.cpp -// -// = DESCRIPTION -// Code for decoding different data types -// -// The original code had a single static decoder function defined on -// the CDR class that called traverse to interpret the data -// types. This version defines a virtual method "decode" on each -// class and avoids calling traverse. -// -// = AUTHOR -// Copyright 1994-1995 by Sun Microsystems Inc. -// and -// Aniruddha Gokhale -// -// ============================================================================ - -#include "tao/Marshal.h" -#include "tao/CDR.h" -#include "tao/Environment.h" -#include "tao/Any.h" -#include "tao/Principal.h" -#include "tao/MProfile.h" -#include "tao/Object.h" -#include "tao/Stub.h" -#include "tao/varout.h" -#include "tao/ORB.h" -#include "tao/Union.h" -#include "tao/ORB_Core.h" -#include "tao/debug.h" - -ACE_RCSID(tao, decode, "$Id$") - -// The decoder is exactly the reverse of the encoder, except that: -// -// * Unmarshaling some data types involve allocating memory. Such -// types include sequences (the buffer), objrefs, Principals, Anys, -// TypeCodes, and strings. -// -// * The decoder is used when retrieving typecode parameters from -// encapsulations. This means it must deal with "CORBA::tk_indirect", -// the magic value (~0u) signifying typecode indirection. -// -// This second case is identified by a bit of a hack: the second -// "data" value is used to hold the parent typecode, rather than being -// ignored. This means that all other invocations of decoder () ** -// MUST ** pass zero for the second data parameter, in case they -// decode a TypeCode. If they didn't, this case might be signified -// inappropriately. -// -// XXX desirable to have a less hacky solution to that ... pull that -// code out into a separate routine called both by CDR::decoder () and -// by the code retrieving typecode parameters from encapsulations. - -typedef TAO_Object_Field_T<CORBA::Object,CORBA::Object_var> TAO_Object_Field_Class; - -CORBA::TypeCode::traverse_status -TAO_Marshal_Primitive::decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA::Environment &ACE_TRY_ENV) -{ - CORBA::Boolean continue_decoding = 1; - TAO_InputCDR *stream = (TAO_InputCDR *) context; - CORBA::TypeCode::traverse_status retval = - CORBA::TypeCode::TRAVERSE_CONTINUE; // status of encode operation - - switch (tc->kind_) - { - case CORBA::tk_null: - case CORBA::tk_void: - break; - case CORBA::tk_short: - case CORBA::tk_ushort: - continue_decoding = stream->read_short (*(CORBA::Short *) data); - break; - case CORBA::tk_long: - case CORBA::tk_ulong: - case CORBA::tk_float: - case CORBA::tk_enum: - continue_decoding = stream->read_long (*(CORBA::Long *) data); - break; - case CORBA::tk_double: - case CORBA::tk_longlong: - case CORBA::tk_ulonglong: - continue_decoding = stream->read_longlong (*(CORBA::LongLong *) data); - break; - case CORBA::tk_boolean: - continue_decoding = stream->read_boolean (*(CORBA::Boolean *) data); - break; - case CORBA::tk_char: - case CORBA::tk_octet: - continue_decoding = stream->read_char (*(CORBA::Char *) data); - break; - case CORBA::tk_longdouble: - continue_decoding = stream->read_longdouble (*(CORBA::LongDouble *) data); - break; - case CORBA::tk_wchar: - continue_decoding = stream->read_wchar (*(CORBA::WChar *) data); - break; - default: - retval = CORBA::TypeCode::TRAVERSE_STOP; - // we are not a primitive type - } - if (retval != CORBA::TypeCode::TRAVERSE_CONTINUE - || continue_decoding != 1) - { - if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("TAO_Marshal_Primitive::decode detected error\n"))); - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_MAYBE), - CORBA::TypeCode::TRAVERSE_STOP); - } - return CORBA::TypeCode::TRAVERSE_CONTINUE; -} - -CORBA::TypeCode::traverse_status -TAO_Marshal_Any::decode (CORBA::TypeCode_ptr, - const void *data, - const void *, - void *context, - CORBA::Environment &ACE_TRY_ENV) -{ - CORBA::Any *any = (CORBA::Any *) data; - - // Typecode of the element that makes the Any. - CORBA::TypeCode_var elem_tc; - - // Context is the CDR stream. - TAO_InputCDR *stream = (TAO_InputCDR *) context; - - // Status of encode operation. - CORBA::TypeCode::traverse_status retval = - CORBA::TypeCode::TRAVERSE_CONTINUE; - - // Decode the typecode description for the element. - retval = stream->decode (CORBA::_tc_TypeCode, - &elem_tc.out (), - 0, - ACE_TRY_ENV); - ACE_CHECK_RETURN (retval); - if (retval != CORBA::TypeCode::TRAVERSE_CONTINUE) - return retval; - - // Let the Any maintain a pointer to the CDR stream - // @@ ASG + CORYAN - The following commented line would have been a great - // optimization. However, it turns out that although the Message_Block is - // heap-allocated, the actual buffer i.e., data block is allocated on the - // function call stack. Once we are out of these chain of functions and - // return into the stub, we have lost the activation record for the - // actual buffer. Hence it makes no sense keeping pointers to stack - // memory. - // - // See TAO_Stub.cpp::do_static_call in which a GIOP_Invocation is - // allocated on stack -#if 0 - any->byte_order_ = stream->byte_order (); - any->cdr_ = ACE_CDR::consolidate (stream->start ()); -#endif - // one solution is to heap allocate the GIOP_Invocation. However, that - // would be bad since not all requests will use Anys. - // - // One solution is to allocate a new Message_Block with its own heap - // allocated data_block. (We may optimize this using allocators for known - // sizes). We allocate a Message_Block of the size that is required by - // the data type held by the Any. To find what is the size of this data - // in the CDR, we traverse the CDR by skipping past this data type. We - // then get an offset using the "begin" and "end" shown below that tells - // us the size. The skipping is done on a temporary CDR stream and not on - // the actual incoming CDR stream. Once we have allocated a new - // Message_Block, we simply append the data into it from the original CDR - // stream. - char *begin, *end; - TAO_InputCDR temp (*stream); - - begin = stream->rd_ptr (); - retval = temp.skip (elem_tc.in (), ACE_TRY_ENV); - ACE_CHECK_RETURN (retval); - - if (retval != CORBA::TypeCode::TRAVERSE_CONTINUE) - return retval; - - end = temp.rd_ptr (); - - // We need to allocate more memory than in the original - // stream, first to guarantee that the buffer is aligned in - // memory and next because the realignment may introduce - // extra padding. 2*MAX_ALIGNMENT should be enough. - // @@EXC@@ This doesn't seem to be exception safe. - TAO_OutputCDR out (end - begin + 2 * ACE_CDR::MAX_ALIGNMENT); - - retval = out.append (elem_tc.in (), stream, ACE_TRY_ENV); - ACE_CHECK_RETURN (retval); - if (retval != CORBA::TypeCode::TRAVERSE_CONTINUE) - return retval; - - ACE_Message_Block::release (any->cdr_); - if (any->any_owns_data_ && any->value_ != 0) - DEEP_FREE (any->type_, any->value_, 0, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - any->byte_order_ = stream->byte_order (); - ACE_NEW_RETURN (any->cdr_, ACE_Message_Block, - CORBA::TypeCode::TRAVERSE_STOP); - ACE_CDR::consolidate (any->cdr_, out.begin ()); - any->value_ = 0; - - if (any->type_) - CORBA::release (any->type_); - - any->type_ = elem_tc._retn (); - any->any_owns_data_ = 0; - - if (retval != CORBA::TypeCode::TRAVERSE_CONTINUE) - { - if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("TAO_Marshal_Any::decode detected error\n"))); - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_MAYBE), - retval); - } - return retval; -} - -CORBA::TypeCode::traverse_status -TAO_Marshal_TypeCode::decode (CORBA::TypeCode_ptr, - const void *data, - const void *parent_typecode, - void *context, - CORBA::Environment &ACE_TRY_ENV) -{ - CORBA::Boolean continue_decoding = 1; - - // Context is the CDR stream. - TAO_InputCDR *stream = (TAO_InputCDR *) context; - - // Typecode to be decoded. - CORBA::TypeCode_ptr *tcp; - - // Typecode kind. - CORBA::ULong kind; - - static CORBA::TypeCode_ptr tc_consts [CORBA::TC_KIND_COUNT] = - { - CORBA::_tc_null, - CORBA::_tc_void, - CORBA::_tc_short, - CORBA::_tc_long, - CORBA::_tc_ushort, - - CORBA::_tc_ulong, - CORBA::_tc_float, - CORBA::_tc_double, - CORBA::_tc_boolean, - CORBA::_tc_char, - - CORBA::_tc_octet, - CORBA::_tc_any, - CORBA::_tc_TypeCode, - CORBA::_tc_Principal, - - 0, // CORBA::_tc_Object ... type ID is CORBA_Object - 0, // CORBA_tk_struct - 0, // CORBA_tk_union - 0, // CORBA_tk_enum - 0, // CORBA::_tc_string ... unbounded - 0, // CORBA_tk_sequence - 0, // CORBA_tk_array - 0, // CORBA_tk_alias - 0, // CORBA_tk_except - - CORBA::_tc_longlong, - CORBA::_tc_ulonglong, - CORBA::_tc_longdouble, - CORBA::_tc_wchar, - 0 // CORBA::_tc_wstring ... unbounded - }; - - // TypeCode for the parent. The most likely situation when a parent will be - // provided is when we are precomputing the private state of an IDL compiler - // generated or an ORB owned TypeCode, OR we are decoding an indirected - // TypeCode. In such circumstances, the decoded - // TypeCode will share resources with its parent and cannot be freed until - // its parent is being freed. - CORBA::TypeCode_ptr parent = (CORBA::TypeCode_ptr) parent_typecode; - - // Decode the "kind" field of the typecode from the stream - continue_decoding = stream->read_ulong (kind); - - if (continue_decoding == 1) - { - // The data has to be a TypeCode_ptr *. - tcp = (CORBA::TypeCode_ptr *) data; - - // Typecodes with empty parameter lists all have preallocated - // constants. We use those to reduce memory consumption and - // heap access ... also, to speed things up! - if (kind < CORBA::TC_KIND_COUNT - && (*tcp = tc_consts [(u_int) kind]) != 0) - // parent is ignored - *tcp = CORBA::TypeCode::_duplicate (tc_consts [(u_int) kind]); - else if (kind == ~0u || kind < CORBA::TC_KIND_COUNT) - { - // Either a non-constant typecode or an indirected typecode. - switch (kind) - { - // Need special handling for all kinds of typecodes that - // have nonempty parameter lists ... - default: - // Error: missed a case! - ACE_THROW_RETURN (CORBA::INTERNAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_MAYBE), CORBA::TypeCode::TRAVERSE_STOP); - - // Some have "simple" parameter lists ... some of these - // also have preallocated constants that could be used. - case CORBA::tk_string: - case CORBA::tk_wstring: - { - CORBA::ULong bound; - - continue_decoding = stream->read_ulong (bound); - if (continue_decoding) - { - if (bound == 0) - { - // unbounded string. Let us reuse the ORB owned - // _tc_string or _tc_wstring - if (kind == CORBA::tk_string) - *tcp = CORBA::TypeCode::_duplicate - (CORBA::_tc_string); - else - *tcp = CORBA::TypeCode::_duplicate - (CORBA::_tc_wstring); - } - else - { - // bounded string. Create a TypeCode. If it is does not - // have a parent, then the application must free it. - - // allocate a new TypeCode - - // This may produce a memory leak, because - // callers are sloppy about removing these - // objects. - CORBA::Long _oc_bounded_string [] = - {TAO_ENCAP_BYTE_ORDER, 0}; - // Bounded string. Save the bounds - _oc_bounded_string [1] = (CORBA::Long) bound; - ACE_NEW_THROW_EX (*tcp, - CORBA::TypeCode (ACE_static_cast(CORBA::TCKind, kind), - 8, - ACE_reinterpret_cast(char*,_oc_bounded_string), - 0, sizeof - (CORBA::String_var), 0), - CORBA::NO_MEMORY ()); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - } - } - } - break; - - // Indirected typecodes, illegal at "top level" but we - // allow unmarshaling of them here because we use the same - // code to read "off the wire" (where they're illegal) and - // to read out of an encapsulation stream. We distinguish - // the case where this is legal as described above. - case ~0u: - { - if (parent_typecode == 0) - ACE_THROW_RETURN (CORBA::INTERNAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_MAYBE), CORBA::TypeCode::TRAVERSE_STOP); - - // Get the long indicating the encapsulation offset, - // then set up indirection stream that's like "stream" - // but has space enough only for the typecode and the - // length for the encapsulated parameters. - // - // The offset must be negative - CORBA::Long offset; - - continue_decoding = stream->read_long (offset); - if (continue_decoding) - { - // Since indirected typecodes cannot occur at the - // topmost level, they can occur starting only at the - // second and subsequent levels. This means that a - // normal encoding of that typecode occurred somewhere - // before in the stream. As a result the offset field - // must always be negative. See the CORBA spec for details. - continue_decoding = (offset < 0); - } - - // Slava Galperin <galperin@teknowledge.com> clarifies - // this: - // CORBA Spec says: - // - // The encoding of such an indirection is as a - // TypeCode with a TCKind value that has the special - // value 2^32 -1 (0xffffffff, all ones). Such - // typecodes have a single (simple) parameter, which - // is the long offset (in units of octets) from the - // simple parameter. (This means that an offset of - // negative four (-4) is illegal because it will be - // self-indirecting.) - // (CORBA V2.2 CDR Transfer Syntax February 1998 page 13-17) - // - // This apparently assumes offset from the <em> - // beginning </em> of the simple parameter. - // [Right, because otherwise the value -8 would be - // illegal] - // Because at this point stream is positioned after - // the parameter, we need to account for that when - // constructing indir_stream by subtracting 4 (length - // of the offset parameter itself). - - // TAO_InputCDR indir_stream (*stream, 8, offset - // - 4); - ACE_Message_Block *mb = (ACE_Message_Block *)stream->start (); - TAO_InputCDR indir_stream (mb->rd_ptr () + offset - 4, - -1 * (offset - 4)); - - - continue_decoding = (CORBA::Boolean) indir_stream.good_bit (); - - // Get "kind" and length of target typecode - // - // XXX this currently assumes the TCKind to which we - // indirect is the same byte order as the "parent" - // typecode -- not the right assumption; see how the - // TypeCode interpreter does it. - - CORBA::ULong indir_kind = 0; - CORBA::ULong indir_len = 0; - - // retrieve the typecode kind - if (continue_decoding) - continue_decoding = indir_stream.read_ulong (indir_kind); - - if (continue_decoding - && indir_kind >= CORBA::TC_KIND_COUNT) - continue_decoding = 0; - - // now retrieve the encapsulation length - if (continue_decoding) - continue_decoding = indir_stream.read_ulong (indir_len); - - // Now construct indirected typecode. This shares the - // typecode octets with the "parent" typecode, - // increasing the amount of memory sharing and - // reducing the cost of getting typecodes. - if (continue_decoding) - { - ACE_NEW_THROW_EX (*tcp, - CORBA::TypeCode ((CORBA::TCKind) indir_kind, - indir_len, - indir_stream.rd_ptr(), - 0, - 0, - parent), - CORBA::NO_MEMORY ()); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - } - } - break; - - // The rest have "complex" parameter lists that are - // encoded as bulk octets ... - case CORBA::tk_objref: - case CORBA::tk_struct: - case CORBA::tk_union: - case CORBA::tk_enum: - case CORBA::tk_sequence: - case CORBA::tk_array: - case CORBA::tk_alias: - case CORBA::tk_except: - { - CORBA::ULong length; - - // get the encapsulation length - continue_decoding = stream->read_ulong (length); - if (!continue_decoding) - break; - - // if length > MAXUNSIGNED, error ... - u_int len = (u_int) length; - - // create a new typecode - ACE_NEW_THROW_EX (*tcp, - CORBA::TypeCode ((CORBA::TCKind) kind, - len, - stream->rd_ptr (), - 0, - 0, - parent), - CORBA::NO_MEMORY ()); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - // skip length number of bytes in the stream, else we may - // leave the stream in an undefined state - (void) stream->skip_bytes (length); - } - } // end of switch - } - else // bad kind_ value to be decoded - { - if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("TAO_Marshal_TypeCode:decode: ") - ASYS_TEXT ("Bad kind_ value in CDR stream\n"))); - ACE_THROW_RETURN ( CORBA::BAD_TYPECODE (), CORBA::TypeCode::TRAVERSE_STOP); - } - } - - if (continue_decoding != 1) - { - if (TAO_debug_level) - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("TAO_Marshal_TypeCode::decode detected error\n"))); - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_MAYBE), - CORBA::TypeCode::TRAVERSE_STOP); - } - return CORBA::TypeCode::TRAVERSE_CONTINUE; -} - -// Encode Principal. - -CORBA::TypeCode::traverse_status -TAO_Marshal_Principal::decode (CORBA::TypeCode_ptr, - const void *data, - const void *, - void *context, - CORBA::Environment &ACE_TRY_ENV) -{ - // Context is the CDR stream. - TAO_InputCDR *stream = (TAO_InputCDR *) context; - - CORBA::Principal_ptr x; - - if ((*stream >> x) == 0) - { - *(CORBA_Principal_ptr*)data = CORBA::Principal::_nil (); - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_MAYBE), - CORBA::TypeCode::TRAVERSE_STOP); - } - - *(CORBA_Principal **)data = x; - return CORBA::TypeCode::TRAVERSE_CONTINUE; -} - -// Decode obj ref. An IOR -CORBA::TypeCode::traverse_status -TAO_Marshal_ObjRef::decode (CORBA::TypeCode_ptr, - const void *data, // where the result will go - const void *, - void *context, - CORBA::Environment &ACE_TRY_ENV) -{ - // Context is the CDR stream. - TAO_InputCDR *stream = (TAO_InputCDR *) context; - - CORBA::Object_ptr object; - - if ((*stream >> object) == 0) - { - *(CORBA_Object_ptr*)data = CORBA::Object::_nil (); - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_MAYBE), CORBA::TypeCode::TRAVERSE_STOP); - } - - *(CORBA_Object **)data = object; - return CORBA::TypeCode::TRAVERSE_CONTINUE; -} - -// Decode structs. -CORBA::TypeCode::traverse_status -TAO_Marshal_Struct::decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA::Environment &ACE_TRY_ENV) -{ - TAO_InputCDR *stream = (TAO_InputCDR *) context; - CORBA::TypeCode::traverse_status retval = - CORBA::TypeCode::TRAVERSE_CONTINUE; - CORBA::Boolean continue_decoding = 1; - CORBA::TypeCode_var param; - CORBA::Long size, alignment, align_offset; - - void *start_addr = (void *)data; - - // Number of fields in the struct. - int member_count = tc->member_count (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - for (int i = 0; i < member_count - && retval == CORBA::TypeCode::TRAVERSE_CONTINUE - && continue_decoding == 1; - i++) - { - param = tc->member_type (i, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - size = param->size (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - alignment = param->alignment (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - align_offset = - (ptr_arith_t) ACE_ptr_align_binary (data, alignment) - - (ptr_arith_t) data - - ((ptr_arith_t) ACE_ptr_align_binary (start_addr, alignment) - - (ptr_arith_t) start_addr); - if (align_offset < 0) - align_offset += alignment; - - // if both the start_addr and data are not aligned as per - // the alignment, we do not add the offset - data = (const void *) ((ptr_arith_t) data + - ((align_offset == alignment) ? - 0 : align_offset)); - switch (param->kind_) - { - case CORBA::tk_null: - case CORBA::tk_void: - break; - case CORBA::tk_short: - case CORBA::tk_ushort: - continue_decoding = - stream->read_short (*(CORBA::Short *) data); - break; - case CORBA::tk_long: - case CORBA::tk_ulong: - case CORBA::tk_float: - case CORBA::tk_enum: - continue_decoding = - stream->read_long (*(CORBA::Long *) data); - break; - case CORBA::tk_double: - case CORBA::tk_longlong: - case CORBA::tk_ulonglong: - continue_decoding = - stream->read_longlong (*(CORBA::LongLong *) data); - break; - case CORBA::tk_boolean: - continue_decoding = - stream->read_boolean (*(CORBA::Boolean *) data); - break; - case CORBA::tk_char: - case CORBA::tk_octet: - continue_decoding = - stream->read_char (*(CORBA::Char *) data); - break; - case CORBA::tk_longdouble: - continue_decoding = - stream->read_longdouble (*(CORBA::LongDouble *) data); - break; - case CORBA::tk_wchar: - continue_decoding = - stream->read_wchar (*(CORBA::WChar *) data); - break; - case CORBA::tk_TypeCode: - case CORBA::tk_any: - case CORBA::tk_Principal: - case CORBA::tk_struct: - case CORBA::tk_union: - case CORBA::tk_sequence: - case CORBA::tk_array: - case CORBA::tk_alias: - case CORBA::tk_except: - case CORBA::tk_string: - case CORBA::tk_wstring: - retval = stream->decode (param.in (), data, 0, ACE_TRY_ENV); - break; - - case CORBA::tk_objref: - { - CORBA_Object_ptr object; - retval = stream->decode (param.in (), &object, 0, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - if (retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - TAO_Object_Field_Class* field = - ACE_reinterpret_cast (TAO_Object_Field_Class *, - ACE_const_cast (void *, data)); - field->_downcast (object, ACE_TRY_ENV); - } - } - break; - - default: - break; - } - data = (char *) data + size; - } - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - if (retval != CORBA::TypeCode::TRAVERSE_CONTINUE) - { - if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("TAO_Marshal_Struct::decode detected error\n"))); - - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_MAYBE), - CORBA::TypeCode::TRAVERSE_STOP); - } - return CORBA::TypeCode::TRAVERSE_CONTINUE; -} - -// Encode unions. -CORBA::TypeCode::traverse_status -TAO_Marshal_Union::decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *data2, - void *context, - CORBA::Environment &ACE_TRY_ENV) -{ - // Context is the CDR stream. - TAO_InputCDR *stream = (TAO_InputCDR *) context; - - CORBA::TypeCode_var discrim_tc; - CORBA::TypeCode_var member_tc = 0; - CORBA::Any_ptr member_label; - CORBA::ULong discrim_size_with_pad; - const void *discrim_val; - CORBA::ULong member_count; - CORBA::Long default_index; - CORBA::ULong i; - CORBA::TypeCode_ptr default_tc = 0; - CORBA::Boolean discrim_matched = 0; - TAO_Base_Union *base_union = (TAO_Base_Union *)data; - void *member_val; - - discrim_tc = tc->discriminator_type (ACE_TRY_ENV); - // get the discriminator type - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - // decode the discriminator value - discrim_val = base_union->_discriminant (); - stream->decode (discrim_tc.in (), discrim_val, data2, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - discrim_size_with_pad = tc->TAO_discrim_pad_size (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - // move the pointer to point to the actual value - data = (char *) data + discrim_size_with_pad; - data2 = (char *) data2 + discrim_size_with_pad; - - // now get ready to marshal the actual union value - default_index = tc->default_index (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - member_count = tc->member_count (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - // check which label value matches with the discriminator - // value. Accordingly, marshal the corresponding - // member_type. If none match, check if default exists - // and marshal accordingly. Otherwise it is an error. - - for (i = 0; member_count-- != 0; i++) - { - member_label = tc->member_label (i, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - // do the matching - CORBA::TypeCode_var type = member_label->type (); - switch (type->kind (ACE_TRY_ENV)) // kind() doesn't throw any exception. - { - case CORBA::tk_short: - { - CORBA::Short s; - *member_label >>= s; - if (s == *(CORBA::Short *) discrim_val) - discrim_matched = 1; - } - break; - case CORBA::tk_ushort: - { - CORBA::UShort s; - *member_label >>= s; - if (s == *(CORBA::UShort *) discrim_val) - discrim_matched = 1; - } - break; - case CORBA::tk_long: - { - CORBA::Long l; - *member_label >>= l; - if (l == *(CORBA::Long *) discrim_val) - discrim_matched = 1; - } - break; - case CORBA::tk_ulong: - { - CORBA::ULong l; - *member_label >>= l; - if (l == *(CORBA::ULong *) discrim_val) - discrim_matched = 1; - } - break; - case CORBA::tk_enum: - { - CORBA::ULong ul; - TAO_InputCDR stream ((ACE_Message_Block *) - member_label->_tao_get_cdr (), - member_label->_tao_byte_order ()); - (void)stream.decode (discrim_tc.in (), &ul, 0, ACE_TRY_ENV); - //@@EXC@@ Rethrow CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_MAYBE)? - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - if (ul == *(CORBA::ULong *) discrim_val) - discrim_matched = 1; - } - break; - case CORBA::tk_char: - { - CORBA::Char c; - *member_label >>= CORBA::Any::to_char (c); - if (c == *(CORBA::Char *) discrim_val) - discrim_matched = 1; - } - break; - case CORBA::tk_wchar: - CORBA::WChar wc; - *member_label >>= CORBA::Any::to_wchar (wc); - if (wc == *(CORBA::WChar *) discrim_val) - discrim_matched = 1; - break; - case CORBA::tk_boolean: - { - CORBA::Boolean b; - *member_label >>= CORBA::Any::to_boolean (b); - if (b == *(CORBA::Boolean *) discrim_val) - discrim_matched = 1; - } - break; - default: - ACE_THROW_RETURN (CORBA::BAD_TYPECODE (), CORBA::TypeCode::TRAVERSE_STOP); - }// end of switch - - // get the member typecode - member_tc = tc->member_type (i, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - // have we reached the default label?, if so, - // save a handle to the typecode for the default - if (default_index >= 0 && default_index-- == 0) - default_tc = member_tc.in (); - if (discrim_matched) - { - member_val = base_union->_access (1); - // marshal according to the matched typecode - if (member_tc->kind () == CORBA::tk_objref) - { - CORBA_Object_ptr object; - int retval = - stream->decode (member_tc.in (), &object, data2, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - if (retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - // we know that the object pointer is stored in a - // TAO_Object_Field_T parametrized type - TAO_Object_Field_Class* field = - ACE_reinterpret_cast (TAO_Object_Field_Class *, - member_val); - field->_downcast (object, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - } - return CORBA::TypeCode::TRAVERSE_CONTINUE; - } - else - { - return stream->decode (member_tc.in (), member_val, - data2, ACE_TRY_ENV); - } - } - } // end of for loop - - // we are here only if there was no match - if (default_tc) - { - member_val = base_union->_access (1); - if (default_tc->kind () == CORBA::tk_objref) - { - CORBA_Object_ptr object; - int retval = - stream->decode (member_tc.in (), &object, data2, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - if (retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - // we know that the object pointer is stored in a - // TAO_Object_Field_T parametrized type - TAO_Object_Field_Class* field = - ACE_reinterpret_cast (TAO_Object_Field_Class *, - member_val); - field->_downcast (object, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - } - return CORBA::TypeCode::TRAVERSE_CONTINUE; - } - else - { - return stream->decode (default_tc, member_val, - data2, ACE_TRY_ENV); - } - } - else - return CORBA::TypeCode::TRAVERSE_CONTINUE; -} - -// decode string -CORBA::TypeCode::traverse_status -TAO_Marshal_String::decode (CORBA::TypeCode_ptr, - const void *data, - const void *, - void *context, - CORBA::Environment &ACE_TRY_ENV) -{ - CORBA::Boolean continue_decoding = 1; - // Context is the CDR stream. - TAO_InputCDR *stream = (TAO_InputCDR *) context; - - char ** str_ptr = (char**)data; - - // On decode, omit the check against specified string bounds, and - // cope with illegal "zero length" strings (all lengths on the wire - // must include a NUL). - // - // This is on the principle of being gracious in what we accept; we - // don't generate messages that fail to comply with protocol specs, - // but we will accept them when it's clear how to do so. - - continue_decoding = stream->read_string (*str_ptr); - if (continue_decoding != 1) - { - if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("TAO_Marshal_String::decode detected error\n"))); - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_MAYBE), - CORBA::TypeCode::TRAVERSE_STOP); - } - return CORBA::TypeCode::TRAVERSE_CONTINUE; -} - -// Decode sequence. - -CORBA::TypeCode::traverse_status -TAO_Marshal_Sequence::decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA::Environment &ACE_TRY_ENV) -{ - CORBA::Boolean continue_decoding = 1; - TAO_InputCDR *stream = (TAO_InputCDR *) context; - TAO_Base_Sequence *seq = (TAO_Base_Sequence *)data; - // Return status. - CORBA::TypeCode::traverse_status retval = - CORBA::TypeCode::TRAVERSE_CONTINUE; - // Typecode of the element. - CORBA::TypeCode_var tc2; - // Size of element. - size_t size; - CORBA::ULong bounds; - char *value; - - // First unmarshal the sequence length ... we trust it to be right - // here, on the "be gracious in what you accept" principle. We - // don't generate illegal sequences (i.e. length > bounds). - - continue_decoding = stream->read_ulong (bounds); - - if (continue_decoding) - { - // No point decoding an empty sequence. - if (bounds > 0) - { - // Get element typecode. - tc2 = tc->content_type (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - size = tc2->size (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - -#if defined (TAO_NO_COPY_OCTET_SEQUENCES) - // The treatment of octet sequences is completely - // different. - if (tc2->kind_ == CORBA::tk_octet - && ACE_BIT_DISABLED (stream->start ()->flags (), - ACE_Message_Block::DONT_DELETE)) - { - TAO_Unbounded_Sequence<CORBA::Octet>* seq2 = - ACE_dynamic_cast(TAO_Unbounded_Sequence<CORBA::Octet>*, seq); - seq2->replace (bounds, stream->start ()); - seq2->mb ()->wr_ptr (seq2->mb ()->rd_ptr () + bounds); - stream->skip_bytes (bounds); - return CORBA::TypeCode::TRAVERSE_CONTINUE; - } -#endif /* defined (TAO_NO_COPY_OCTET_SEQUENCES) */ - - // Allocate the buffer using the virtual - // _allocate_buffer method, hence the right - // constructors are invoked and size for the array - // is OK. The sequence will release it, since its - // release_ field is 1. - if (seq->maximum_ < bounds) - { - seq->_deallocate_buffer (); - seq->maximum_ = bounds; - seq->release_ = 1; - seq->buffer_ = 0; - seq->_allocate_buffer (bounds); - } - // In any case the sequence length is changed. - seq->length_ = bounds; - - - value = (char *) seq->buffer_; - - switch (tc2->kind_) - { - case CORBA::tk_null: - case CORBA::tk_void: - return CORBA::TypeCode::TRAVERSE_CONTINUE; - - case CORBA::tk_short: - case CORBA::tk_ushort: - // For primitives, compute the size only once - continue_decoding = continue_decoding && - stream->read_short_array - ((CORBA::Short *) value, bounds); - if (continue_decoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - - case CORBA::tk_long: - case CORBA::tk_ulong: - case CORBA::tk_float: - case CORBA::tk_enum: - // For primitives, compute the size only once - continue_decoding = continue_decoding && - stream->read_long_array - ((CORBA::Long *) value, bounds); - if (continue_decoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - - case CORBA::tk_double: - case CORBA::tk_longlong: - case CORBA::tk_ulonglong: - // For primitives, compute the size only once - continue_decoding = continue_decoding && - stream->read_longlong_array - ((CORBA::LongLong *) value, bounds); - if (continue_decoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - - case CORBA::tk_boolean: - // For primitives, compute the size only once - continue_decoding = continue_decoding && - stream->read_octet_array - ((CORBA::Octet *) value, bounds); - if (continue_decoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - - case CORBA::tk_char: - // For primitives, compute the size only once - continue_decoding = continue_decoding && - stream->read_char_array - ((CORBA::Char *) value, bounds); - if (continue_decoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - - case CORBA::tk_octet: - // For primitives, compute the size only once - continue_decoding = continue_decoding && - stream->read_octet_array - ((CORBA::Octet *) value, bounds); - if (continue_decoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - - case CORBA::tk_longdouble: - // For primitives, compute the size only once - continue_decoding = continue_decoding && - stream->read_longdouble_array - ((CORBA::LongDouble *) value, bounds); - if (continue_decoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - - case CORBA::tk_wchar: - // For primitives, compute the size only once - continue_decoding = continue_decoding && - stream->read_wchar_array - ((CORBA::WChar *) value, bounds); - if (continue_decoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - - // handle all aggregate types here - case CORBA::tk_string: - case CORBA::tk_wstring: - case CORBA::tk_any: - case CORBA::tk_TypeCode: - case CORBA::tk_Principal: - case CORBA::tk_struct: - case CORBA::tk_union: - case CORBA::tk_sequence: - case CORBA::tk_array: - case CORBA::tk_alias: - case CORBA::tk_except: - // For those aggregate types whose size is - // constant, we compute it only once. - while (bounds-- && retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - retval = stream->decode (tc2.in (), - value, - 0, - ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - value += size; - } - // CORBA::release (tc2); - return retval; - - case CORBA::tk_objref: - { - size = sizeof (CORBA_Object_ptr); - while (bounds-- && - retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - CORBA_Object_ptr ptr; - retval = stream->decode (tc2.in (), - &ptr, - 0, - ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - seq->_downcast (value, ptr, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - CORBA::release (ptr); - value += size; - } - return retval; - } - - default: - break; - } // end of switch - } // length is > 0 - else - return CORBA::TypeCode::TRAVERSE_CONTINUE; - } - ACE_THROW_RETURN (CORBA::MARSHAL (), - CORBA::TypeCode::TRAVERSE_STOP); -} - -// Decode array. - -CORBA::TypeCode::traverse_status -TAO_Marshal_Array::decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA::Environment &ACE_TRY_ENV) -{ - CORBA::Boolean continue_decoding = 1; - TAO_InputCDR *stream = (TAO_InputCDR *) context; - - // Return status. - CORBA::TypeCode::traverse_status retval = - CORBA::TypeCode::TRAVERSE_CONTINUE; - - // Typecode of the element. - CORBA::TypeCode_var tc2; - - // Size of element. - size_t size; - CORBA::ULong bounds; - char *value = (char *) data; - - // retrieve the bounds of the array - bounds = tc->length (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - // get element typecode - tc2 = tc->content_type (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - size = tc2->size (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - switch (tc2->kind_) - { - case CORBA::tk_null: - case CORBA::tk_void: - return CORBA::TypeCode::TRAVERSE_CONTINUE; - - case CORBA::tk_short: - case CORBA::tk_ushort: - // For primitives, compute the size only once - continue_decoding = continue_decoding && - stream->read_short_array - ((CORBA::Short *) value, bounds); - if (continue_decoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - - case CORBA::tk_long: - case CORBA::tk_ulong: - case CORBA::tk_float: - case CORBA::tk_enum: - // For primitives, compute the size only once - continue_decoding = continue_decoding && - stream->read_long_array - ((CORBA::Long *) value, bounds); - if (continue_decoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - - case CORBA::tk_double: - case CORBA::tk_longlong: - case CORBA::tk_ulonglong: - // For primitives, compute the size only once - continue_decoding = continue_decoding && - stream->read_longlong_array - ((CORBA::LongLong *) value, bounds); - if (continue_decoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - - case CORBA::tk_boolean: - // For primitives, compute the size only once - continue_decoding = continue_decoding && - stream->read_octet_array - ((CORBA::Octet *) value, bounds); - if (continue_decoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - - case CORBA::tk_char: - case CORBA::tk_octet: - // For primitives, compute the size only once - continue_decoding = continue_decoding && - stream->read_octet_array - ((CORBA::Octet *) value, bounds); - if (continue_decoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - - case CORBA::tk_longdouble: - // For primitives, compute the size only once - continue_decoding = continue_decoding && - stream->read_longdouble_array - ((CORBA::LongDouble *) value, bounds); - if (continue_decoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - - case CORBA::tk_wchar: - // For primitives, compute the size only once - continue_decoding = continue_decoding && - stream->read_wchar_array - ((CORBA::WChar *) value, bounds); - if (continue_decoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - - // handle all aggregate types here - case CORBA::tk_any: - case CORBA::tk_TypeCode: - case CORBA::tk_Principal: - case CORBA::tk_objref: - case CORBA::tk_struct: - case CORBA::tk_union: - case CORBA::tk_string: - case CORBA::tk_sequence: - case CORBA::tk_array: - case CORBA::tk_alias: - case CORBA::tk_except: - case CORBA::tk_wstring: - // For those aggregate types whose size is constant, we - // compute it only once - while (bounds-- && retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - retval = stream->decode (tc2.in (), value, 0, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - value += size; - } - // CORBA::release (tc2); - return retval; - default: - break; - } // end of switch - - // error exit - if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("TAO_Marshal_Sequence::decode detected error\n"))); - ACE_THROW_RETURN (CORBA::MARSHAL (), - CORBA::TypeCode::TRAVERSE_STOP); -} - -// Decode alias. -CORBA::TypeCode::traverse_status -TAO_Marshal_Alias::decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA::Environment &ACE_TRY_ENV) -{ - // Typecode of the aliased type. - CORBA::TypeCode_var tc2; - CORBA::Boolean continue_decoding = 1; - - // Context is the CDR stream. - TAO_InputCDR *stream = (TAO_InputCDR *) context; - - // Status of decode operation. - CORBA::TypeCode::traverse_status retval = - CORBA::TypeCode::TRAVERSE_CONTINUE; - char *value = (char *) data; - - tc2 = tc->content_type (ACE_TRY_ENV); - // @@EXC@@ Rethrow CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_MAYBE)? - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - // Switch on the data type and handle the cases for primitives - // here for efficiency rather than calling. - switch (tc2->kind_) - { - case CORBA::tk_null: - case CORBA::tk_void: - break; - case CORBA::tk_short: - case CORBA::tk_ushort: - continue_decoding = - stream->read_short (*(CORBA::Short *) value); - break; - case CORBA::tk_long: - case CORBA::tk_ulong: - case CORBA::tk_float: - case CORBA::tk_enum: - continue_decoding = - stream->read_long (*(CORBA::Long *) value); - break; - case CORBA::tk_double: - case CORBA::tk_longlong: - case CORBA::tk_ulonglong: - continue_decoding = - stream->read_longlong (*(CORBA::LongLong *) value); - break; - case CORBA::tk_boolean: - continue_decoding = - stream->read_boolean (*(CORBA::Boolean *) value); - break; - case CORBA::tk_char: - case CORBA::tk_octet: - continue_decoding = - stream->read_char (*(CORBA::Char *) value); - break; - case CORBA::tk_longdouble: - continue_decoding = - stream->read_longdouble (*(CORBA::LongDouble *) value); - break; - case CORBA::tk_wchar: - continue_decoding = - stream->read_wchar (*(CORBA::WChar *) value); - break; - case CORBA::tk_string: - case CORBA::tk_wstring: - case CORBA::tk_any: - case CORBA::tk_TypeCode: - case CORBA::tk_Principal: - case CORBA::tk_objref: - case CORBA::tk_struct: - case CORBA::tk_union: - case CORBA::tk_sequence: - case CORBA::tk_array: - case CORBA::tk_alias: - case CORBA::tk_except: - retval = stream->decode (tc2.in (), data, 0, ACE_TRY_ENV); - // @@EXC@@ Rethrow CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_MAYBE)? - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - break; - default: - // anything else is an error - retval = CORBA::TypeCode::TRAVERSE_STOP; - } - - if (retval != CORBA::TypeCode::TRAVERSE_CONTINUE - || continue_decoding != 1) - { - if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("TAO_Marshal_Except::decode detected error\n"))); - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_MAYBE), - CORBA::TypeCode::TRAVERSE_STOP); - } - return CORBA::TypeCode::TRAVERSE_CONTINUE; -} - -// Decode exception For exceptions, the "hidden" type ID near the -// front of the on-wire representation was previously unmarshaled and -// mapped to the "tc" typcode we're using to traverse the memory ... -// at the same time its vtable, refcount, and other state was -// established. -// -// NOTE: This is asymmetric with respect to encoding exceptions. -CORBA::TypeCode::traverse_status -TAO_Marshal_Except::decode (CORBA::TypeCode_ptr, - const void *, - const void *, - void *, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_MAYBE), - CORBA::TypeCode::TRAVERSE_STOP); -} - -// decode wstring -CORBA::TypeCode::traverse_status -TAO_Marshal_WString::decode (CORBA::TypeCode_ptr, - const void *data, - const void *, - void *context, - CORBA::Environment &ACE_TRY_ENV) -{ - CORBA::Boolean continue_decoding = 1; - TAO_InputCDR *stream = (TAO_InputCDR *) context; - CORBA::WChar *str = *(CORBA::WChar **) data; - CORBA::ULong len; - - // On decode, omit the check against specified wstring bounds, and - // cope with illegal "zero length" strings (all lengths on the wire - // must include a NUL). - // - // This is on the principle of being gracious in what we accept; we - // don't generate messages that fail to comply with protocol specs, - // but we will accept them when it's clear how to do so. - - continue_decoding = stream->read_ulong (len); - - ACE_NEW_RETURN (str, - CORBA::WChar [(size_t) (len)], - CORBA::TypeCode::TRAVERSE_CONTINUE); - *((CORBA::WChar **) data) = str; - - if (len != 0) - while (continue_decoding != 0 && len--) - { - continue_decoding = stream->read_wchar (*str); - str++; - } - - if (continue_decoding != 1) - { - if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("TAO_Marshal_WString::decode detected error\n"))); - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_MAYBE), - CORBA::TypeCode::TRAVERSE_STOP); - } - return CORBA::TypeCode::TRAVERSE_CONTINUE; -} diff --git a/TAO/tao/deep_free.cpp b/TAO/tao/deep_free.cpp deleted file mode 100644 index d5fcae12cb2..00000000000 --- a/TAO/tao/deep_free.cpp +++ /dev/null @@ -1,810 +0,0 @@ -// ============================================================================ -// -// $Id$ -// -// = LIBRARY -// TAO -// -// = FILENAME -// deep_free.cpp -// -// = DESCRIPTION -// Code for deep_free -// The original code had a single static deep_free function that called -// traverse to interpret the data types. This version defines a static method -// "deep_free" on each class and avoids calling traverse. -// -// Helper routine for "Any" destructor. -// -// This frees all the memory pointed to by any given value held inside -// of an "Any". For most data types it does nothing, since most data -// types don't hold any memory. For a few, it calls other deep_free methods -// to free the memory -// -// = AUTHOR -// Copyright 1994-1995 by Sun Microsystems Inc. -// and -// Aniruddha Gokhale -// -// ============================================================================ - -#include "tao/Marshal.h" -#include "tao/CDR.h" -#include "tao/Environment.h" -#include "tao/Any.h" -#include "tao/Object.h" -#include "tao/Stub.h" -#include "tao/Principal.h" -#include "tao/varout.h" -#include "tao/Union.h" -#include "tao/debug.h" - -ACE_RCSID(tao, deep_free, "$Id$") - -CORBA::TypeCode::traverse_status -DEEP_FREE (CORBA::TypeCode_ptr param, - const void *source, - const void *dest, - CORBA::Environment &ACE_TRY_ENV) -{ - CORBA::TypeCode::traverse_status retval = CORBA::TypeCode::TRAVERSE_CONTINUE; - - // Since every exception-throwing function is followed by break and then return, - // we'll just skip the checking here. - switch (param->kind_) - { - case CORBA::tk_null: - case CORBA::tk_void: - case CORBA::tk_short: - case CORBA::tk_ushort: - case CORBA::tk_long: - case CORBA::tk_ulong: - case CORBA::tk_float: - case CORBA::tk_enum: - case CORBA::tk_double: - case CORBA::tk_longlong: - case CORBA::tk_ulonglong: - case CORBA::tk_boolean: - case CORBA::tk_char: - case CORBA::tk_octet: - case CORBA::tk_longdouble: - case CORBA::tk_wchar: - break; - case CORBA::tk_any: - retval = TAO_Marshal_Any::deep_free (param, source, dest, ACE_TRY_ENV); - break; - case CORBA::tk_TypeCode: - retval = TAO_Marshal_TypeCode::deep_free (param, source, dest, ACE_TRY_ENV); - break; - case CORBA::tk_Principal: - retval = TAO_Marshal_Principal::deep_free (param, source, dest, ACE_TRY_ENV); - break; - case CORBA::tk_objref: - retval = TAO_Marshal_ObjRef::deep_free (param, source, dest, ACE_TRY_ENV); - break; - case CORBA::tk_struct: - retval = TAO_Marshal_Struct::deep_free (param, source, dest, ACE_TRY_ENV); - break; - case CORBA::tk_union: - retval = TAO_Marshal_Union::deep_free (param, source, dest, ACE_TRY_ENV); - break; - case CORBA::tk_string: - retval = TAO_Marshal_String::deep_free (param, source, dest, ACE_TRY_ENV); - break; - case CORBA::tk_sequence: - retval = TAO_Marshal_Sequence::deep_free (param, source, dest, ACE_TRY_ENV); - // @@ (JP) This takes care of a memory leak we had for recursive unions - // and unions that contain an anonymous sequence. For unions that contain - // typedef'd sequences and other cases where the union member is a - // pointer, we still have leaks. These are not so easy to fix for all - // cases. What we need is Carlos' _tao_destroy() method in the stubs. - delete ACE_reinterpret_cast (TAO_Base_Sequence *, - ACE_const_cast (void *, - source)); - break; - case CORBA::tk_array: - retval = TAO_Marshal_Array::deep_free (param, source, dest, ACE_TRY_ENV); - break; - case CORBA::tk_alias: - retval = TAO_Marshal_Alias::deep_free (param, source, dest, ACE_TRY_ENV); - break; - case CORBA::tk_except: - retval = TAO_Marshal_Except::deep_free (param, source, dest, ACE_TRY_ENV); - break; - case CORBA::tk_wstring: - retval = TAO_Marshal_WString::deep_free (param, source, dest, ACE_TRY_ENV); - break; - default: - retval = CORBA::TypeCode::TRAVERSE_STOP; - } // end of switch - - return retval; -} - -// deep free for primitives -CORBA::TypeCode::traverse_status -TAO_Marshal_Primitive::deep_free (CORBA::TypeCode_ptr tc, - const void *, - const void *, - CORBA::Environment &ACE_TRY_ENV) -{ - CORBA::TCKind my_kind; - - if (!tc) - { - if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("TAO_Marshal_Primitive::deep_free detected error\n"))); - ACE_THROW_RETURN (CORBA::BAD_TYPECODE (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_MAYBE), CORBA::TypeCode::TRAVERSE_STOP); - } - - my_kind = tc->kind (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - switch (my_kind) - { - case CORBA::tk_null: - case CORBA::tk_void: - case CORBA::tk_char: - case CORBA::tk_octet: - case CORBA::tk_short: - case CORBA::tk_ushort: - case CORBA::tk_wchar: - case CORBA::tk_long: - case CORBA::tk_ulong: - case CORBA::tk_float: - case CORBA::tk_enum: - case CORBA::tk_longlong: - case CORBA::tk_ulonglong: - case CORBA::tk_double: - case CORBA::tk_longdouble: - case CORBA::tk_boolean: - break; - default: - if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("TAO_Marshal_Primitive::deep_free detected error\n"))); - ACE_THROW_RETURN (CORBA::BAD_TYPECODE (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_MAYBE), - CORBA::TypeCode::TRAVERSE_STOP); - } - return CORBA::TypeCode::TRAVERSE_CONTINUE; -} - -// deep_free structs -CORBA::TypeCode::traverse_status -TAO_Marshal_Struct::deep_free (CORBA::TypeCode_ptr tc, - const void *source, - const void *dest, - CORBA::Environment &ACE_TRY_ENV) -{ - if (!tc) - { - if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("TAO_Marshal_Struct::deep_free detected error\n"))); - ACE_THROW_RETURN (CORBA::BAD_TYPECODE (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_MAYBE), CORBA::TypeCode::TRAVERSE_STOP); - } - - // In case this hasn't been done yet. - source = ACE_ptr_align_binary (source, - tc->alignment (ACE_TRY_ENV)); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - CORBA::TypeCode::traverse_status retval = CORBA::TypeCode::TRAVERSE_CONTINUE; - CORBA::TypeCode_var param; - CORBA::Long size, alignment, align_offset; - - void *start_addr = (void *)source; - - // Number of fields in the struct. - // compute the number of fields in the struct - int member_count = tc->member_count (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - for (int i = 0; i < member_count && retval == - CORBA::TypeCode::TRAVERSE_CONTINUE; i++) - { - // get the typecode for the ith field - param = tc->member_type (i, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - // get the size of the field - size = param->size (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - alignment = param->alignment (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - align_offset = - (ptr_arith_t) ACE_ptr_align_binary (source, alignment) - - (ptr_arith_t) source - - ((ptr_arith_t) ACE_ptr_align_binary (start_addr, alignment) - - (ptr_arith_t) start_addr); - if (align_offset < 0) - align_offset += alignment; - - // if both the start_addr and data are not aligned as per - // the alignment, we do not add the offset - source = (const void *) ((ptr_arith_t) source + - ((align_offset == alignment) ? - 0 : align_offset)); - - // Since every exception-throwing function is followed by a break, we'll just - // check for exception after the switch. - switch (param->kind_) - { - case CORBA::tk_null: - case CORBA::tk_void: - case CORBA::tk_short: - case CORBA::tk_ushort: - case CORBA::tk_long: - case CORBA::tk_ulong: - case CORBA::tk_float: - case CORBA::tk_enum: - case CORBA::tk_double: - case CORBA::tk_longlong: - case CORBA::tk_ulonglong: - case CORBA::tk_boolean: - case CORBA::tk_char: - case CORBA::tk_octet: - case CORBA::tk_longdouble: - case CORBA::tk_wchar: - break; - case CORBA::tk_any: - retval = TAO_Marshal_Any::deep_free (param.in (), source, dest, ACE_TRY_ENV); - break; - case CORBA::tk_TypeCode: - retval = TAO_Marshal_TypeCode::deep_free (param.in (), source, dest, ACE_TRY_ENV); - break; - case CORBA::tk_Principal: - retval = TAO_Marshal_Principal::deep_free (param.in (), source, dest, ACE_TRY_ENV); - break; - - case CORBA::tk_objref: - { - typedef TAO_Object_Field_T<CORBA::Object,CORBA::Object_var> - TAO_Object_Field_Class; - TAO_Object_Field_Class* field = - ACE_reinterpret_cast (TAO_Object_Field_Class *, - ACE_const_cast (void *, source)); - field->_release (); - retval = CORBA::TypeCode::TRAVERSE_CONTINUE; - } - break; - - case CORBA::tk_struct: - retval = TAO_Marshal_Struct::deep_free (param.in (), source, dest, ACE_TRY_ENV); - break; - case CORBA::tk_union: - retval = TAO_Marshal_Union::deep_free (param.in (), source, dest, ACE_TRY_ENV); - break; - case CORBA::tk_string: - retval = TAO_Marshal_String::deep_free (param.in (), source, dest, ACE_TRY_ENV); - break; - case CORBA::tk_sequence: - retval = TAO_Marshal_Sequence::deep_free (param.in (), source, dest, ACE_TRY_ENV); - break; - case CORBA::tk_array: - retval = TAO_Marshal_Array::deep_free (param.in (), source, dest, ACE_TRY_ENV); - break; - case CORBA::tk_alias: - retval = TAO_Marshal_Alias::deep_free (param.in (), source, dest, ACE_TRY_ENV); - break; - case CORBA::tk_except: - retval = TAO_Marshal_Except::deep_free (param.in (), source, dest, ACE_TRY_ENV); - break; - case CORBA::tk_wstring: - retval = TAO_Marshal_WString::deep_free (param.in (), source, dest, ACE_TRY_ENV); - break; - default: - retval = CORBA::TypeCode::TRAVERSE_STOP; - } // end of switch - source = (char *)source + size; - } // end of loop - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - if (retval != CORBA::TypeCode::TRAVERSE_CONTINUE) - { - if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("TAO_Marshal_Struct::deep_free detected error\n"))); - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_MAYBE), - CORBA::TypeCode::TRAVERSE_STOP); - } - return CORBA::TypeCode::TRAVERSE_CONTINUE; -} - -// deep_free for union -CORBA::TypeCode::traverse_status -TAO_Marshal_Union::deep_free (CORBA::TypeCode_ptr tc, - const void *data, - const void *data2, - CORBA::Environment &ACE_TRY_ENV) -{ - CORBA::TypeCode::traverse_status retval = CORBA::TypeCode::TRAVERSE_CONTINUE; - CORBA::TypeCode_var discrim_tc; - CORBA::TypeCode_var member_tc; - CORBA::Any_ptr member_label; - const void *discrim_val; - CORBA::ULong member_count; - CORBA::Long default_index; - CORBA::ULong i; - CORBA::TypeCode_ptr default_tc = 0; - CORBA::Boolean discrim_matched = 0; - TAO_Base_Union *base_union; - void *member_val; - - // Get a base pointer so we can use the union's virtual functions. - base_union = ACE_reinterpret_cast (TAO_Base_Union *, - ACE_const_cast (void *, - data)); - - discrim_tc = tc->discriminator_type (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - discrim_val = base_union->_discriminant (); - // Get a pointer to the discriminator value. - - member_val = base_union->_access (0); - // Get a pointer to the member, but don't allocate new storage. - - default_index = tc->default_index (ACE_TRY_ENV); - // now get ready to marshal the actual union value - ACE_CHECK_RETURN ( CORBA::TypeCode::TRAVERSE_STOP); - - member_count = tc->member_count (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - // check which label value matches with the discriminator - // value. Accordingly, marshal the corresponding - // member_type. If none match, check if default exists - // and marshal accordingly. Otherwise it is an error. - for (i = 0; member_count-- != 0; i++) - { - member_label = tc->member_label (i, ACE_TRY_ENV); - ACE_CHECK_RETURN ( CORBA::TypeCode::TRAVERSE_STOP); - - // do the matching - CORBA::TypeCode_var type = member_label->type (); - switch (type->kind (ACE_TRY_ENV)) - { - // @@ This is not going to work, it assumes that the CDR - // stream is in the same byte order. - case CORBA::tk_short: - if (*(CORBA::Short *)member_label->_tao_get_cdr ()->base () == - *(CORBA::Short *)discrim_val) - discrim_matched = 1; - break; - case CORBA::tk_ushort: - if (*(CORBA::UShort *)member_label->_tao_get_cdr ()->base () == - *(CORBA::UShort *)discrim_val) - discrim_matched = 1; - break; - case CORBA::tk_long: - if (*(CORBA::Long *)member_label->_tao_get_cdr ()->base () == - *(CORBA::Long *)discrim_val) - discrim_matched = 1; - break; - case CORBA::tk_ulong: - case CORBA::tk_enum: - if (*(CORBA::ULong *)member_label->_tao_get_cdr ()->base () == - *(CORBA::ULong *)discrim_val) - discrim_matched = 1; - break; - case CORBA::tk_char: - if (*(CORBA::Char *)member_label->_tao_get_cdr ()->base () == - *(CORBA::Char *)discrim_val) - discrim_matched = 1; - break; - case CORBA::tk_wchar: - if (*(CORBA::WChar *)member_label->_tao_get_cdr ()->base () == - *(CORBA::WChar *)discrim_val) - discrim_matched = 1; - break; - case CORBA::tk_boolean: - if (*(CORBA::Boolean *)member_label->_tao_get_cdr ()->base () == - *(CORBA::Boolean *)discrim_val) - discrim_matched = 1; - break; - default: - ACE_THROW_RETURN (CORBA::BAD_TYPECODE (), - CORBA::TypeCode::TRAVERSE_STOP); - }// end of switch - - // get the member typecode - member_tc = tc->member_type (i, ACE_TRY_ENV); - ACE_CHECK_RETURN ( CORBA::TypeCode::TRAVERSE_STOP); - - if (default_index >= 0 && default_index-- == 0) - { - // have we reached the default label?, if so, - // save a handle to the typecode for the default - default_tc = member_tc.in (); - } - if (discrim_matched) - { - // deep_free the discriminator value - retval = DEEP_FREE (discrim_tc.in (), - discrim_val, - data2, - ACE_TRY_ENV); - - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - if (retval != CORBA::TypeCode::TRAVERSE_CONTINUE) - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_MAYBE), - CORBA::TypeCode::TRAVERSE_STOP); - - // marshal according to the matched typecode - return DEEP_FREE (member_tc.in (), - member_val, - data2, - ACE_TRY_ENV); - } // end of if - } // end of for - - // we are here only if there was no match - - // deep_free the discriminator value - retval = DEEP_FREE (discrim_tc.in (), - discrim_val, - data2, - ACE_TRY_ENV); - - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - if (retval != CORBA::TypeCode::TRAVERSE_CONTINUE) - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_MAYBE), - CORBA::TypeCode::TRAVERSE_STOP); - - if (default_tc) - return DEEP_FREE (default_tc, - member_val, - data2, - ACE_TRY_ENV); - else - return CORBA::TypeCode::TRAVERSE_CONTINUE; -} - -// deep_free for Sequence -CORBA::TypeCode::traverse_status -TAO_Marshal_Sequence::deep_free (CORBA::TypeCode_ptr tc, - const void *source, - const void *, - CORBA::Environment &) -{ - // TAO implements sequences using inheritance from a base - // class. That class allocate and deallocates the buffer, using - // virtual methods. - - if (tc) - { - TAO_Base_Sequence *src = - ACE_reinterpret_cast(TAO_Base_Sequence*,ACE_const_cast(void*,source)); - - src->_deallocate_buffer (); - return CORBA::TypeCode::TRAVERSE_CONTINUE; - } - return CORBA::TypeCode::TRAVERSE_STOP; -} - -// deep_free for Array -CORBA::TypeCode::traverse_status -TAO_Marshal_Array::deep_free (CORBA::TypeCode_ptr tc, - const void *source, - const void *dest, - CORBA::Environment &ACE_TRY_ENV) -{ - CORBA::TypeCode::traverse_status retval = - CORBA::TypeCode::TRAVERSE_CONTINUE; // return status - CORBA::TypeCode_var tc2; // typecode of the element - size_t size; // size of element - CORBA::ULong bounds; - - // Rely on binary format of sequences -- all are the same - // except for the type pointed to by "buffer" - - if (!tc) - { - if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("TAO_Marshal_Struct::deep_free detected error\n"))); - ACE_THROW_RETURN (CORBA::BAD_TYPECODE (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_MAYBE), - CORBA::TypeCode::TRAVERSE_STOP); - } - - bounds = tc->length (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - // exception getting bounds - - // get element typecode - tc2 = tc->content_type (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - // exception computing content type - - // get the size of the element type - size = tc2->size (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - switch (tc2->kind_) - { - case CORBA::tk_null: - case CORBA::tk_void: - case CORBA::tk_short: - case CORBA::tk_ushort: - case CORBA::tk_long: - case CORBA::tk_ulong: - case CORBA::tk_float: - case CORBA::tk_double: - case CORBA::tk_longlong: - case CORBA::tk_ulonglong: - case CORBA::tk_boolean: - case CORBA::tk_char: - case CORBA::tk_octet: - case CORBA::tk_longdouble: - case CORBA::tk_wchar: - case CORBA::tk_enum: - // CORBA::release (tc2); - return CORBA::TypeCode::TRAVERSE_CONTINUE; - - // handle all aggregate types here - case CORBA::tk_any: - while (bounds-- && retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - retval = TAO_Marshal_Any::deep_free (tc2.in (), source, dest, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - source = (char *)source + size; - } - break; - case CORBA::tk_TypeCode: - while (bounds-- && retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - retval = TAO_Marshal_TypeCode::deep_free (tc2.in (), source, dest, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - source = (char *)source + size; - } - break; - case CORBA::tk_Principal: - while (bounds-- && retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - retval = TAO_Marshal_Principal::deep_free (tc2.in (), source, dest, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - source = (char *)source + size; - } - break; - case CORBA::tk_objref: - while (bounds-- && retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - retval = TAO_Marshal_ObjRef::deep_free (tc2.in (), source, dest, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - source = (char *)source + size; - } - break; - case CORBA::tk_struct: - while (bounds-- && retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - retval = TAO_Marshal_Struct::deep_free (tc2.in (), source, dest, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - source = (char *)source + size; - } - break; - case CORBA::tk_union: - while (bounds-- && retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - retval = TAO_Marshal_Union::deep_free (tc2.in (), source, dest, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - source = (char *)source + size; - } - break; - case CORBA::tk_string: - while (bounds-- && retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - retval = TAO_Marshal_String::deep_free (tc2.in (), source, dest, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - source = (char *)source + size; - } - break; - case CORBA::tk_sequence: - while (bounds-- && retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - retval = TAO_Marshal_Sequence::deep_free (tc2.in(), source, dest, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - source = (char *)source + size; - } - break; - case CORBA::tk_array: - while (bounds-- && retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - retval = TAO_Marshal_Array::deep_free (tc2.in (), source, dest, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - source = (char *)source + size; - } - break; - case CORBA::tk_alias: - while (bounds-- && retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - retval = TAO_Marshal_Alias::deep_free (tc2.in (), source, dest, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - source = (char *)source + size; - } - break; - case CORBA::tk_except: - while (bounds-- && retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - retval = TAO_Marshal_Except::deep_free (tc2.in (), source, dest, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - source = (char *)source + size; - } - break; - case CORBA::tk_wstring: - while (bounds-- && retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - retval = TAO_Marshal_WString::deep_free (tc2.in (), source, dest, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - source = (char *)source + size; - } - break; - default: - retval = CORBA::TypeCode::TRAVERSE_STOP; - break; - } // end of switch - // CORBA::release (tc2); - if (retval != CORBA::TypeCode::TRAVERSE_CONTINUE) - { - if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("TAO_Marshal_Sequence::deep_free detected error\n"))); - // error exit - ACE_THROW_RETURN (CORBA::MARSHAL (), CORBA::TypeCode::TRAVERSE_STOP); - } - return CORBA::TypeCode::TRAVERSE_CONTINUE; -} - -// deep_free alias -CORBA::TypeCode::traverse_status -TAO_Marshal_Alias::deep_free (CORBA::TypeCode_ptr tc, - const void *source, - const void *dest, - CORBA::Environment &ACE_TRY_ENV) -{ - CORBA::TypeCode_var tc2; // typecode of the aliased type - CORBA::TypeCode::traverse_status retval = - CORBA::TypeCode::TRAVERSE_CONTINUE; // status of encode operation - - if (!tc) - { - if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("TAO_Marshal_Alias::deep_free detected error\n"))); - ACE_THROW_RETURN (CORBA::BAD_TYPECODE (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_MAYBE), - CORBA::TypeCode::TRAVERSE_STOP); - } - - // get element type - tc2 = tc->content_type (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - // exception getting content_type - - // switch on the data type and handle the cases for primitives here for - // efficiency - switch (tc2->kind_) - { - case CORBA::tk_null: - case CORBA::tk_void: - case CORBA::tk_short: - case CORBA::tk_ushort: - case CORBA::tk_long: - case CORBA::tk_ulong: - case CORBA::tk_float: - case CORBA::tk_enum: - case CORBA::tk_double: - case CORBA::tk_longlong: - case CORBA::tk_ulonglong: - case CORBA::tk_boolean: - case CORBA::tk_char: - case CORBA::tk_octet: - case CORBA::tk_longdouble: - case CORBA::tk_wchar: - // CORBA::release (tc2); - return CORBA::TypeCode::TRAVERSE_CONTINUE; - case CORBA::tk_any: - retval = TAO_Marshal_Any::deep_free (tc2.in (), source, dest, ACE_TRY_ENV); - break; - case CORBA::tk_TypeCode: - retval = TAO_Marshal_TypeCode::deep_free (tc2.in (), source, dest, ACE_TRY_ENV); - break; - case CORBA::tk_Principal: - retval = TAO_Marshal_Principal::deep_free (tc2.in (), source, dest, ACE_TRY_ENV); - break; - case CORBA::tk_objref: - retval = TAO_Marshal_ObjRef::deep_free (tc2.in (), source, dest, ACE_TRY_ENV); - break; - case CORBA::tk_struct: - retval = TAO_Marshal_Struct::deep_free (tc2.in (), source, dest, ACE_TRY_ENV); - break; - case CORBA::tk_union: - retval = TAO_Marshal_Union::deep_free (tc2.in (), source, dest, ACE_TRY_ENV); - break; - case CORBA::tk_string: - retval = TAO_Marshal_String::deep_free (tc2.in (), source, dest, ACE_TRY_ENV); - break; - case CORBA::tk_sequence: - retval = TAO_Marshal_Sequence::deep_free (tc2.in (), source, dest, ACE_TRY_ENV); - break; - case CORBA::tk_array: - retval = TAO_Marshal_Array::deep_free (tc2.in (), source, dest, ACE_TRY_ENV); - break; - case CORBA::tk_alias: - retval = TAO_Marshal_Alias::deep_free (tc2.in (), source, dest, ACE_TRY_ENV); - break; - case CORBA::tk_except: - retval = TAO_Marshal_Except::deep_free (tc2.in (), source, dest, ACE_TRY_ENV); - break; - case CORBA::tk_wstring: - retval = TAO_Marshal_WString::deep_free (tc2.in (), source, dest, ACE_TRY_ENV); - break; - default: - // anything else is an error - retval = CORBA::TypeCode::TRAVERSE_STOP; - } - // CORBA::release (tc2); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - if (retval != CORBA::TypeCode::TRAVERSE_CONTINUE) - { - // We should never reach here. - if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("TAO_Marshal_Alias::decode detected error\n"))); - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_MAYBE), - CORBA::TypeCode::TRAVERSE_STOP); - } - return CORBA::TypeCode::TRAVERSE_CONTINUE; -} - -// deep_free structs -CORBA::TypeCode::traverse_status -TAO_Marshal_Except::deep_free (CORBA::TypeCode_ptr tc, - const void *, - const void *, - CORBA::Environment &ACE_TRY_ENV) -{ -#if 0 - // temporarily commented out to make compiler happy - CORBA::Long i, - member_count; // number of fields in the struct - CORBA::TypeCode::traverse_status retval = CORBA::TypeCode::TRAVERSE_CONTINUE; - CORBA::TypeCode_ptr param; - CORBA::Long size, alignment; -#endif /* 0 */ - - if (!tc) - { - if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("TAO_Marshal_Except::deep_free detected error\n"))); - ACE_THROW_RETURN (CORBA::BAD_TYPECODE (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_MAYBE), - CORBA::TypeCode::TRAVERSE_STOP); - } - // XXX: Exceptions are currently leaked because of bugs lurking - // in this area. Keep in mind that there are two things to - // free: (a) the typecode in the exception base class; (b) any - // pointers held by a user-defined exception, such as an objref - // or string. - // - // Since this code does nothing, it should leak BOTH of those - // kinds of memory. Since it's not supposed to be called except - // when the exception really is being freed, it should only be - // called when the reference count in the exception base class - // is zero. - // - // It's not clear which of those assertions actually hold. - // - // The code SHOULD be just like the traverse () call for a - // structure, with (a) a precondition that the reference count - // is zero, (b) an assertion that the typecode in the exception - // and "tc" are equivalent, (c) releasing that typecode found - // within the exception. - // - return CORBA::TypeCode::TRAVERSE_CONTINUE; -} diff --git a/TAO/tao/encode.cpp b/TAO/tao/encode.cpp deleted file mode 100644 index 0d555abec6e..00000000000 --- a/TAO/tao/encode.cpp +++ /dev/null @@ -1,1140 +0,0 @@ -// $Id$ - -// ============================================================================ -// -// = LIBRARY -// TAO -// -// = FILENAME -// encode.cpp -// -// = DESCRIPTION -// Code for encoding different data types -// -// The original code had a single static encoder function defined on -// the CDR class that called traverse to interpret the data types. -// This version defines a virtual method "encode" on each class and -// avoids calling traverse. -// -// = AUTHOR -// Copyright 1994-1995 by Sun Microsystems Inc. -// and Aniruddha Gokhale -// -// ============================================================================ - -#include "tao/Marshal.h" -#include "tao/CDR.h" -#include "tao/Environment.h" -#include "tao/Any.h" -#include "tao/Object.h" -#include "tao/Stub.h" -#include "tao/Principal.h" -#include "tao/varout.h" -#include "tao/Union.h" -#include "tao/debug.h" - -ACE_RCSID(tao, encode, "$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 -// components. "context" is the marshaling stream on which to encode -// the data value. - -typedef TAO_Object_Field_T<CORBA::Object,CORBA::Object_var> TAO_Object_Field_Class; - -CORBA::TypeCode::traverse_status -TAO_Marshal_Primitive::encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA::Environment &ACE_TRY_ENV) -{ - CORBA::Boolean continue_encoding = 1; - TAO_OutputCDR *stream = (TAO_OutputCDR *) context; - CORBA::TypeCode::traverse_status retval = - CORBA::TypeCode::TRAVERSE_CONTINUE; // status of encode operation - - switch (tc->kind_) - { - case CORBA::tk_null: - case CORBA::tk_void: - break; - case CORBA::tk_short: - case CORBA::tk_ushort: - continue_encoding = stream->write_short (*(CORBA::Short *) data); - break; - case CORBA::tk_long: - case CORBA::tk_ulong: - case CORBA::tk_float: - case CORBA::tk_enum: - continue_encoding = stream->write_long (*(CORBA::Long *) data); - break; - case CORBA::tk_double: - case CORBA::tk_longlong: - case CORBA::tk_ulonglong: - continue_encoding = stream->write_longlong (*(CORBA::LongLong *) data); - break; - case CORBA::tk_boolean: - continue_encoding = stream->write_boolean (*(CORBA::Boolean *) data); - break; - case CORBA::tk_char: - case CORBA::tk_octet: - continue_encoding = stream->write_char (*(CORBA::Char *) data); - break; - case CORBA::tk_longdouble: - continue_encoding = stream->write_longdouble (*(CORBA::LongDouble *) data); - break; - case CORBA::tk_wchar: - continue_encoding = stream->write_wchar (*(CORBA::WChar *) data); - break; - default: - retval = CORBA::TypeCode::TRAVERSE_STOP; - // we are not a primitive type - } - - if (retval == CORBA::TypeCode::TRAVERSE_CONTINUE - && continue_encoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - else - { - if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - "TAO_Marshal_Primitive::encode detected error\n")); - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_MAYBE), - CORBA::TypeCode::TRAVERSE_STOP); - } -} - -CORBA::TypeCode::traverse_status -TAO_Marshal_Any::encode (CORBA::TypeCode_ptr, - const void *data, - const void *, - void *context, - CORBA::Environment &ACE_TRY_ENV) -{ - CORBA::Any *any = (CORBA::Any *) data; - - TAO_OutputCDR *stream = (TAO_OutputCDR *) context; - - // Status of encode operation - CORBA::TypeCode::traverse_status retval = - CORBA::TypeCode::TRAVERSE_CONTINUE; - - // Typecode of the element that makes the Any. - CORBA::TypeCode_ptr elem_tc = any->type_; - - // Encode the typecode description for the element. - retval = stream->encode (CORBA::_tc_TypeCode, &elem_tc, 0, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - if (retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - // if the any owns the data, then the value is a CDR stream and - // we simply append the CDR stream - // The only exception is when the TypeCode is a tk_null, them - // both cdr_ and value_ are 0. - if (any->cdr_ != 0) - { - TAO_InputCDR in_strm (any->cdr_); - retval = stream->append (elem_tc, &in_strm, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - } - else if (any->value_ != 0) - { - // encode the value - retval = stream->encode (elem_tc, any->value_, 0, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - } - } - - if (retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - else - { - if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - "TAO_Marshal_Any::encode detected error\n")); - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_MAYBE), - CORBA::TypeCode::TRAVERSE_STOP); - } -} - -CORBA::TypeCode::traverse_status -TAO_Marshal_TypeCode::encode (CORBA::TypeCode_ptr, - const void *data, - const void *, - void *context, - CORBA::Environment &ACE_TRY_ENV) -{ - CORBA::Boolean continue_encoding = 1; - TAO_OutputCDR *stream = (TAO_OutputCDR *) context; - CORBA::TypeCode_ptr tc2; // typecode to be encoded - - tc2 = *(CORBA::TypeCode_ptr *) data; // the data has to be a TypeCode_ptr - - // encode the "kind" field of the typecode - continue_encoding = stream->write_ulong ((CORBA::ULong) tc2->kind_); - if (continue_encoding == 1) - { - // now encode the parameters, if any - switch (tc2->kind_) - { - // Most TypeCodes have empty parameter lists - default: - break; - - // A few have "simple" parameter lists - case CORBA::tk_string: - case CORBA::tk_wstring: - continue_encoding = stream->write_ulong (tc2->length (ACE_TRY_ENV)); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - break; - - // Indirected typecodes can't occur at "top level" like - // this, only nested inside others! - case ~0u: - if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - "indirected typecode at top level!\n")); - continue_encoding = 0; - break; - - // The rest have "complex" parameter lists that are - // already encoded as bulk octets ... put length, then - // octets. - case CORBA::tk_objref: - case CORBA::tk_struct: - case CORBA::tk_union: - case CORBA::tk_enum: - case CORBA::tk_sequence: - case CORBA::tk_array: - case CORBA::tk_alias: - case CORBA::tk_except: - { - // simply encode the encapsulation - continue_encoding = stream->write_ulong (tc2->length_); - continue_encoding = continue_encoding - && stream->write_octet_array ((CORBA::Octet*)tc2->buffer_, tc2->length_); - } - } - } - if (continue_encoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - else - { - if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - "TAO_Marshal_TypeCode::encode detected error\n")); - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_MAYBE), - CORBA::TypeCode::TRAVERSE_STOP); - } -} - -// encode Principal -CORBA::TypeCode::traverse_status -TAO_Marshal_Principal::encode (CORBA::TypeCode_ptr, - const void *data, - const void *, - void *context, - CORBA::Environment &ACE_TRY_ENV) -{ - TAO_OutputCDR *stream = (TAO_OutputCDR *) context; - - CORBA::Principal_ptr p = *(CORBA::Principal_ptr *) data; - - if ((*stream << p) == 0) - { - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_MAYBE), - CORBA::TypeCode::TRAVERSE_STOP); - } - return CORBA::TypeCode::TRAVERSE_CONTINUE; -} - -// encode obj ref -CORBA::TypeCode::traverse_status -TAO_Marshal_ObjRef::encode (CORBA::TypeCode_ptr, - const void *data, - const void *, - void *context, - CORBA::Environment &ACE_TRY_ENV) -{ - TAO_OutputCDR *stream = (TAO_OutputCDR *) context; - - // Current version: objref is really an TAO_Stub. - // @@ But, it need not be. All IIOP specific processing has - // been move to the specific transport profile class! - // - // XXX this doesn't actually verify that the stuff got written - // OK to the "wire" ... - // @@ Seems to break here! - CORBA::Object_ptr obj = *(CORBA::Object_ptr *) data; - - if ((*stream << obj) == 0) - { - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_MAYBE), - CORBA::TypeCode::TRAVERSE_STOP); - } - return CORBA::TypeCode::TRAVERSE_CONTINUE; -} - -// encode structs -CORBA::TypeCode::traverse_status -TAO_Marshal_Struct::encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA::Environment &ACE_TRY_ENV) -{ - TAO_OutputCDR *stream = (TAO_OutputCDR *) context; - CORBA::TypeCode::traverse_status retval = CORBA::TypeCode::TRAVERSE_CONTINUE; - CORBA::Boolean continue_encoding = 1; - CORBA::TypeCode_var param; - CORBA::Long size, alignment, align_offset; - - void *start_addr = (void *)data; - - int member_count = tc->member_count (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - for (int i = 0; - i < member_count && retval == CORBA::TypeCode::TRAVERSE_CONTINUE - && continue_encoding == 1; - i++) - { - param = tc->member_type (i, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - size = param->size (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - alignment = param->alignment (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - align_offset = - (ptr_arith_t) ACE_ptr_align_binary (data, alignment) - - (ptr_arith_t) data - - ((ptr_arith_t) ACE_ptr_align_binary (start_addr, alignment) - - (ptr_arith_t) start_addr); - if (align_offset < 0) - align_offset += alignment; - - // if both the start_addr and data are not aligned as per - // the alignment, we do not add the offset - data = (const void *) ((ptr_arith_t) data + - ((align_offset == alignment) ? - 0 : align_offset)); - switch (param->kind_) - { - case CORBA::tk_null: - case CORBA::tk_void: - break; - case CORBA::tk_short: - case CORBA::tk_ushort: - continue_encoding = stream->write_short (*(CORBA::Short *) data); - break; - case CORBA::tk_long: - case CORBA::tk_ulong: - case CORBA::tk_float: - case CORBA::tk_enum: - continue_encoding = stream->write_long (*(CORBA::Long *) data); - break; - case CORBA::tk_double: - case CORBA::tk_longlong: - case CORBA::tk_ulonglong: - continue_encoding = stream->write_longlong (*(CORBA::LongLong *) data); - break; - case CORBA::tk_boolean: - continue_encoding = stream->write_boolean (*(CORBA::Boolean *) data); - break; - case CORBA::tk_char: - case CORBA::tk_octet: - continue_encoding = stream->write_char (*(CORBA::Char *) data); - break; - case CORBA::tk_longdouble: - continue_encoding = stream->write_longdouble (*(CORBA::LongDouble *) data); - break; - case CORBA::tk_wchar: - continue_encoding = stream->write_wchar (*(CORBA::WChar *) data); - break; - case CORBA::tk_any: - case CORBA::tk_Principal: - case CORBA::tk_struct: - case CORBA::tk_union: - case CORBA::tk_sequence: - case CORBA::tk_array: - case CORBA::tk_alias: - case CORBA::tk_except: - case CORBA::tk_string: - case CORBA::tk_wstring: - case CORBA::tk_TypeCode: - retval = stream->encode (param.in (), data, 0, ACE_TRY_ENV); - break; - - case CORBA::tk_objref: - { - // we know that the object pointer is stored in a - // TAO_Object_Field_T parametrized type - TAO_Object_Field_Class* field = - ACE_reinterpret_cast (TAO_Object_Field_Class *, - ACE_const_cast (void *, data)); - CORBA::Object_ptr ptr = field->_upcast (); - retval = stream->encode (param.in (), &ptr, 0, ACE_TRY_ENV); - } - break; - - default: - break; - } - data = (char *) data + size; - } - - if (retval == CORBA::TypeCode::TRAVERSE_CONTINUE - && continue_encoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - - if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - "TAO_Marshal_Struct::encode detected error\n")); - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_MAYBE), - CORBA::TypeCode::TRAVERSE_STOP); -} - -// encode unions -CORBA::TypeCode::traverse_status -TAO_Marshal_Union::encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *data2, - void *context, - CORBA::Environment &ACE_TRY_ENV) -{ - TAO_OutputCDR *stream = (TAO_OutputCDR *) context; - - CORBA::TypeCode_var discrim_tc = - tc->discriminator_type (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - // get the discriminator type - - CORBA::TypeCode_ptr default_tc = 0; - CORBA::Boolean discrim_matched = 0; - - TAO_Base_Union *base_union = (TAO_Base_Union *)data; - void *member_val; - - // encode the discriminator value - const void *discrim_val = base_union->_discriminant (); - CORBA::TypeCode::traverse_status retval = - stream->encode (discrim_tc.in (), discrim_val, data2, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - if (retval != CORBA::TypeCode::TRAVERSE_CONTINUE) - return retval; - - CORBA::ULong discrim_size_with_pad = - tc->TAO_discrim_pad_size (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - // move the pointer to point to the actual value - data = (char *) data + discrim_size_with_pad; - data2 = (char *) data2 + discrim_size_with_pad; - - // now get ready to marshal the actual union value - CORBA::Long default_index = - tc->default_index (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - // get the member count - CORBA::ULong member_count = - tc->member_count (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - // Check which label value matches with the - // discriminator value. Accordingly, marshal the - // corresponding member_type. If none match, - // check if default exists and marshal - // accordingly. Otherwise it is an error. - for (int i = 0; member_count-- != 0; i++) - { - CORBA::Any_ptr member_label = - tc->member_label (i, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - // do the matching - CORBA::TypeCode_var type = member_label->type (); - CORBA::ULong kind = type->kind (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - switch (kind) - { - case CORBA::tk_short: - { - CORBA::Short s; - *member_label >>= s; - if (s == *(CORBA::Short *) discrim_val) - discrim_matched = 1; - } - break; - - case CORBA::tk_ushort: - { - CORBA::UShort s; - *member_label >>= s; - if (s == *(CORBA::UShort *) discrim_val) - discrim_matched = 1; - } - break; - - case CORBA::tk_long: - { - CORBA::Long l; - *member_label >>= l; - if (l == *(CORBA::Long *) discrim_val) - discrim_matched = 1; - } - break; - - case CORBA::tk_ulong: - { - CORBA::ULong l; - *member_label >>= l; - if (l == *(CORBA::ULong *) discrim_val) - discrim_matched = 1; - } - break; - - case CORBA::tk_enum: - { - CORBA::ULong ul; - TAO_InputCDR stream (member_label->_tao_get_cdr (), - member_label->_tao_byte_order ()); - (void)stream.decode (discrim_tc.in (), &ul, 0, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - if (ul == *(CORBA::ULong *) discrim_val) - discrim_matched = 1; - } - break; - - case CORBA::tk_char: - { - CORBA::Char c; - *member_label >>= CORBA::Any::to_char (c); - if (c == *(CORBA::Char *) discrim_val) - discrim_matched = 1; - } - break; - - case CORBA::tk_wchar: - CORBA::WChar wc; - *member_label >>= CORBA::Any::to_wchar (wc); - if (wc == *(CORBA::WChar *) discrim_val) - discrim_matched = 1; - break; - - case CORBA::tk_boolean: - { - CORBA::Boolean b; - *member_label >>= CORBA::Any::to_boolean (b); - if (b == *(CORBA::Boolean *) discrim_val) - discrim_matched = 1; - } - break; - - default: - if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - "Union::encode - " - "Bad discriminant type\n")); - ACE_THROW_RETURN (CORBA::BAD_TYPECODE (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_MAYBE), - CORBA::TypeCode::TRAVERSE_STOP); - }// end of switch - - // get the member typecode - CORBA::TypeCode_var member_tc = - tc->member_type (i, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - if (default_index >= 0 && default_index-- == 0) - { - // have we reached the default label?, if so, - // save a handle to the typecode for the default - default_tc = member_tc.in (); - } - if (discrim_matched) - { - member_val = base_union->_access (0); - // marshal according to the matched typecode - - if (member_tc->kind () == CORBA::tk_objref) - { - // we know that the object pointer is stored in a - // TAO_Object_Field_T parametrized type - TAO_Object_Field_Class* field = - ACE_reinterpret_cast (TAO_Object_Field_Class *, - member_val); - CORBA::Object_ptr ptr = field->_upcast (); - return stream->encode (member_tc.in (), &ptr, data2, ACE_TRY_ENV); - } - else - { - return stream->encode (member_tc.in (), member_val, - data2, ACE_TRY_ENV); - } - } - } - // we are here only if there was no match - if (default_tc) - { - member_val = base_union->_access (0); - if (default_tc->kind () == CORBA::tk_objref) - { - // we know that the object pointer is stored in a - // TAO_Object_Field_T parametrized type - TAO_Object_Field_Class* field = - ACE_reinterpret_cast (TAO_Object_Field_Class *, - member_val); - CORBA::Object_ptr ptr = field->_upcast (); - return stream->encode (default_tc, &ptr, data2, ACE_TRY_ENV); - } - else - { - return stream->encode (default_tc, member_val, - data2, ACE_TRY_ENV); - } - } - if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - "Union::encode - failed. " - "No match and no default case\n")); - - ACE_THROW_RETURN (CORBA::MARSHAL (), - CORBA::TypeCode::TRAVERSE_STOP); -} - -// encode string -CORBA::TypeCode::traverse_status -TAO_Marshal_String::encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA::Environment &ACE_TRY_ENV) -{ - TAO_OutputCDR *stream = (TAO_OutputCDR *) context; - char * str = *(char**) data; - - // Verify string satisfies bounds requirements. We're not so - // permissive as to send messages violating the interface spec - // by having excessively long strings! - CORBA::ULong bounds = tc->length (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - if (str != 0) - { - CORBA::ULong length = ACE_OS::strlen (str); - if (bounds == 0 || bounds >= length) - if (stream->write_string (length, str)) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - } - else - { - if (stream->write_string (0, 0)) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - } - return CORBA::TypeCode::TRAVERSE_STOP; -} - -// encode sequence -CORBA::TypeCode::traverse_status -TAO_Marshal_Sequence::encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA::Environment &ACE_TRY_ENV) -{ - CORBA::Boolean continue_encoding = 1; - TAO_OutputCDR *stream = (TAO_OutputCDR *) context; - TAO_Base_Sequence *seq = (TAO_Base_Sequence *)data; - CORBA::TypeCode::traverse_status retval = - CORBA::TypeCode::TRAVERSE_CONTINUE; // return status - CORBA::TypeCode_var tc2; // typecode of the element - size_t size; // size of element - CORBA::ULong len = seq ? seq->length_ : 0; - char *value; - - // First marshal the sequence length, verifying that it's within the - // sequence bounds ... - - if (len > 0) - { - // retrieve the bounds of the sequence - CORBA::ULong bounds = tc->length (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - // encode only if it is an unbounded sequence or if length is - // less/equal to the bounds - if (bounds == 0 || len <= bounds) - { - // We just encode the current elements in the sequence - bounds = len; - continue_encoding = stream->write_ulong (bounds); - if (continue_encoding && bounds != 0) - { - // get element typecode - tc2 = tc->content_type (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - size = tc2->size (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - value = (char *) seq->buffer_; - switch (tc2->kind_) - { - case CORBA::tk_null: - case CORBA::tk_void: - return CORBA::TypeCode::TRAVERSE_CONTINUE; - - case CORBA::tk_short: - case CORBA::tk_ushort: - continue_encoding = continue_encoding && - stream->write_short_array - ((CORBA::Short*)value, bounds); - if (continue_encoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - - case CORBA::tk_long: - case CORBA::tk_ulong: - case CORBA::tk_float: - case CORBA::tk_enum: - // For primitives, compute the size only once - continue_encoding = continue_encoding && - stream->write_long_array - ((CORBA::Long*)value, bounds); - if (continue_encoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - - case CORBA::tk_double: - case CORBA::tk_longlong: - case CORBA::tk_ulonglong: - // For primitives, compute the size only once - continue_encoding = continue_encoding && - stream->write_longlong_array - ((CORBA::LongLong*)value, bounds); - if (continue_encoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - - case CORBA::tk_boolean: - // For primitives, compute the size only once - continue_encoding = continue_encoding && - stream->write_boolean_array - ((CORBA::Boolean*)value, bounds); - if (continue_encoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - - case CORBA::tk_char: - // For primitives, compute the size only once - continue_encoding = continue_encoding && - stream->write_char_array - ((CORBA::Char*)value, bounds); - if (continue_encoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - - case CORBA::tk_octet: -#if !defined (TAO_NO_COPY_OCTET_SEQUENCES) - // For primitives, compute the size only once - continue_encoding = continue_encoding && - stream->write_octet_array - ((CORBA::Octet*)value, bounds); -#else - { - TAO_Unbounded_Sequence<CORBA::Octet> *oseq = - ACE_dynamic_cast(TAO_Unbounded_Sequence<CORBA::Octet>*,seq); - if (oseq->mb_ == 0) - { - continue_encoding = continue_encoding && - stream->write_octet_array - ((CORBA::Octet*)value, bounds); - } - else - { - continue_encoding = continue_encoding && - stream->write_octet_array_mb (oseq->mb ()); - } - } -#endif /* TAO_NO_COPY_OCTET_SEQUENCES */ - if (continue_encoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - - case CORBA::tk_longdouble: - // For primitives, compute the size only once - continue_encoding = continue_encoding && - stream->write_longdouble_array - ((CORBA::LongDouble*)value, bounds); - if (continue_encoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - - case CORBA::tk_wchar: - // For primitives, compute the size only once - continue_encoding = continue_encoding && - stream->write_wchar_array - ((CORBA::WChar*)value, bounds); - if (continue_encoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - - // handle all aggregate types here - - case CORBA::tk_any: - case CORBA::tk_TypeCode: - case CORBA::tk_Principal: - case CORBA::tk_struct: - case CORBA::tk_union: - case CORBA::tk_string: - case CORBA::tk_sequence: - case CORBA::tk_array: - case CORBA::tk_alias: - case CORBA::tk_except: - case CORBA::tk_wstring: - // For those aggregate types whose size - // is constant, we compute it only once - while (bounds-- && retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - retval = stream->encode (tc2.in (), value, 0, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - value += size; - } - // CORBA::release (tc2); - if (retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - - case CORBA::tk_objref: - { - size = sizeof (CORBA_Object_ptr); - while (bounds-- && - retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - CORBA_Object_ptr ptr = - seq->_upcast (value); - retval = stream->encode (tc2.in (), &ptr, 0, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - value += size; - } - if (retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - return retval; - } - break; - - default: - break; - } // end of switch - } // seq length not 0 - } // within bounds or unbounded - } // length is > 0 - else - { - // length is 0, encode it - continue_encoding = stream->write_ulong (len); - if (continue_encoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - - } - - // If an error was detected but no exception was raised then raise a - // marshal exception. - ACE_THROW_RETURN (CORBA::MARSHAL (), - CORBA::TypeCode::TRAVERSE_STOP); -} - -// encode array -CORBA::TypeCode::traverse_status -TAO_Marshal_Array::encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA::Environment &ACE_TRY_ENV) -{ - CORBA::Boolean continue_encoding = 1; - TAO_OutputCDR *stream = (TAO_OutputCDR *) context; - CORBA::TypeCode::traverse_status retval = - CORBA::TypeCode::TRAVERSE_CONTINUE; // return status - size_t size; // size of element - CORBA::ULong bounds; - char *value = (char *) data; - - // retrieve the bounds of the array - bounds = tc->length (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - // get element typecode. - CORBA::TypeCode_var tc2 = tc->content_type (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - size = tc2->size (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - switch (tc2->kind_) - { - case CORBA::tk_null: - case CORBA::tk_void: - return CORBA::TypeCode::TRAVERSE_CONTINUE; - - case CORBA::tk_short: - case CORBA::tk_ushort: - continue_encoding = continue_encoding && - stream->write_short_array - ((CORBA::Short*)value, bounds); - if (continue_encoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - - case CORBA::tk_long: - case CORBA::tk_ulong: - case CORBA::tk_float: - // For primitives, compute the size only once - continue_encoding = continue_encoding && - stream->write_long_array - ((CORBA::Long*)value, bounds); - if (continue_encoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - - case CORBA::tk_double: - case CORBA::tk_longlong: - case CORBA::tk_ulonglong: - // For primitives, compute the size only once - continue_encoding = continue_encoding && - stream->write_longlong_array - ((CORBA::LongLong*)value, bounds); - if (continue_encoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - - case CORBA::tk_boolean: - // For primitives, compute the size only once - continue_encoding = continue_encoding && - stream->write_boolean_array - ((CORBA::Boolean*)value, bounds); - if (continue_encoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - - case CORBA::tk_char: - case CORBA::tk_octet: - // For primitives, compute the size only once - continue_encoding = continue_encoding && - stream->write_octet_array - ((CORBA::Octet*)value, bounds); - if (continue_encoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - - case CORBA::tk_longdouble: - // For primitives, compute the size only once - continue_encoding = continue_encoding && - stream->write_longdouble_array - ((CORBA::LongDouble*)value, bounds); - if (continue_encoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - - case CORBA::tk_wchar: - // For primitives, compute the size only once - continue_encoding = continue_encoding && - stream->write_wchar_array - ((CORBA::WChar*)value, bounds); - if (continue_encoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - - case CORBA::tk_enum: - // For primitives, compute the size only once - continue_encoding = continue_encoding && - stream->write_long_array - ((CORBA::Long*)value, bounds); - if (continue_encoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - // handle all aggregate types here - - case CORBA::tk_any: - case CORBA::tk_TypeCode: - case CORBA::tk_Principal: - case CORBA::tk_objref: - case CORBA::tk_struct: - case CORBA::tk_union: - case CORBA::tk_string: - case CORBA::tk_sequence: - case CORBA::tk_array: - case CORBA::tk_alias: - case CORBA::tk_except: - case CORBA::tk_wstring: - // For those aggregate types whose size is constant, we - // compute it only once - while (bounds-- && retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - retval = stream->encode (tc2.in (), value, 0, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - value += size; - } - // CORBA::release (tc2); - if (retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - break; - default: - break; - } // end of switch - - // error exit - if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - "TAO_Marshal_Sequence::encode detected error\n")); - ACE_THROW_RETURN (CORBA::MARSHAL (), - CORBA::TypeCode::TRAVERSE_STOP); -} - -CORBA::TypeCode::traverse_status -TAO_Marshal_Alias::encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA::Environment &ACE_TRY_ENV) -{ - CORBA::TypeCode_var tc2; // typecode of the aliased type - CORBA::Boolean continue_encoding = 1; - TAO_OutputCDR *stream = (TAO_OutputCDR *) context; - CORBA::TypeCode::traverse_status retval = - CORBA::TypeCode::TRAVERSE_CONTINUE; // status of encode operation - char *value = (char *) data; - - tc2 = tc->content_type (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - // switch on the data type and handle the cases for primitives here for - // efficiency rather than calling - switch (tc2->kind_) - { - case CORBA::tk_null: - case CORBA::tk_void: - break; - case CORBA::tk_short: - case CORBA::tk_ushort: - continue_encoding = stream->write_short (*(CORBA::Short *) value); - break; - case CORBA::tk_long: - case CORBA::tk_ulong: - case CORBA::tk_float: - case CORBA::tk_enum: - continue_encoding = stream->write_long (*(CORBA::Long *) value); - break; - case CORBA::tk_double: - case CORBA::tk_longlong: - case CORBA::tk_ulonglong: - continue_encoding = stream->write_longlong (*(CORBA::LongLong *) value); - break; - case CORBA::tk_boolean: - continue_encoding = stream->write_boolean (*(CORBA::Boolean *) value); - break; - case CORBA::tk_char: - case CORBA::tk_octet: - continue_encoding = stream->write_char (*(CORBA::Char *) value); - break; - case CORBA::tk_longdouble: - continue_encoding = stream->write_longdouble (*(CORBA::LongDouble *) value); - break; - case CORBA::tk_wchar: - continue_encoding = stream->write_wchar (*(CORBA::WChar *) value); - break; - case CORBA::tk_any: - case CORBA::tk_TypeCode: - case CORBA::tk_Principal: - case CORBA::tk_objref: - case CORBA::tk_struct: - case CORBA::tk_union: - case CORBA::tk_string: - case CORBA::tk_sequence: - case CORBA::tk_array: - case CORBA::tk_alias: - case CORBA::tk_except: - case CORBA::tk_wstring: - retval = stream->encode (tc2.in (), data, 0, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - break; - default: - // anything else is an error - retval = CORBA::TypeCode::TRAVERSE_STOP; - } - - // tc2->_decr_refcnt (); - if (retval == CORBA::TypeCode::TRAVERSE_CONTINUE - && continue_encoding == 1) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - - if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - "TAO_Marshal_Alias::encode detected error\n")); - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_MAYBE), - CORBA::TypeCode::TRAVERSE_STOP); -} - - -// encode exception -CORBA::TypeCode::traverse_status -TAO_Marshal_Except::encode (CORBA::TypeCode_ptr, - const void *, - const void *, - void *, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_MAYBE), - CORBA::TypeCode::TRAVERSE_STOP); -} - - -// encode wstring -CORBA::TypeCode::traverse_status -TAO_Marshal_WString::encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA::Environment &ACE_TRY_ENV) -{ - CORBA::WChar *str = *(CORBA::WChar **) data; - TAO_OutputCDR *stream = (TAO_OutputCDR *) context; - - // Verify string satisfies bounds requirements. We're not so - // permissive as to send messages violating the interface spec - // by having excessively long strings! - CORBA::ULong bounds = tc->length (ACE_TRY_ENV); - - if (str != 0) - { - // get the actual length of the string - CORBA::ULong len = ACE_OS::wslen ((CORBA::WChar *) str); - - // if it is an unbounded string or if the length is less than the - // bounds for an unbounded string - if (bounds == 0 || len <= bounds) - if (stream->write_wstring (len, str)) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - } - else - { - if (stream->write_wstring (0, 0)) - return CORBA::TypeCode::TRAVERSE_CONTINUE; - } - return CORBA::TypeCode::TRAVERSE_STOP; -} diff --git a/TAO/tao/orb.idl b/TAO/tao/orb.idl index a1ca0c37421..e5bbf409db2 100644 --- a/TAO/tao/orb.idl +++ b/TAO/tao/orb.idl @@ -7,10 +7,14 @@ #include <Policy.pidl> +#pragma prefix "omg.org" + module CORBA { typedef unsigned long ServiceOption; typedef unsigned long ServiceDetailType; }; +#pragma prefix "" + #endif /* TAO_CORBA_IDL */ diff --git a/TAO/tao/skip.cpp b/TAO/tao/skip.cpp index ca67024aa07..110c717b218 100644 --- a/TAO/tao/skip.cpp +++ b/TAO/tao/skip.cpp @@ -102,19 +102,10 @@ TAO_Marshal_Any::skip (CORBA::TypeCode_ptr, TAO_InputCDR *stream = ACE_static_cast (TAO_InputCDR *, context); // Status of encode operation. - CORBA::TypeCode::traverse_status retval = - stream->decode (CORBA::_tc_TypeCode, - &elem_tc.inout (), - 0, - ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); + if (!(*stream >> elem_tc.inout ())) + return CORBA::TypeCode::TRAVERSE_STOP; - if (retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - retval = stream->skip (elem_tc.in (), ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - } - return retval; + return stream->skip (elem_tc.in (), ACE_TRY_ENV); } CORBA::TypeCode::traverse_status @@ -355,145 +346,211 @@ TAO_Marshal_Union::skip (CORBA::TypeCode_ptr tc, void *context, CORBA::Environment &ACE_TRY_ENV) { - // Context is the CDR stream. - TAO_InputCDR *stream = ACE_static_cast (TAO_InputCDR *, context); - - CORBA::TypeCode::traverse_status retval = - CORBA::TypeCode::TRAVERSE_CONTINUE; + TAO_InputCDR *src = + ACE_reinterpret_cast (TAO_InputCDR*, context); - CORBA::TypeCode_var discrim_tc; - CORBA::TypeCode_var member_tc; - CORBA::Any_ptr member_label; - CORBA::ULongLong discrim_val; - CORBA::ULong member_count; - CORBA::Long default_index; - CORBA::ULong i; - CORBA::TypeCode_ptr default_tc = 0; - CORBA::Boolean discrim_matched = 0; - - // get the discriminator type which will enable us to skip the discriminator - // value - discrim_tc = tc->discriminator_type (ACE_TRY_ENV); + CORBA::TypeCode_ptr discrim_tc = + tc->discriminator_type (ACE_TRY_ENV); ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - // decode the discriminator value - retval = stream->decode (discrim_tc.in (), &discrim_val, 0, ACE_TRY_ENV); + CORBA::ULong kind = + discrim_tc->kind (ACE_TRY_ENV); ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - if (retval == CORBA::TypeCode::TRAVERSE_CONTINUE) + // Save the discriminator value in a temporary variable... + CORBA::Short short_v; + CORBA::UShort ushort_v; + CORBA::Long long_v; + CORBA::ULong ulong_v; + CORBA::ULong enum_v; + CORBA::Char char_v; + CORBA::WChar wchar_v; + CORBA::Boolean boolean_v; + + switch (kind) { - // now get ready to skip the actual union value - default_index = tc->default_index (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); + case CORBA::tk_short: + { + if (!src->read_short (short_v)) + return CORBA::TypeCode::TRAVERSE_STOP; + } + break; - member_count = tc->member_count (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); + case CORBA::tk_ushort: + { + if (!src->read_ushort (ushort_v)) + return CORBA::TypeCode::TRAVERSE_STOP; + } + break; - // check which label value matches with the discriminator - // value. Accordingly, marshal the corresponding - // member_type. If none match, check if default exists - // and marshal accordingly. Otherwise it is an error. + case CORBA::tk_long: + { + if (!src->read_long (long_v)) + return CORBA::TypeCode::TRAVERSE_STOP; + } + break; - for (i = 0; i < member_count; i++) - { - member_label = tc->member_label (i, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); + case CORBA::tk_ulong: + { + if (!src->read_ulong (ulong_v)) + return CORBA::TypeCode::TRAVERSE_STOP; + } + break; - // do the matching - CORBA::TypeCode_var type = member_label->type (); - CORBA::ULong kind = type->kind (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); + case CORBA::tk_enum: + { + if (!src->read_ulong (enum_v)) + return CORBA::TypeCode::TRAVERSE_STOP; + } + break; - switch (kind) - { - case CORBA::tk_short: - { - CORBA::Short s; - *member_label >>= s; - if (s == *(CORBA::Short *) &discrim_val) - discrim_matched = 1; - } - break; - case CORBA::tk_ushort: - { - CORBA::UShort s; - *member_label >>= s; - if (s == *(CORBA::UShort *) &discrim_val) - discrim_matched = 1; - } - break; - case CORBA::tk_long: - { - CORBA::Long l; - *member_label >>= l; - if (l == *(CORBA::Long *) &discrim_val) - discrim_matched = 1; - } - break; - case CORBA::tk_ulong: - { - CORBA::ULong l; - *member_label >>= l; - if (l == *(CORBA::ULong *) &discrim_val) - discrim_matched = 1; - } - break; - case CORBA::tk_enum: - { - CORBA::ULong ul; - TAO_InputCDR stream (member_label->_tao_get_cdr (), - member_label->_tao_byte_order ()); - (void)stream.decode (discrim_tc.in (), &ul, 0, ACE_TRY_ENV); - if (ul == *(CORBA::ULong *) &discrim_val) - discrim_matched = 1; - } - break; - case CORBA::tk_char: - { - CORBA::Char c; - *member_label >>= CORBA::Any::to_char (c); - if (c == *(CORBA::Char *) &discrim_val) - discrim_matched = 1; - } - break; - case CORBA::tk_wchar: - CORBA::WChar wc; - *member_label >>= CORBA::Any::to_wchar (wc); - if (wc == *(CORBA::WChar *) &discrim_val) - discrim_matched = 1; - break; - case CORBA::tk_boolean: - { - CORBA::Boolean b; - *member_label >>= CORBA::Any::to_boolean (b); - if (b == *(CORBA::Boolean *) &discrim_val) - discrim_matched = 1; - } - break; - default: - ACE_THROW_RETURN (CORBA::BAD_TYPECODE (), - CORBA::TypeCode::TRAVERSE_STOP); - }// end of switch + case CORBA::tk_char: + { + if (!src->read_char (char_v)) + return CORBA::TypeCode::TRAVERSE_STOP; + } + break; + + case CORBA::tk_wchar: + { + if (!src->read_wchar (wchar_v)) + return CORBA::TypeCode::TRAVERSE_STOP; + } + break; + + case CORBA::tk_boolean: + { + if (!src->read_boolean (boolean_v)) + return CORBA::TypeCode::TRAVERSE_STOP; + } + break; - // get the member typecode - member_tc = tc->member_type (i, ACE_TRY_ENV); + default: + return CORBA::TypeCode::TRAVERSE_STOP; + } + + CORBA::ULong member_count = + tc->member_count (ACE_TRY_ENV); + ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); + + CORBA::ULong current_member = ~0UL; + CORBA::ULong default_member = ~0UL; + for (CORBA::ULong i = 0; + i != member_count && current_member == ~0UL; + ++i) + { + CORBA::Any *any = + tc->member_label (i, ACE_TRY_ENV); + ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); + + CORBA::Octet o; + if ((*any >>= CORBA::Any::to_octet (o)) && o == 0) + { + CORBA::ULong default_index = + tc->default_index (ACE_TRY_ENV); ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - // have we reached the default label, if so save a handle to - // the typecode for the default + if (i != default_index) + ACE_THROW_RETURN (CORBA::BAD_TYPECODE (), + CORBA::TypeCode::TRAVERSE_STOP); + // Found the default branch, save its position and continue + // trying to find the current value... + default_member = i; + continue; + } - if (default_index >= 0 && default_index-- == 0) - default_tc = member_tc.in (); - if (discrim_matched) - { - // marshal according to the matched typecode - return stream->skip (member_tc.in (), ACE_TRY_ENV); - } + switch (kind) + { + case CORBA::tk_short: + { + CORBA::Short d; + if ((*any >>= d) && d == short_v) + current_member = i; + } + break; + + case CORBA::tk_ushort: + { + CORBA::UShort d; + if ((*any >>= d) && d == ushort_v) + current_member = i; + } + break; + + case CORBA::tk_long: + { + CORBA::Long d; + if ((*any >>= d) && d == long_v) + current_member = i; + } + break; + + case CORBA::tk_ulong: + { + CORBA::ULong d; + if ((*any >>= d) && d == ulong_v) + current_member = i; + } + break; + + case CORBA::tk_enum: + { + CORBA::ULong d; + // @@ Will this work???? + if ((*any >>= d) && d == enum_v) + current_member = i; + } + break; + + case CORBA::tk_char: + { + CORBA::Char d; + if ((*any >>= CORBA::Any::to_char (d)) && d == char_v) + current_member = i; + } + break; + + case CORBA::tk_wchar: + { + CORBA::WChar d; + if ((*any >>= CORBA::Any::to_wchar (d)) && d == wchar_v) + current_member = i; + } + break; + + case CORBA::tk_boolean: + { + CORBA::Boolean d; + if ((*any >>= CORBA::Any::to_boolean (d)) && d == boolean_v) + current_member = i; + } + break; + + default: + return CORBA::TypeCode::TRAVERSE_STOP; + } + } + + if (current_member == ~0UL) + { + // Cannot find the current member, check if there is a + // default... + if (default_member != ~0UL) + { + // Good, use the default to append... + CORBA::TypeCode_ptr member_tc = + tc->member_type (default_member, ACE_TRY_ENV); + ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); + return src->skip (member_tc, ACE_TRY_ENV); } - if (default_tc != 0) - return stream->skip (default_tc, ACE_TRY_ENV); + return CORBA::TypeCode::TRAVERSE_STOP; } - return retval; + + // If we found the member successfully then just use that one... + CORBA::TypeCode_ptr member_tc = + tc->member_type (current_member, ACE_TRY_ENV); + ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); + return src->skip (member_tc, ACE_TRY_ENV); } // decode string |