diff options
Diffstat (limited to 'TAO/tao/IFR_Client')
-rw-r--r-- | TAO/tao/IFR_Client/IFR_BaseC.cpp | 94 | ||||
-rw-r--r-- | TAO/tao/IFR_Client/IFR_BaseC.i | 292 | ||||
-rw-r--r-- | TAO/tao/IFR_Client/IFR_BasicC.cpp | 148 | ||||
-rw-r--r-- | TAO/tao/IFR_Client/IFR_BasicC.h | 81 | ||||
-rw-r--r-- | TAO/tao/IFR_Client/IFR_BasicC.i | 192 | ||||
-rw-r--r-- | TAO/tao/IFR_Client/IFR_ExtendedC.cpp | 34 | ||||
-rw-r--r-- | TAO/tao/IFR_Client/IFR_ExtendedC.h | 7 | ||||
-rw-r--r-- | TAO/tao/IFR_Client/IFR_ExtendedC.i | 48 |
8 files changed, 447 insertions, 449 deletions
diff --git a/TAO/tao/IFR_Client/IFR_BaseC.cpp b/TAO/tao/IFR_Client/IFR_BaseC.cpp index 3f4ba9fb788..397a4945430 100644 --- a/TAO/tao/IFR_Client/IFR_BaseC.cpp +++ b/TAO/tao/IFR_Client/IFR_BaseC.cpp @@ -398,13 +398,13 @@ _TAO_IRObject_Remote_Proxy_Broker::select_proxy ( // default constructor -CORBA::IRObject::IRObject (int collocated) +CORBA::IRObject::CORBA_IRObject (int collocated) { this->CORBA_IRObject_setup_collocation (collocated); } // destructor -CORBA::IRObject::~IRObject (void) +CORBA::IRObject::~CORBA_IRObject (void) {} void @@ -2305,13 +2305,13 @@ _TAO_Contained_Remote_Proxy_Broker::select_proxy ( // default constructor -CORBA::Contained::Contained (int collocated) +CORBA::Contained::CORBA_Contained (int collocated) { this->CORBA_Contained_setup_collocation (collocated); } // destructor -CORBA::Contained::~Contained (void) +CORBA::Contained::~CORBA_Contained (void) {} void @@ -3453,17 +3453,17 @@ CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_move::result (CORBA::Env // The Base_Sequence functions, please see tao/Sequence.h void - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_allocate_buffer (CORBA::ULong length) + _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_allocate_buffer (CORBA::ULong length) { - Contained **tmp = 0; + CORBA_Contained **tmp = 0; tmp = _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (length); if (this->buffer_ != 0) { - Contained **old = ACE_reinterpret_cast (Contained**, this->buffer_); + CORBA_Contained **old = ACE_reinterpret_cast (CORBA_Contained**, this->buffer_); for (CORBA::ULong i = 0; i < this->length_; ++i) if (!this->release_) - tmp[i] = Contained::_duplicate (old[i]); + tmp[i] = CORBA_Contained::_duplicate (old[i]); else tmp[i] = old[i]; @@ -3475,52 +3475,52 @@ CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_move::result (CORBA::Env } void - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_deallocate_buffer (void) + _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_deallocate_buffer (void) { if (this->buffer_ == 0 || this->release_ == 0) return; - Contained **tmp = ACE_reinterpret_cast (Contained**, this->buffer_); + CORBA_Contained **tmp = ACE_reinterpret_cast (CORBA_Contained**, this->buffer_); for (CORBA::ULong i = 0; i < this->length_; ++i) { CORBA::release (tmp[i]); - tmp[i] = Contained::_nil (); + tmp[i] = CORBA_Contained::_nil (); } _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::freebuf (tmp); this->buffer_ = 0; } - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::~_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (void) + _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::~_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (void) { this->_deallocate_buffer (); } void - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol) + _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol) { - Contained **tmp = ACE_reinterpret_cast (Contained**, this->buffer_); + CORBA_Contained **tmp = ACE_reinterpret_cast (CORBA_Contained**, this->buffer_); for (CORBA::ULong i = nl; i < ol; ++i) { CORBA::release (tmp[i]); - tmp[i] = Contained::_nil (); + tmp[i] = CORBA_Contained::_nil (); } } void - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_downcast ( + _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_downcast ( void* target, CORBA_Object *src, CORBA_Environment &ACE_TRY_ENV ) { - Contained **tmp = ACE_static_cast (Contained**, target); - *tmp = Contained::_narrow (src, ACE_TRY_ENV); + CORBA_Contained **tmp = ACE_static_cast (CORBA_Contained**, target); + *tmp = CORBA_Contained::_narrow (src, ACE_TRY_ENV); ACE_CHECK; } CORBA_Object* - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_upcast (void *src) const + _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_upcast (void *src) const { - Contained **tmp = ACE_static_cast (Contained**, src); + CORBA_Contained **tmp = ACE_static_cast (CORBA_Contained**, src); return *tmp; } @@ -3588,14 +3588,14 @@ void CORBA::StructMember::_tao_any_destructor (void *x) #define __TAO_UNBOUNDED_SEQUENCE_CORBA_STRUCTMEMBERSEQ_CS_ void - CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_allocate_buffer (CORBA::ULong length) + _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_allocate_buffer (CORBA::ULong length) { - StructMember* tmp = 0; + CORBA_StructMember* tmp = 0; tmp = _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (length); if (this->buffer_ != 0) { - StructMember *old = ACE_reinterpret_cast (StructMember *,this->buffer_); + CORBA_StructMember *old = ACE_reinterpret_cast (CORBA_StructMember *,this->buffer_); for (CORBA::ULong i = 0; i < this->length_; ++i) tmp[i] = old[i]; @@ -3608,18 +3608,18 @@ void CORBA::StructMember::_tao_any_destructor (void *x) } void - CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_deallocate_buffer (void) + _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_deallocate_buffer (void) { if (this->buffer_ == 0 || this->release_ == 0) return; - StructMember *tmp = ACE_reinterpret_cast (StructMember *,this->buffer_); + CORBA_StructMember *tmp = ACE_reinterpret_cast (CORBA_StructMember *,this->buffer_); _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::freebuf (tmp); this->buffer_ = 0; } - CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::~_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (void) // Dtor. + _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::~_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (void) // Dtor. { this->_deallocate_buffer (); } @@ -3690,14 +3690,14 @@ void CORBA::Initializer::_tao_any_destructor (void *x) #define __TAO_UNBOUNDED_SEQUENCE_CORBA_INITIALIZERSEQ_CS_ void - CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::_allocate_buffer (CORBA::ULong length) + _TAO_Unbounded_Sequence_CORBA_InitializerSeq::_allocate_buffer (CORBA::ULong length) { - Initializer* tmp = 0; + CORBA_Initializer* tmp = 0; tmp = _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (length); if (this->buffer_ != 0) { - Initializer *old = ACE_reinterpret_cast (Initializer *,this->buffer_); + CORBA_Initializer *old = ACE_reinterpret_cast (CORBA_Initializer *,this->buffer_); for (CORBA::ULong i = 0; i < this->length_; ++i) tmp[i] = old[i]; @@ -3710,18 +3710,18 @@ void CORBA::Initializer::_tao_any_destructor (void *x) } void - CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::_deallocate_buffer (void) + _TAO_Unbounded_Sequence_CORBA_InitializerSeq::_deallocate_buffer (void) { if (this->buffer_ == 0 || this->release_ == 0) return; - Initializer *tmp = ACE_reinterpret_cast (Initializer *,this->buffer_); + CORBA_Initializer *tmp = ACE_reinterpret_cast (CORBA_Initializer *,this->buffer_); _TAO_Unbounded_Sequence_CORBA_InitializerSeq::freebuf (tmp); this->buffer_ = 0; } - CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::~_TAO_Unbounded_Sequence_CORBA_InitializerSeq (void) // Dtor. + _TAO_Unbounded_Sequence_CORBA_InitializerSeq::~_TAO_Unbounded_Sequence_CORBA_InitializerSeq (void) // Dtor. { this->_deallocate_buffer (); } @@ -3792,14 +3792,14 @@ void CORBA::UnionMember::_tao_any_destructor (void *x) #define __TAO_UNBOUNDED_SEQUENCE_CORBA_UNIONMEMBERSEQ_CS_ void - CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_allocate_buffer (CORBA::ULong length) + _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_allocate_buffer (CORBA::ULong length) { - UnionMember* tmp = 0; + CORBA_UnionMember* tmp = 0; tmp = _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (length); if (this->buffer_ != 0) { - UnionMember *old = ACE_reinterpret_cast (UnionMember *,this->buffer_); + CORBA_UnionMember *old = ACE_reinterpret_cast (CORBA_UnionMember *,this->buffer_); for (CORBA::ULong i = 0; i < this->length_; ++i) tmp[i] = old[i]; @@ -3812,18 +3812,18 @@ void CORBA::UnionMember::_tao_any_destructor (void *x) } void - CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_deallocate_buffer (void) + _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_deallocate_buffer (void) { if (this->buffer_ == 0 || this->release_ == 0) return; - UnionMember *tmp = ACE_reinterpret_cast (UnionMember *,this->buffer_); + CORBA_UnionMember *tmp = ACE_reinterpret_cast (CORBA_UnionMember *,this->buffer_); _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::freebuf (tmp); this->buffer_ = 0; } - CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::~_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (void) // Dtor. + _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::~_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (void) // Dtor. { this->_deallocate_buffer (); } @@ -4703,13 +4703,13 @@ _TAO_Container_Remote_Proxy_Broker::select_proxy ( // default constructor -CORBA::Container::Container (int collocated) +CORBA::Container::CORBA_Container (int collocated) { this->CORBA_Container_setup_collocation (collocated); } // destructor -CORBA::Container::~Container (void) +CORBA::Container::~CORBA_Container (void) {} void @@ -5127,12 +5127,12 @@ void CORBA::Container::Description::_tao_any_destructor (void *x) void CORBA::Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::_allocate_buffer (CORBA::ULong length) { - Description* tmp = 0; + CORBA::Container::Description* tmp = 0; tmp = _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::allocbuf (length); if (this->buffer_ != 0) { - Description *old = ACE_reinterpret_cast (Description *,this->buffer_); + CORBA::Container::Description *old = ACE_reinterpret_cast (CORBA::Container::Description *,this->buffer_); for (CORBA::ULong i = 0; i < this->length_; ++i) tmp[i] = old[i]; @@ -5150,7 +5150,7 @@ void CORBA::Container::Description::_tao_any_destructor (void *x) if (this->buffer_ == 0 || this->release_ == 0) return; - Description *tmp = ACE_reinterpret_cast (Description *,this->buffer_); + CORBA::Container::Description *tmp = ACE_reinterpret_cast (CORBA::Container::Description *,this->buffer_); _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::freebuf (tmp); this->buffer_ = 0; @@ -7127,13 +7127,13 @@ _TAO_IDLType_Remote_Proxy_Broker::select_proxy ( // default constructor -CORBA::IDLType::IDLType (int collocated) +CORBA_IDLType::CORBA_IDLType (int collocated) { this->CORBA_IDLType_setup_collocation (collocated); } // destructor -CORBA::IDLType::~IDLType (void) +CORBA_IDLType::~CORBA_IDLType (void) {} void @@ -7416,13 +7416,13 @@ _TAO_TypedefDef_Remote_Proxy_Broker::select_proxy ( // default constructor -CORBA::TypedefDef::TypedefDef (int collocated) +CORBA_TypedefDef::CORBA_TypedefDef (int collocated) { this->CORBA_TypedefDef_setup_collocation (collocated); } // destructor -CORBA::TypedefDef::~TypedefDef (void) +CORBA_TypedefDef::~CORBA_TypedefDef (void) {} void diff --git a/TAO/tao/IFR_Client/IFR_BaseC.i b/TAO/tao/IFR_Client/IFR_BaseC.i index 66e731e5d46..f2bf85a268b 100644 --- a/TAO/tao/IFR_Client/IFR_BaseC.i +++ b/TAO/tao/IFR_Client/IFR_BaseC.i @@ -781,21 +781,21 @@ CORBA::Contained::Description_out::operator-> (void) #if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_CONTAINEDSEQ_CI_) #define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_CONTAINEDSEQ_CI_ - ACE_INLINE Contained ** - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (CORBA::ULong nelems) + ACE_INLINE CORBA_Contained ** + _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (CORBA::ULong nelems) { - Contained **buf = 0; + CORBA_Contained **buf = 0; - ACE_NEW_RETURN (buf, Contained*[nelems], 0); + ACE_NEW_RETURN (buf, CORBA_Contained*[nelems], 0); for (CORBA::ULong i = 0; i < nelems; i++) - buf[i] = Contained::_nil (); + buf[i] = CORBA_Contained::_nil (); return buf; } ACE_INLINE void - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::freebuf (Contained **buffer) + _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::freebuf (CORBA_Contained **buffer) { if (buffer == 0) return; @@ -803,36 +803,36 @@ CORBA::Contained::Description_out::operator-> (void) } ACE_INLINE - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (void) + _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (void) { } ACE_INLINE - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (CORBA::ULong maximum) + _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (CORBA::ULong maximum) : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (maximum)) { } ACE_INLINE - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (CORBA::ULong maximum, + _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (CORBA::ULong maximum, CORBA::ULong length, - Contained* *value, + CORBA_Contained* *value, CORBA::Boolean release) : TAO_Unbounded_Base_Sequence (maximum, length, value, release) { } ACE_INLINE - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq(const _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq &rhs) + _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq(const _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq &rhs) : TAO_Unbounded_Base_Sequence (rhs) { if (rhs.buffer_ != 0) { - Contained **tmp1 = _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (this->maximum_); - Contained ** const tmp2 = ACE_reinterpret_cast (Contained ** ACE_CAST_CONST, rhs.buffer_); + CORBA_Contained **tmp1 = _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (this->maximum_); + CORBA_Contained ** const tmp2 = ACE_reinterpret_cast (CORBA_Contained ** ACE_CAST_CONST, rhs.buffer_); for (CORBA::ULong i = 0; i < rhs.length_; ++i) - tmp1[i] = Contained::_duplicate (tmp2[i]); + tmp1[i] = CORBA_Contained::_duplicate (tmp2[i]); this->buffer_ = tmp1; } @@ -842,20 +842,20 @@ CORBA::Contained::Description_out::operator-> (void) } } - ACE_INLINE CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq & - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq &rhs) + ACE_INLINE _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq & + _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq &rhs) { if (this == &rhs) return *this; if (this->release_) { - Contained **tmp = ACE_reinterpret_cast (Contained **, this->buffer_); + CORBA_Contained **tmp = ACE_reinterpret_cast (CORBA_Contained **, this->buffer_); for (CORBA::ULong i = 0; i < this->length_; ++i) { CORBA::release (tmp[i]); - tmp[i] = Contained::_nil (); + tmp[i] = CORBA_Contained::_nil (); } if (this->maximum_ < rhs.maximum_) { @@ -868,28 +868,28 @@ CORBA::Contained::Description_out::operator-> (void) TAO_Unbounded_Base_Sequence::operator= (rhs); - Contained **tmp1 = ACE_reinterpret_cast (Contained **, this->buffer_); - Contained ** const tmp2 = ACE_reinterpret_cast (Contained ** ACE_CAST_CONST, rhs.buffer_); + CORBA_Contained **tmp1 = ACE_reinterpret_cast (CORBA_Contained **, this->buffer_); + CORBA_Contained ** const tmp2 = ACE_reinterpret_cast (CORBA_Contained ** ACE_CAST_CONST, rhs.buffer_); for (CORBA::ULong i = 0; i < rhs.length_; ++i) - tmp1[i] = Contained::_duplicate (tmp2[i]); + tmp1[i] = CORBA_Contained::_duplicate (tmp2[i]); return *this; } ACE_INLINE TAO_Object_Manager<CORBA::Contained,CORBA::Contained_var> - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::operator[] (CORBA::ULong index) const + _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::operator[] (CORBA::ULong index) const // read-write accessor { ACE_ASSERT (index < this->maximum_); - Contained ** const tmp = ACE_reinterpret_cast (Contained ** ACE_CAST_CONST, this->buffer_); + CORBA_Contained ** const tmp = ACE_reinterpret_cast (CORBA_Contained ** ACE_CAST_CONST, this->buffer_); return TAO_Object_Manager<CORBA::Contained,CORBA::Contained_var> (tmp + index, this->release_); } - ACE_INLINE Contained* * - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::get_buffer (CORBA::Boolean orphan) + ACE_INLINE CORBA_Contained* * + _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::get_buffer (CORBA::Boolean orphan) { - Contained **result = 0; + CORBA_Contained **result = 0; if (orphan == 0) { // We retain ownership. @@ -901,7 +901,7 @@ CORBA::Contained::Description_out::operator-> (void) } else { - result = ACE_reinterpret_cast (Contained**, this->buffer_); + result = ACE_reinterpret_cast (CORBA_Contained**, this->buffer_); } } else // if (orphan == 1) @@ -910,7 +910,7 @@ CORBA::Contained::Description_out::operator-> (void) { // We set the state back to default and relinquish // ownership. - result = ACE_reinterpret_cast(Contained**,this->buffer_); + result = ACE_reinterpret_cast(CORBA_Contained**,this->buffer_); this->maximum_ = 0; this->length_ = 0; this->buffer_ = 0; @@ -920,10 +920,10 @@ CORBA::Contained::Description_out::operator-> (void) return result; } - ACE_INLINE const Contained* * - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::get_buffer (void) const + ACE_INLINE const CORBA_Contained* * + _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::get_buffer (void) const { - return ACE_reinterpret_cast(const Contained ** ACE_CAST_CONST, this->buffer_); + return ACE_reinterpret_cast(const CORBA_Contained ** ACE_CAST_CONST, this->buffer_); } @@ -1532,50 +1532,50 @@ CORBA_StructMember_out::operator-> (void) #define __TAO_UNBOUNDED_SEQUENCE_CORBA_STRUCTMEMBERSEQ_CI_ // = Static operations. - ACE_INLINE StructMember * - CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (CORBA::ULong size) + ACE_INLINE CORBA_StructMember * + _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (CORBA::ULong size) // Allocate storage for the sequence. { - StructMember *retval = 0; - ACE_NEW_RETURN (retval, StructMember[size], 0); + CORBA_StructMember *retval = 0; + ACE_NEW_RETURN (retval, CORBA_StructMember[size], 0); return retval; } - ACE_INLINE void CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::freebuf (StructMember *buffer) + ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::freebuf (CORBA_StructMember *buffer) // Free the sequence. { delete [] buffer; } ACE_INLINE - CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (void) // Default constructor. + _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (void) // Default constructor. { } ACE_INLINE - CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (CORBA::ULong maximum) // Constructor using a maximum length value. + _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (CORBA::ULong maximum) // Constructor using a maximum length value. : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (maximum)) { } ACE_INLINE - CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (CORBA::ULong maximum, + _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (CORBA::ULong maximum, CORBA::ULong length, - StructMember *data, + CORBA_StructMember *data, CORBA::Boolean release) : TAO_Unbounded_Base_Sequence (maximum, length, data, release) { } ACE_INLINE - CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (const _TAO_Unbounded_Sequence_CORBA_StructMemberSeq &rhs) + _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (const _TAO_Unbounded_Sequence_CORBA_StructMemberSeq &rhs) // Copy constructor. : TAO_Unbounded_Base_Sequence (rhs) { if (rhs.buffer_ != 0) { - StructMember *tmp1 = _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (this->maximum_); - StructMember * const tmp2 = ACE_reinterpret_cast (StructMember * ACE_CAST_CONST, rhs.buffer_); + CORBA_StructMember *tmp1 = _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (this->maximum_); + CORBA_StructMember * const tmp2 = ACE_reinterpret_cast (CORBA_StructMember * ACE_CAST_CONST, rhs.buffer_); for (CORBA::ULong i = 0; i < this->length_; ++i) tmp1[i] = tmp2[i]; @@ -1588,8 +1588,8 @@ CORBA_StructMember_out::operator-> (void) } } - ACE_INLINE CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq & - CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_StructMemberSeq &rhs) + ACE_INLINE _TAO_Unbounded_Sequence_CORBA_StructMemberSeq & + _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_StructMemberSeq &rhs) // Assignment operator. { if (this == &rhs) @@ -1600,7 +1600,7 @@ CORBA_StructMember_out::operator-> (void) if (this->maximum_ < rhs.maximum_) { // free the old buffer - StructMember *tmp = ACE_reinterpret_cast (StructMember *, this->buffer_); + CORBA_StructMember *tmp = ACE_reinterpret_cast (CORBA_StructMember *, this->buffer_); _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::freebuf (tmp); this->buffer_ = _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (rhs.maximum_); } @@ -1610,8 +1610,8 @@ CORBA_StructMember_out::operator-> (void) TAO_Unbounded_Base_Sequence::operator= (rhs); - StructMember *tmp1 = ACE_reinterpret_cast (StructMember *, this->buffer_); - StructMember * const tmp2 = ACE_reinterpret_cast (StructMember * ACE_CAST_CONST, rhs.buffer_); + CORBA_StructMember *tmp1 = ACE_reinterpret_cast (CORBA_StructMember *, this->buffer_); + CORBA_StructMember * const tmp2 = ACE_reinterpret_cast (CORBA_StructMember * ACE_CAST_CONST, rhs.buffer_); for (CORBA::ULong i = 0; i < this->length_; ++i) tmp1[i] = tmp2[i]; @@ -1620,30 +1620,30 @@ CORBA_StructMember_out::operator-> (void) } // = Accessors. - ACE_INLINE StructMember & - CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::operator[] (CORBA::ULong i) + ACE_INLINE CORBA_StructMember & + _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::operator[] (CORBA::ULong i) // operator [] { ACE_ASSERT (i < this->maximum_); - StructMember* tmp = ACE_reinterpret_cast(StructMember*,this->buffer_); + CORBA_StructMember* tmp = ACE_reinterpret_cast(CORBA_StructMember*,this->buffer_); return tmp[i]; } - ACE_INLINE const StructMember & - CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::operator[] (CORBA::ULong i) const + ACE_INLINE const CORBA_StructMember & + _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::operator[] (CORBA::ULong i) const // operator [] { ACE_ASSERT (i < this->maximum_); - StructMember * const tmp = ACE_reinterpret_cast (StructMember* ACE_CAST_CONST, this->buffer_); + CORBA_StructMember * const tmp = ACE_reinterpret_cast (CORBA_StructMember* ACE_CAST_CONST, this->buffer_); return tmp[i]; } // Implement the TAO_Base_Sequence methods (see Sequence.h) - ACE_INLINE StructMember * - CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::get_buffer (CORBA::Boolean orphan) + ACE_INLINE CORBA_StructMember * + _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::get_buffer (CORBA::Boolean orphan) { - StructMember *result = 0; + CORBA_StructMember *result = 0; if (orphan == 0) { // We retain ownership. @@ -1655,7 +1655,7 @@ CORBA_StructMember_out::operator-> (void) } else { - result = ACE_reinterpret_cast (StructMember*, this->buffer_); + result = ACE_reinterpret_cast (CORBA_StructMember*, this->buffer_); } } else // if (orphan == 1) @@ -1664,7 +1664,7 @@ CORBA_StructMember_out::operator-> (void) { // We set the state back to default and relinquish // ownership. - result = ACE_reinterpret_cast(StructMember*,this->buffer_); + result = ACE_reinterpret_cast(CORBA_StructMember*,this->buffer_); this->maximum_ = 0; this->length_ = 0; this->buffer_ = 0; @@ -1674,23 +1674,23 @@ CORBA_StructMember_out::operator-> (void) return result; } - ACE_INLINE const StructMember * - CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::get_buffer (void) const + ACE_INLINE const CORBA_StructMember * + _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::get_buffer (void) const { - return ACE_reinterpret_cast(const StructMember * ACE_CAST_CONST, this->buffer_); + return ACE_reinterpret_cast(const CORBA_StructMember * ACE_CAST_CONST, this->buffer_); } ACE_INLINE void - CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::replace (CORBA::ULong max, + _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::replace (CORBA::ULong max, CORBA::ULong length, - StructMember *data, + CORBA_StructMember *data, CORBA::Boolean release) { this->maximum_ = max; this->length_ = length; if (this->buffer_ && this->release_ == 1) { - StructMember *tmp = ACE_reinterpret_cast(StructMember*,this->buffer_); + CORBA_StructMember *tmp = ACE_reinterpret_cast(CORBA_StructMember*,this->buffer_); _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::freebuf (tmp); } this->buffer_ = data; @@ -2119,50 +2119,50 @@ CORBA_Initializer_out::operator-> (void) #define __TAO_UNBOUNDED_SEQUENCE_CORBA_INITIALIZERSEQ_CI_ // = Static operations. - ACE_INLINE Initializer * - CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (CORBA::ULong size) + ACE_INLINE CORBA_Initializer * + _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (CORBA::ULong size) // Allocate storage for the sequence. { - Initializer *retval = 0; - ACE_NEW_RETURN (retval, Initializer[size], 0); + CORBA_Initializer *retval = 0; + ACE_NEW_RETURN (retval, CORBA_Initializer[size], 0); return retval; } - ACE_INLINE void CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::freebuf (Initializer *buffer) + ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_InitializerSeq::freebuf (CORBA_Initializer *buffer) // Free the sequence. { delete [] buffer; } ACE_INLINE - CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::_TAO_Unbounded_Sequence_CORBA_InitializerSeq (void) // Default constructor. + _TAO_Unbounded_Sequence_CORBA_InitializerSeq::_TAO_Unbounded_Sequence_CORBA_InitializerSeq (void) // Default constructor. { } ACE_INLINE - CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::_TAO_Unbounded_Sequence_CORBA_InitializerSeq (CORBA::ULong maximum) // Constructor using a maximum length value. + _TAO_Unbounded_Sequence_CORBA_InitializerSeq::_TAO_Unbounded_Sequence_CORBA_InitializerSeq (CORBA::ULong maximum) // Constructor using a maximum length value. : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (maximum)) { } ACE_INLINE - CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::_TAO_Unbounded_Sequence_CORBA_InitializerSeq (CORBA::ULong maximum, + _TAO_Unbounded_Sequence_CORBA_InitializerSeq::_TAO_Unbounded_Sequence_CORBA_InitializerSeq (CORBA::ULong maximum, CORBA::ULong length, - Initializer *data, + CORBA_Initializer *data, CORBA::Boolean release) : TAO_Unbounded_Base_Sequence (maximum, length, data, release) { } ACE_INLINE - CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::_TAO_Unbounded_Sequence_CORBA_InitializerSeq (const _TAO_Unbounded_Sequence_CORBA_InitializerSeq &rhs) + _TAO_Unbounded_Sequence_CORBA_InitializerSeq::_TAO_Unbounded_Sequence_CORBA_InitializerSeq (const _TAO_Unbounded_Sequence_CORBA_InitializerSeq &rhs) // Copy constructor. : TAO_Unbounded_Base_Sequence (rhs) { if (rhs.buffer_ != 0) { - Initializer *tmp1 = _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (this->maximum_); - Initializer * const tmp2 = ACE_reinterpret_cast (Initializer * ACE_CAST_CONST, rhs.buffer_); + CORBA_Initializer *tmp1 = _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (this->maximum_); + CORBA_Initializer * const tmp2 = ACE_reinterpret_cast (CORBA_Initializer * ACE_CAST_CONST, rhs.buffer_); for (CORBA::ULong i = 0; i < this->length_; ++i) tmp1[i] = tmp2[i]; @@ -2175,8 +2175,8 @@ CORBA_Initializer_out::operator-> (void) } } - ACE_INLINE CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq & - CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_InitializerSeq &rhs) + ACE_INLINE _TAO_Unbounded_Sequence_CORBA_InitializerSeq & + _TAO_Unbounded_Sequence_CORBA_InitializerSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_InitializerSeq &rhs) // Assignment operator. { if (this == &rhs) @@ -2187,7 +2187,7 @@ CORBA_Initializer_out::operator-> (void) if (this->maximum_ < rhs.maximum_) { // free the old buffer - Initializer *tmp = ACE_reinterpret_cast (Initializer *, this->buffer_); + CORBA_Initializer *tmp = ACE_reinterpret_cast (CORBA_Initializer *, this->buffer_); _TAO_Unbounded_Sequence_CORBA_InitializerSeq::freebuf (tmp); this->buffer_ = _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (rhs.maximum_); } @@ -2197,8 +2197,8 @@ CORBA_Initializer_out::operator-> (void) TAO_Unbounded_Base_Sequence::operator= (rhs); - Initializer *tmp1 = ACE_reinterpret_cast (Initializer *, this->buffer_); - Initializer * const tmp2 = ACE_reinterpret_cast (Initializer * ACE_CAST_CONST, rhs.buffer_); + CORBA_Initializer *tmp1 = ACE_reinterpret_cast (CORBA_Initializer *, this->buffer_); + CORBA_Initializer * const tmp2 = ACE_reinterpret_cast (CORBA_Initializer * ACE_CAST_CONST, rhs.buffer_); for (CORBA::ULong i = 0; i < this->length_; ++i) tmp1[i] = tmp2[i]; @@ -2207,30 +2207,30 @@ CORBA_Initializer_out::operator-> (void) } // = Accessors. - ACE_INLINE Initializer & - CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::operator[] (CORBA::ULong i) + ACE_INLINE CORBA_Initializer & + _TAO_Unbounded_Sequence_CORBA_InitializerSeq::operator[] (CORBA::ULong i) // operator [] { ACE_ASSERT (i < this->maximum_); - Initializer* tmp = ACE_reinterpret_cast(Initializer*,this->buffer_); + CORBA_Initializer* tmp = ACE_reinterpret_cast(CORBA_Initializer*,this->buffer_); return tmp[i]; } - ACE_INLINE const Initializer & - CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::operator[] (CORBA::ULong i) const + ACE_INLINE const CORBA_Initializer & + _TAO_Unbounded_Sequence_CORBA_InitializerSeq::operator[] (CORBA::ULong i) const // operator [] { ACE_ASSERT (i < this->maximum_); - Initializer * const tmp = ACE_reinterpret_cast (Initializer* ACE_CAST_CONST, this->buffer_); + CORBA_Initializer * const tmp = ACE_reinterpret_cast (CORBA_Initializer* ACE_CAST_CONST, this->buffer_); return tmp[i]; } // Implement the TAO_Base_Sequence methods (see Sequence.h) - ACE_INLINE Initializer * - CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::get_buffer (CORBA::Boolean orphan) + ACE_INLINE CORBA_Initializer * + _TAO_Unbounded_Sequence_CORBA_InitializerSeq::get_buffer (CORBA::Boolean orphan) { - Initializer *result = 0; + CORBA_Initializer *result = 0; if (orphan == 0) { // We retain ownership. @@ -2242,7 +2242,7 @@ CORBA_Initializer_out::operator-> (void) } else { - result = ACE_reinterpret_cast (Initializer*, this->buffer_); + result = ACE_reinterpret_cast (CORBA_Initializer*, this->buffer_); } } else // if (orphan == 1) @@ -2251,7 +2251,7 @@ CORBA_Initializer_out::operator-> (void) { // We set the state back to default and relinquish // ownership. - result = ACE_reinterpret_cast(Initializer*,this->buffer_); + result = ACE_reinterpret_cast(CORBA_Initializer*,this->buffer_); this->maximum_ = 0; this->length_ = 0; this->buffer_ = 0; @@ -2261,23 +2261,23 @@ CORBA_Initializer_out::operator-> (void) return result; } - ACE_INLINE const Initializer * - CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::get_buffer (void) const + ACE_INLINE const CORBA_Initializer * + _TAO_Unbounded_Sequence_CORBA_InitializerSeq::get_buffer (void) const { - return ACE_reinterpret_cast(const Initializer * ACE_CAST_CONST, this->buffer_); + return ACE_reinterpret_cast(const CORBA_Initializer * ACE_CAST_CONST, this->buffer_); } ACE_INLINE void - CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::replace (CORBA::ULong max, + _TAO_Unbounded_Sequence_CORBA_InitializerSeq::replace (CORBA::ULong max, CORBA::ULong length, - Initializer *data, + CORBA_Initializer *data, CORBA::Boolean release) { this->maximum_ = max; this->length_ = length; if (this->buffer_ && this->release_ == 1) { - Initializer *tmp = ACE_reinterpret_cast(Initializer*,this->buffer_); + CORBA_Initializer *tmp = ACE_reinterpret_cast(CORBA_Initializer*,this->buffer_); _TAO_Unbounded_Sequence_CORBA_InitializerSeq::freebuf (tmp); } this->buffer_ = data; @@ -2706,50 +2706,50 @@ CORBA_UnionMember_out::operator-> (void) #define __TAO_UNBOUNDED_SEQUENCE_CORBA_UNIONMEMBERSEQ_CI_ // = Static operations. - ACE_INLINE UnionMember * - CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (CORBA::ULong size) + ACE_INLINE CORBA_UnionMember * + _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (CORBA::ULong size) // Allocate storage for the sequence. { - UnionMember *retval = 0; - ACE_NEW_RETURN (retval, UnionMember[size], 0); + CORBA_UnionMember *retval = 0; + ACE_NEW_RETURN (retval, CORBA_UnionMember[size], 0); return retval; } - ACE_INLINE void CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::freebuf (UnionMember *buffer) + ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::freebuf (CORBA_UnionMember *buffer) // Free the sequence. { delete [] buffer; } ACE_INLINE - CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (void) // Default constructor. + _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (void) // Default constructor. { } ACE_INLINE - CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (CORBA::ULong maximum) // Constructor using a maximum length value. + _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (CORBA::ULong maximum) // Constructor using a maximum length value. : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (maximum)) { } ACE_INLINE - CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (CORBA::ULong maximum, + _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (CORBA::ULong maximum, CORBA::ULong length, - UnionMember *data, + CORBA_UnionMember *data, CORBA::Boolean release) : TAO_Unbounded_Base_Sequence (maximum, length, data, release) { } ACE_INLINE - CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (const _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq &rhs) + _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (const _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq &rhs) // Copy constructor. : TAO_Unbounded_Base_Sequence (rhs) { if (rhs.buffer_ != 0) { - UnionMember *tmp1 = _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (this->maximum_); - UnionMember * const tmp2 = ACE_reinterpret_cast (UnionMember * ACE_CAST_CONST, rhs.buffer_); + CORBA_UnionMember *tmp1 = _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (this->maximum_); + CORBA_UnionMember * const tmp2 = ACE_reinterpret_cast (CORBA_UnionMember * ACE_CAST_CONST, rhs.buffer_); for (CORBA::ULong i = 0; i < this->length_; ++i) tmp1[i] = tmp2[i]; @@ -2762,8 +2762,8 @@ CORBA_UnionMember_out::operator-> (void) } } - ACE_INLINE CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq & - CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq &rhs) + ACE_INLINE _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq & + _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq &rhs) // Assignment operator. { if (this == &rhs) @@ -2774,7 +2774,7 @@ CORBA_UnionMember_out::operator-> (void) if (this->maximum_ < rhs.maximum_) { // free the old buffer - UnionMember *tmp = ACE_reinterpret_cast (UnionMember *, this->buffer_); + CORBA_UnionMember *tmp = ACE_reinterpret_cast (CORBA_UnionMember *, this->buffer_); _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::freebuf (tmp); this->buffer_ = _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (rhs.maximum_); } @@ -2784,8 +2784,8 @@ CORBA_UnionMember_out::operator-> (void) TAO_Unbounded_Base_Sequence::operator= (rhs); - UnionMember *tmp1 = ACE_reinterpret_cast (UnionMember *, this->buffer_); - UnionMember * const tmp2 = ACE_reinterpret_cast (UnionMember * ACE_CAST_CONST, rhs.buffer_); + CORBA_UnionMember *tmp1 = ACE_reinterpret_cast (CORBA_UnionMember *, this->buffer_); + CORBA_UnionMember * const tmp2 = ACE_reinterpret_cast (CORBA_UnionMember * ACE_CAST_CONST, rhs.buffer_); for (CORBA::ULong i = 0; i < this->length_; ++i) tmp1[i] = tmp2[i]; @@ -2794,30 +2794,30 @@ CORBA_UnionMember_out::operator-> (void) } // = Accessors. - ACE_INLINE UnionMember & - CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::operator[] (CORBA::ULong i) + ACE_INLINE CORBA_UnionMember & + _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::operator[] (CORBA::ULong i) // operator [] { ACE_ASSERT (i < this->maximum_); - UnionMember* tmp = ACE_reinterpret_cast(UnionMember*,this->buffer_); + CORBA_UnionMember* tmp = ACE_reinterpret_cast(CORBA_UnionMember*,this->buffer_); return tmp[i]; } - ACE_INLINE const UnionMember & - CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::operator[] (CORBA::ULong i) const + ACE_INLINE const CORBA_UnionMember & + _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::operator[] (CORBA::ULong i) const // operator [] { ACE_ASSERT (i < this->maximum_); - UnionMember * const tmp = ACE_reinterpret_cast (UnionMember* ACE_CAST_CONST, this->buffer_); + CORBA_UnionMember * const tmp = ACE_reinterpret_cast (CORBA_UnionMember* ACE_CAST_CONST, this->buffer_); return tmp[i]; } // Implement the TAO_Base_Sequence methods (see Sequence.h) - ACE_INLINE UnionMember * - CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::get_buffer (CORBA::Boolean orphan) + ACE_INLINE CORBA_UnionMember * + _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::get_buffer (CORBA::Boolean orphan) { - UnionMember *result = 0; + CORBA_UnionMember *result = 0; if (orphan == 0) { // We retain ownership. @@ -2829,7 +2829,7 @@ CORBA_UnionMember_out::operator-> (void) } else { - result = ACE_reinterpret_cast (UnionMember*, this->buffer_); + result = ACE_reinterpret_cast (CORBA_UnionMember*, this->buffer_); } } else // if (orphan == 1) @@ -2838,7 +2838,7 @@ CORBA_UnionMember_out::operator-> (void) { // We set the state back to default and relinquish // ownership. - result = ACE_reinterpret_cast(UnionMember*,this->buffer_); + result = ACE_reinterpret_cast(CORBA_UnionMember*,this->buffer_); this->maximum_ = 0; this->length_ = 0; this->buffer_ = 0; @@ -2848,23 +2848,23 @@ CORBA_UnionMember_out::operator-> (void) return result; } - ACE_INLINE const UnionMember * - CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::get_buffer (void) const + ACE_INLINE const CORBA_UnionMember * + _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::get_buffer (void) const { - return ACE_reinterpret_cast(const UnionMember * ACE_CAST_CONST, this->buffer_); + return ACE_reinterpret_cast(const CORBA_UnionMember * ACE_CAST_CONST, this->buffer_); } ACE_INLINE void - CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::replace (CORBA::ULong max, + _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::replace (CORBA::ULong max, CORBA::ULong length, - UnionMember *data, + CORBA_UnionMember *data, CORBA::Boolean release) { this->maximum_ = max; this->length_ = length; if (this->buffer_ && this->release_ == 1) { - UnionMember *tmp = ACE_reinterpret_cast(UnionMember*,this->buffer_); + CORBA_UnionMember *tmp = ACE_reinterpret_cast(CORBA_UnionMember*,this->buffer_); _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::freebuf (tmp); } this->buffer_ = data; @@ -3505,7 +3505,7 @@ CORBA::Container::Description_out::operator-> (void) #define __TAO_UNBOUNDED_SEQUENCE_CORBA_CONTAINER_DESCRIPTIONSEQ_CI_ // = Static operations. - ACE_INLINE Description * + ACE_INLINE CORBA::Container::Description * CORBA::Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::allocbuf (CORBA::ULong size) // Allocate storage for the sequence. { @@ -3593,30 +3593,30 @@ CORBA::Container::Description_out::operator-> (void) } // = Accessors. - ACE_INLINE Description & + ACE_INLINE CORBA::Container::Description & CORBA::Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::operator[] (CORBA::ULong i) // operator [] { ACE_ASSERT (i < this->maximum_); - Description* tmp = ACE_reinterpret_cast(Description*,this->buffer_); + CORBA::Container::Description* tmp = ACE_reinterpret_cast(CORBA::Container::Description*,this->buffer_); return tmp[i]; } - ACE_INLINE const Description & + ACE_INLINE const CORBA::Container::Description & CORBA::Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::operator[] (CORBA::ULong i) const // operator [] { ACE_ASSERT (i < this->maximum_); - Description * const tmp = ACE_reinterpret_cast (Description* ACE_CAST_CONST, this->buffer_); + CORBA::Container::Description * const tmp = ACE_reinterpret_cast (CORBA::Container::Description* ACE_CAST_CONST, this->buffer_); return tmp[i]; } // Implement the TAO_Base_Sequence methods (see Sequence.h) - ACE_INLINE Description * + ACE_INLINE CORBA::Container::Description * CORBA::Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::get_buffer (CORBA::Boolean orphan) { - Description *result = 0; + CORBA::Container::Description *result = 0; if (orphan == 0) { // We retain ownership. @@ -3628,7 +3628,7 @@ CORBA::Container::Description_out::operator-> (void) } else { - result = ACE_reinterpret_cast (Description*, this->buffer_); + result = ACE_reinterpret_cast (CORBA::Container::Description*, this->buffer_); } } else // if (orphan == 1) @@ -3637,7 +3637,7 @@ CORBA::Container::Description_out::operator-> (void) { // We set the state back to default and relinquish // ownership. - result = ACE_reinterpret_cast(Description*,this->buffer_); + result = ACE_reinterpret_cast(CORBA::Container::Description*,this->buffer_); this->maximum_ = 0; this->length_ = 0; this->buffer_ = 0; @@ -3647,23 +3647,23 @@ CORBA::Container::Description_out::operator-> (void) return result; } - ACE_INLINE const Description * + ACE_INLINE const CORBA::Container::Description * CORBA::Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::get_buffer (void) const { - return ACE_reinterpret_cast(const Description * ACE_CAST_CONST, this->buffer_); + return ACE_reinterpret_cast(const CORBA::Container::Description * ACE_CAST_CONST, this->buffer_); } ACE_INLINE void CORBA::Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::replace (CORBA::ULong max, CORBA::ULong length, - Description *data, + CORBA::Container::Description *data, CORBA::Boolean release) { this->maximum_ = max; this->length_ = length; if (this->buffer_ && this->release_ == 1) { - Description *tmp = ACE_reinterpret_cast(Description*,this->buffer_); + CORBA::Container::Description *tmp = ACE_reinterpret_cast(CORBA::Container::Description*,this->buffer_); _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::freebuf (tmp); } this->buffer_ = data; diff --git a/TAO/tao/IFR_Client/IFR_BasicC.cpp b/TAO/tao/IFR_Client/IFR_BasicC.cpp index 4a7ffeec116..6382ea57d6b 100644 --- a/TAO/tao/IFR_Client/IFR_BasicC.cpp +++ b/TAO/tao/IFR_Client/IFR_BasicC.cpp @@ -2491,7 +2491,7 @@ CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_local_interface:: // The Base_Sequence functions, please see tao/Sequence.h void - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_allocate_buffer (CORBA::ULong length) + _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_allocate_buffer (CORBA::ULong length) { CORBA::InterfaceDef **tmp = 0; tmp = _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::allocbuf (length); @@ -2513,7 +2513,7 @@ CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_local_interface:: } void - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_deallocate_buffer (void) + _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_deallocate_buffer (void) { if (this->buffer_ == 0 || this->release_ == 0) return; @@ -2527,13 +2527,13 @@ CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_local_interface:: this->buffer_ = 0; } - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::~_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (void) + _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::~_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (void) { this->_deallocate_buffer (); } void - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol) + _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol) { CORBA::InterfaceDef **tmp = ACE_reinterpret_cast (CORBA::InterfaceDef**, this->buffer_); @@ -2544,7 +2544,7 @@ CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_local_interface:: } } void - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_downcast ( + _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_downcast ( void* target, CORBA_Object *src, CORBA_Environment &ACE_TRY_ENV @@ -2556,7 +2556,7 @@ CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_local_interface:: } CORBA_Object* - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_upcast (void *src) const + _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_upcast (void *src) const { CORBA::InterfaceDef **tmp = ACE_static_cast (CORBA::InterfaceDef**, src); return *tmp; @@ -2621,7 +2621,7 @@ void CORBA_InterfaceDefSeq::_tao_any_destructor (void *x) // The Base_Sequence functions, please see tao/Sequence.h void - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_allocate_buffer (CORBA::ULong length) + _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_allocate_buffer (CORBA::ULong length) { CORBA::AbstractInterfaceDef **tmp = 0; tmp = _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::allocbuf (length); @@ -2643,7 +2643,7 @@ void CORBA_InterfaceDefSeq::_tao_any_destructor (void *x) } void - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_deallocate_buffer (void) + _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_deallocate_buffer (void) { if (this->buffer_ == 0 || this->release_ == 0) return; @@ -2657,13 +2657,13 @@ void CORBA_InterfaceDefSeq::_tao_any_destructor (void *x) this->buffer_ = 0; } - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::~_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq (void) + _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::~_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq (void) { this->_deallocate_buffer (); } void - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol) + _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol) { CORBA::AbstractInterfaceDef **tmp = ACE_reinterpret_cast (CORBA::AbstractInterfaceDef**, this->buffer_); @@ -2674,7 +2674,7 @@ void CORBA_InterfaceDefSeq::_tao_any_destructor (void *x) } } void - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_downcast ( + _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_downcast ( void* target, CORBA_Object *src, CORBA_Environment &ACE_TRY_ENV @@ -2686,7 +2686,7 @@ void CORBA_InterfaceDefSeq::_tao_any_destructor (void *x) } CORBA_Object* - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_upcast (void *src) const + _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_upcast (void *src) const { CORBA::AbstractInterfaceDef **tmp = ACE_static_cast (CORBA::AbstractInterfaceDef**, src); return *tmp; @@ -2751,7 +2751,7 @@ void CORBA_AbstractInterfaceDefSeq::_tao_any_destructor (void *x) // The Base_Sequence functions, please see tao/Sequence.h void - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_allocate_buffer (CORBA::ULong length) + _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_allocate_buffer (CORBA::ULong length) { CORBA::LocalInterfaceDef **tmp = 0; tmp = _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::allocbuf (length); @@ -2773,7 +2773,7 @@ void CORBA_AbstractInterfaceDefSeq::_tao_any_destructor (void *x) } void - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_deallocate_buffer (void) + _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_deallocate_buffer (void) { if (this->buffer_ == 0 || this->release_ == 0) return; @@ -2787,13 +2787,13 @@ void CORBA_AbstractInterfaceDefSeq::_tao_any_destructor (void *x) this->buffer_ = 0; } - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::~_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq (void) + _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::~_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq (void) { this->_deallocate_buffer (); } void - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol) + _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol) { CORBA::LocalInterfaceDef **tmp = ACE_reinterpret_cast (CORBA::LocalInterfaceDef**, this->buffer_); @@ -2804,7 +2804,7 @@ void CORBA_AbstractInterfaceDefSeq::_tao_any_destructor (void *x) } } void - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_downcast ( + _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_downcast ( void* target, CORBA_Object *src, CORBA_Environment &ACE_TRY_ENV @@ -2816,7 +2816,7 @@ void CORBA_AbstractInterfaceDefSeq::_tao_any_destructor (void *x) } CORBA_Object* - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_upcast (void *src) const + _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_upcast (void *src) const { CORBA::LocalInterfaceDef **tmp = ACE_static_cast (CORBA::LocalInterfaceDef**, src); return *tmp; @@ -4152,13 +4152,13 @@ _TAO_Repository_Remote_Proxy_Broker::select_proxy ( // default constructor -CORBA::Repository::Repository (int collocated) +CORBA_Repository::CORBA_Repository (int collocated) { this->CORBA_Repository_setup_collocation (collocated); } // destructor -CORBA::Repository::~Repository (void) +CORBA_Repository::~CORBA_Repository (void) {} void @@ -5067,13 +5067,13 @@ _TAO_ModuleDef_Remote_Proxy_Broker::select_proxy ( // default constructor -CORBA::ModuleDef::ModuleDef (int collocated) +CORBA_ModuleDef::CORBA_ModuleDef (int collocated) { this->CORBA_ModuleDef_setup_collocation (collocated); } // destructor -CORBA::ModuleDef::~ModuleDef (void) +CORBA_ModuleDef::~CORBA_ModuleDef (void) {} void @@ -6103,13 +6103,13 @@ _TAO_ConstantDef_Remote_Proxy_Broker::select_proxy ( // default constructor -CORBA::ConstantDef::ConstantDef (int collocated) +CORBA_ConstantDef::CORBA_ConstantDef (int collocated) { this->CORBA_ConstantDef_setup_collocation (collocated); } // destructor -CORBA::ConstantDef::~ConstantDef (void) +CORBA_ConstantDef::~CORBA_ConstantDef (void) {} void @@ -7020,13 +7020,13 @@ _TAO_StructDef_Remote_Proxy_Broker::select_proxy ( // default constructor -CORBA::StructDef::StructDef (int collocated) +CORBA_StructDef::CORBA_StructDef (int collocated) { this->CORBA_StructDef_setup_collocation (collocated); } // destructor -CORBA::StructDef::~StructDef (void) +CORBA_StructDef::~CORBA_StructDef (void) {} void @@ -8223,13 +8223,13 @@ _TAO_UnionDef_Remote_Proxy_Broker::select_proxy ( // default constructor -CORBA::UnionDef::UnionDef (int collocated) +CORBA_UnionDef::CORBA_UnionDef (int collocated) { this->CORBA_UnionDef_setup_collocation (collocated); } // destructor -CORBA::UnionDef::~UnionDef (void) +CORBA_UnionDef::~CORBA_UnionDef (void) {} void @@ -9175,13 +9175,13 @@ _TAO_EnumDef_Remote_Proxy_Broker::select_proxy ( // default constructor -CORBA::EnumDef::EnumDef (int collocated) +CORBA_EnumDef::CORBA_EnumDef (int collocated) { this->CORBA_EnumDef_setup_collocation (collocated); } // destructor -CORBA::EnumDef::~EnumDef (void) +CORBA_EnumDef::~CORBA_EnumDef (void) {} void @@ -9890,13 +9890,13 @@ _TAO_AliasDef_Remote_Proxy_Broker::select_proxy ( // default constructor -CORBA::AliasDef::AliasDef (int collocated) +CORBA_AliasDef::CORBA_AliasDef (int collocated) { this->CORBA_AliasDef_setup_collocation (collocated); } // destructor -CORBA::AliasDef::~AliasDef (void) +CORBA_AliasDef::~CORBA_AliasDef (void) {} void @@ -10293,13 +10293,13 @@ _TAO_NativeDef_Remote_Proxy_Broker::select_proxy ( // default constructor -CORBA::NativeDef::NativeDef (int collocated) +CORBA_NativeDef::CORBA_NativeDef (int collocated) { this->CORBA_NativeDef_setup_collocation (collocated); } // destructor -CORBA::NativeDef::~NativeDef (void) +CORBA_NativeDef::~CORBA_NativeDef (void) {} void @@ -10706,13 +10706,13 @@ _TAO_PrimitiveDef_Remote_Proxy_Broker::select_proxy ( // default constructor -CORBA::PrimitiveDef::PrimitiveDef (int collocated) +CORBA_PrimitiveDef::CORBA_PrimitiveDef (int collocated) { this->CORBA_PrimitiveDef_setup_collocation (collocated); } // destructor -CORBA::PrimitiveDef::~PrimitiveDef (void) +CORBA_PrimitiveDef::~CORBA_PrimitiveDef (void) {} void @@ -11318,13 +11318,13 @@ _TAO_StringDef_Remote_Proxy_Broker::select_proxy ( // default constructor -CORBA::StringDef::StringDef (int collocated) +CORBA_StringDef::CORBA_StringDef (int collocated) { this->CORBA_StringDef_setup_collocation (collocated); } // destructor -CORBA::StringDef::~StringDef (void) +CORBA_StringDef::~CORBA_StringDef (void) {} void @@ -12004,13 +12004,13 @@ _TAO_WstringDef_Remote_Proxy_Broker::select_proxy ( // default constructor -CORBA::WstringDef::WstringDef (int collocated) +CORBA_WstringDef::CORBA_WstringDef (int collocated) { this->CORBA_WstringDef_setup_collocation (collocated); } // destructor -CORBA::WstringDef::~WstringDef (void) +CORBA_WstringDef::~CORBA_WstringDef (void) {} void @@ -13162,13 +13162,13 @@ _TAO_SequenceDef_Remote_Proxy_Broker::select_proxy ( // default constructor -CORBA::SequenceDef::SequenceDef (int collocated) +CORBA_SequenceDef::CORBA_SequenceDef (int collocated) { this->CORBA_SequenceDef_setup_collocation (collocated); } // destructor -CORBA::SequenceDef::~SequenceDef (void) +CORBA_SequenceDef::~CORBA_SequenceDef (void) {} void @@ -14541,13 +14541,13 @@ _TAO_ArrayDef_Remote_Proxy_Broker::select_proxy ( // default constructor -CORBA::ArrayDef::ArrayDef (int collocated) +CORBA_ArrayDef::CORBA_ArrayDef (int collocated) { this->CORBA_ArrayDef_setup_collocation (collocated); } // destructor -CORBA::ArrayDef::~ArrayDef (void) +CORBA_ArrayDef::~CORBA_ArrayDef (void) {} void @@ -15611,13 +15611,13 @@ _TAO_ExceptionDef_Remote_Proxy_Broker::select_proxy ( // default constructor -CORBA::ExceptionDef::ExceptionDef (int collocated) +CORBA_ExceptionDef::CORBA_ExceptionDef (int collocated) { this->CORBA_ExceptionDef_setup_collocation (collocated); } // destructor -CORBA::ExceptionDef::~ExceptionDef (void) +CORBA_ExceptionDef::~CORBA_ExceptionDef (void) {} void @@ -16024,7 +16024,7 @@ void CORBA::ExceptionDescription::_tao_any_destructor (void *x) // The Base_Sequence functions, please see tao/Sequence.h void - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_allocate_buffer (CORBA::ULong length) + _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_allocate_buffer (CORBA::ULong length) { CORBA::ExceptionDef **tmp = 0; tmp = _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::allocbuf (length); @@ -16046,7 +16046,7 @@ void CORBA::ExceptionDescription::_tao_any_destructor (void *x) } void - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_deallocate_buffer (void) + _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_deallocate_buffer (void) { if (this->buffer_ == 0 || this->release_ == 0) return; @@ -16060,13 +16060,13 @@ void CORBA::ExceptionDescription::_tao_any_destructor (void *x) this->buffer_ = 0; } - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::~_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (void) + _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::~_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (void) { this->_deallocate_buffer (); } void - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol) + _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol) { CORBA::ExceptionDef **tmp = ACE_reinterpret_cast (CORBA::ExceptionDef**, this->buffer_); @@ -16077,7 +16077,7 @@ void CORBA::ExceptionDescription::_tao_any_destructor (void *x) } } void - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_downcast ( + _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_downcast ( void* target, CORBA_Object *src, CORBA_Environment &ACE_TRY_ENV @@ -16089,7 +16089,7 @@ void CORBA::ExceptionDescription::_tao_any_destructor (void *x) } CORBA_Object* - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_upcast (void *src) const + _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_upcast (void *src) const { CORBA::ExceptionDef **tmp = ACE_static_cast (CORBA::ExceptionDef**, src); return *tmp; @@ -16153,7 +16153,7 @@ void CORBA_ExceptionDefSeq::_tao_any_destructor (void *x) #define __TAO_UNBOUNDED_SEQUENCE_CORBA_EXCDESCRIPTIONSEQ_CS_ void - CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_allocate_buffer (CORBA::ULong length) + _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_allocate_buffer (CORBA::ULong length) { CORBA::ExceptionDescription* tmp = 0; tmp = _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::allocbuf (length); @@ -16173,7 +16173,7 @@ void CORBA_ExceptionDefSeq::_tao_any_destructor (void *x) } void - CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_deallocate_buffer (void) + _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_deallocate_buffer (void) { if (this->buffer_ == 0 || this->release_ == 0) return; @@ -16184,7 +16184,7 @@ void CORBA_ExceptionDefSeq::_tao_any_destructor (void *x) this->buffer_ = 0; } - CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::~_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (void) // Dtor. + _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::~_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (void) // Dtor. { this->_deallocate_buffer (); } @@ -17090,13 +17090,13 @@ _TAO_AttributeDef_Remote_Proxy_Broker::select_proxy ( // default constructor -CORBA::AttributeDef::AttributeDef (int collocated) +CORBA_AttributeDef::CORBA_AttributeDef (int collocated) { this->CORBA_AttributeDef_setup_collocation (collocated); } // destructor -CORBA::AttributeDef::~AttributeDef (void) +CORBA_AttributeDef::~CORBA_AttributeDef (void) {} void @@ -17641,7 +17641,7 @@ void CORBA::ParameterDescription::_tao_any_destructor (void *x) #define __TAO_UNBOUNDED_SEQUENCE_CORBA_PARDESCRIPTIONSEQ_CS_ void - CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_allocate_buffer (CORBA::ULong length) + _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_allocate_buffer (CORBA::ULong length) { CORBA::ParameterDescription* tmp = 0; tmp = _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::allocbuf (length); @@ -17661,7 +17661,7 @@ void CORBA::ParameterDescription::_tao_any_destructor (void *x) } void - CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_deallocate_buffer (void) + _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_deallocate_buffer (void) { if (this->buffer_ == 0 || this->release_ == 0) return; @@ -17672,7 +17672,7 @@ void CORBA::ParameterDescription::_tao_any_destructor (void *x) this->buffer_ = 0; } - CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::~_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (void) // Dtor. + _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::~_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (void) // Dtor. { this->_deallocate_buffer (); } @@ -19564,13 +19564,13 @@ _TAO_OperationDef_Remote_Proxy_Broker::select_proxy ( // default constructor -CORBA::OperationDef::OperationDef (int collocated) +CORBA_OperationDef::CORBA_OperationDef (int collocated) { this->CORBA_OperationDef_setup_collocation (collocated); } // destructor -CORBA::OperationDef::~OperationDef (void) +CORBA_OperationDef::~CORBA_OperationDef (void) {} void @@ -20600,7 +20600,7 @@ void CORBA_RepositoryIdSeq::_tao_any_destructor (void *x) #define __TAO_UNBOUNDED_SEQUENCE_CORBA_OPDESCRIPTIONSEQ_CS_ void - CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_allocate_buffer (CORBA::ULong length) + _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_allocate_buffer (CORBA::ULong length) { CORBA::OperationDescription* tmp = 0; tmp = _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::allocbuf (length); @@ -20620,7 +20620,7 @@ void CORBA_RepositoryIdSeq::_tao_any_destructor (void *x) } void - CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_deallocate_buffer (void) + _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_deallocate_buffer (void) { if (this->buffer_ == 0 || this->release_ == 0) return; @@ -20631,7 +20631,7 @@ void CORBA_RepositoryIdSeq::_tao_any_destructor (void *x) this->buffer_ = 0; } - CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::~_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (void) // Dtor. + _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::~_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (void) // Dtor. { this->_deallocate_buffer (); } @@ -20695,7 +20695,7 @@ void CORBA_OpDescriptionSeq::_tao_any_destructor (void *x) #define __TAO_UNBOUNDED_SEQUENCE_CORBA_ATTRDESCRIPTIONSEQ_CS_ void - CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_allocate_buffer (CORBA::ULong length) + _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_allocate_buffer (CORBA::ULong length) { CORBA::AttributeDescription* tmp = 0; tmp = _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::allocbuf (length); @@ -20715,7 +20715,7 @@ void CORBA_OpDescriptionSeq::_tao_any_destructor (void *x) } void - CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_deallocate_buffer (void) + _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_deallocate_buffer (void) { if (this->buffer_ == 0 || this->release_ == 0) return; @@ -20726,7 +20726,7 @@ void CORBA_OpDescriptionSeq::_tao_any_destructor (void *x) this->buffer_ = 0; } - CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::~_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (void) // Dtor. + _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::~_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (void) // Dtor. { this->_deallocate_buffer (); } @@ -21870,13 +21870,13 @@ _TAO_InterfaceDef_Remote_Proxy_Broker::select_proxy ( // default constructor -CORBA::InterfaceDef::InterfaceDef (int collocated) +CORBA_InterfaceDef::CORBA_InterfaceDef (int collocated) { this->CORBA_InterfaceDef_setup_collocation (collocated); } // destructor -CORBA::InterfaceDef::~InterfaceDef (void) +CORBA_InterfaceDef::~CORBA_InterfaceDef (void) {} void @@ -23641,13 +23641,13 @@ _TAO_AbstractInterfaceDef_Remote_Proxy_Broker::select_proxy ( // default constructor -CORBA::AbstractInterfaceDef::AbstractInterfaceDef (int collocated) +CORBA_AbstractInterfaceDef::CORBA_AbstractInterfaceDef (int collocated) { this->CORBA_AbstractInterfaceDef_setup_collocation (collocated); } // destructor -CORBA::AbstractInterfaceDef::~AbstractInterfaceDef (void) +CORBA_AbstractInterfaceDef::~CORBA_AbstractInterfaceDef (void) {} void @@ -23909,13 +23909,13 @@ _TAO_LocalInterfaceDef_Remote_Proxy_Broker::select_proxy ( // default constructor -CORBA::LocalInterfaceDef::LocalInterfaceDef (int collocated) +CORBA_LocalInterfaceDef::CORBA_LocalInterfaceDef (int collocated) { this->CORBA_LocalInterfaceDef_setup_collocation (collocated); } // destructor -CORBA::LocalInterfaceDef::~LocalInterfaceDef (void) +CORBA_LocalInterfaceDef::~CORBA_LocalInterfaceDef (void) {} void diff --git a/TAO/tao/IFR_Client/IFR_BasicC.h b/TAO/tao/IFR_Client/IFR_BasicC.h index c9f23caae16..7f48cb9bc77 100644 --- a/TAO/tao/IFR_Client/IFR_BasicC.h +++ b/TAO/tao/IFR_Client/IFR_BasicC.h @@ -23,13 +23,12 @@ #define TAO_IDL_IFR_BASICC_H #include "ace/pre.h" +#include "IFR_BaseC.h" #if !defined (ACE_LACKS_PRAGMA_ONCE) # pragma once #endif /* ACE_LACKS_PRAGMA_ONCE */ -#include "IFR_BaseC.h" - #if defined (TAO_EXPORT_MACRO) #undef TAO_EXPORT_MACRO #endif @@ -11835,45 +11834,6 @@ TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::Abs TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::LocalInterfaceDef_ptr); TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::LocalInterfaceDef *&); -#ifndef __ACE_INLINE__ - -TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::PrimitiveKind &); // -TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::PrimitiveKind &); -TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::Repository_ptr ); -TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::Repository_ptr &); -TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ModuleDef_ptr ); -TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ModuleDef_ptr &); -TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ModuleDescription &); -TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ModuleDescription &); -TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ConstantDef_ptr ); -TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ConstantDef_ptr &); -TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ConstantDescription &); -TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ConstantDescription &); -TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::StructDef_ptr ); -TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::StructDef_ptr &); -TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::UnionDef_ptr ); -TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::UnionDef_ptr &); -TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::EnumDef_ptr ); -TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::EnumDef_ptr &); -TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::AliasDef_ptr ); -TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::AliasDef_ptr &); -TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::NativeDef_ptr ); -TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::NativeDef_ptr &); -TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::PrimitiveDef_ptr ); -TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::PrimitiveDef_ptr &); -TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::StringDef_ptr ); -TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::StringDef_ptr &); -TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::WstringDef_ptr ); -TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::WstringDef_ptr &); -TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::SequenceDef_ptr ); -TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::SequenceDef_ptr &); -TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ArrayDef_ptr ); -TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ArrayDef_ptr &); -TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ExceptionDef_ptr ); -TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ExceptionDef_ptr &); -TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ExceptionDescription &); -TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ExceptionDescription &); - // ************************************************************** // CDR operators for classes moved from IFR_BaseC.h @@ -11923,6 +11883,45 @@ TAO_IFR_Client_Export CORBA::Boolean operator>> ( // ********************************************************** +#ifndef __ACE_INLINE__ + +TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::PrimitiveKind &); // +TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::PrimitiveKind &); +TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::Repository_ptr ); +TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::Repository_ptr &); +TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ModuleDef_ptr ); +TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ModuleDef_ptr &); +TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ModuleDescription &); +TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ModuleDescription &); +TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ConstantDef_ptr ); +TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ConstantDef_ptr &); +TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ConstantDescription &); +TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ConstantDescription &); +TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::StructDef_ptr ); +TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::StructDef_ptr &); +TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::UnionDef_ptr ); +TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::UnionDef_ptr &); +TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::EnumDef_ptr ); +TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::EnumDef_ptr &); +TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::AliasDef_ptr ); +TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::AliasDef_ptr &); +TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::NativeDef_ptr ); +TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::NativeDef_ptr &); +TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::PrimitiveDef_ptr ); +TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::PrimitiveDef_ptr &); +TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::StringDef_ptr ); +TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::StringDef_ptr &); +TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::WstringDef_ptr ); +TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::WstringDef_ptr &); +TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::SequenceDef_ptr ); +TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::SequenceDef_ptr &); +TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ArrayDef_ptr ); +TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ArrayDef_ptr &); +TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ExceptionDef_ptr ); +TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ExceptionDef_ptr &); +TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ExceptionDescription &); +TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ExceptionDescription &); + #if !defined _TAO_CDR_OP_CORBA_ExceptionDefSeq_H_ #define _TAO_CDR_OP_CORBA_ExceptionDefSeq_H_ diff --git a/TAO/tao/IFR_Client/IFR_BasicC.i b/TAO/tao/IFR_Client/IFR_BasicC.i index e37507f627e..d51384effc6 100644 --- a/TAO/tao/IFR_Client/IFR_BasicC.i +++ b/TAO/tao/IFR_Client/IFR_BasicC.i @@ -29,7 +29,7 @@ #define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_INTERFACEDEFSEQ_CI_ ACE_INLINE CORBA::InterfaceDef ** - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::allocbuf (CORBA::ULong nelems) + _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::allocbuf (CORBA::ULong nelems) { CORBA::InterfaceDef **buf = 0; @@ -42,7 +42,7 @@ } ACE_INLINE void - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::freebuf (CORBA::InterfaceDef **buffer) + _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::freebuf (CORBA::InterfaceDef **buffer) { if (buffer == 0) return; @@ -50,18 +50,18 @@ } ACE_INLINE - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (void) + _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (void) { } ACE_INLINE - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (CORBA::ULong maximum) + _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (CORBA::ULong maximum) : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::allocbuf (maximum)) { } ACE_INLINE - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (CORBA::ULong maximum, + _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (CORBA::ULong maximum, CORBA::ULong length, CORBA::InterfaceDef* *value, CORBA::Boolean release) @@ -70,7 +70,7 @@ } ACE_INLINE - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq &rhs) + _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq &rhs) : TAO_Unbounded_Base_Sequence (rhs) { if (rhs.buffer_ != 0) @@ -89,8 +89,8 @@ } } - ACE_INLINE CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq & - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq &rhs) + ACE_INLINE _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq & + _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq &rhs) { if (this == &rhs) return *this; @@ -125,7 +125,7 @@ } ACE_INLINE TAO_Object_Manager<CORBA::InterfaceDef,CORBA::InterfaceDef_var> - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::operator[] (CORBA::ULong index) const + _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::operator[] (CORBA::ULong index) const // read-write accessor { ACE_ASSERT (index < this->maximum_); @@ -134,7 +134,7 @@ } ACE_INLINE CORBA::InterfaceDef* * - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::get_buffer (CORBA::Boolean orphan) + _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::get_buffer (CORBA::Boolean orphan) { CORBA::InterfaceDef **result = 0; if (orphan == 0) @@ -168,7 +168,7 @@ } ACE_INLINE const CORBA::InterfaceDef* * - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::get_buffer (void) const + _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::get_buffer (void) const { return ACE_reinterpret_cast(const CORBA::InterfaceDef ** ACE_CAST_CONST, this->buffer_); } @@ -396,7 +396,7 @@ CORBA_InterfaceDefSeq_out::operator[] (CORBA::ULong index) #define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_ABSTRACTINTERFACEDEFSEQ_CI_ ACE_INLINE CORBA::AbstractInterfaceDef ** - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::allocbuf (CORBA::ULong nelems) + _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::allocbuf (CORBA::ULong nelems) { CORBA::AbstractInterfaceDef **buf = 0; @@ -409,7 +409,7 @@ CORBA_InterfaceDefSeq_out::operator[] (CORBA::ULong index) } ACE_INLINE void - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::freebuf (CORBA::AbstractInterfaceDef **buffer) + _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::freebuf (CORBA::AbstractInterfaceDef **buffer) { if (buffer == 0) return; @@ -417,18 +417,18 @@ CORBA_InterfaceDefSeq_out::operator[] (CORBA::ULong index) } ACE_INLINE - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq (void) + _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq (void) { } ACE_INLINE - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq (CORBA::ULong maximum) + _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq (CORBA::ULong maximum) : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::allocbuf (maximum)) { } ACE_INLINE - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq (CORBA::ULong maximum, + _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq (CORBA::ULong maximum, CORBA::ULong length, CORBA::AbstractInterfaceDef* *value, CORBA::Boolean release) @@ -437,7 +437,7 @@ CORBA_InterfaceDefSeq_out::operator[] (CORBA::ULong index) } ACE_INLINE - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq &rhs) + _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq &rhs) : TAO_Unbounded_Base_Sequence (rhs) { if (rhs.buffer_ != 0) @@ -456,8 +456,8 @@ CORBA_InterfaceDefSeq_out::operator[] (CORBA::ULong index) } } - ACE_INLINE CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq & - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq &rhs) + ACE_INLINE _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq & + _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq &rhs) { if (this == &rhs) return *this; @@ -492,7 +492,7 @@ CORBA_InterfaceDefSeq_out::operator[] (CORBA::ULong index) } ACE_INLINE TAO_Object_Manager<CORBA::AbstractInterfaceDef,CORBA::AbstractInterfaceDef_var> - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::operator[] (CORBA::ULong index) const + _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::operator[] (CORBA::ULong index) const // read-write accessor { ACE_ASSERT (index < this->maximum_); @@ -501,7 +501,7 @@ CORBA_InterfaceDefSeq_out::operator[] (CORBA::ULong index) } ACE_INLINE CORBA::AbstractInterfaceDef* * - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::get_buffer (CORBA::Boolean orphan) + _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::get_buffer (CORBA::Boolean orphan) { CORBA::AbstractInterfaceDef **result = 0; if (orphan == 0) @@ -535,7 +535,7 @@ CORBA_InterfaceDefSeq_out::operator[] (CORBA::ULong index) } ACE_INLINE const CORBA::AbstractInterfaceDef* * - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::get_buffer (void) const + _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::get_buffer (void) const { return ACE_reinterpret_cast(const CORBA::AbstractInterfaceDef ** ACE_CAST_CONST, this->buffer_); } @@ -763,7 +763,7 @@ CORBA_AbstractInterfaceDefSeq_out::operator[] (CORBA::ULong index) #define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_LOCALINTERFACEDEFSEQ_CI_ ACE_INLINE CORBA::LocalInterfaceDef ** - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::allocbuf (CORBA::ULong nelems) + _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::allocbuf (CORBA::ULong nelems) { CORBA::LocalInterfaceDef **buf = 0; @@ -776,7 +776,7 @@ CORBA_AbstractInterfaceDefSeq_out::operator[] (CORBA::ULong index) } ACE_INLINE void - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::freebuf (CORBA::LocalInterfaceDef **buffer) + _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::freebuf (CORBA::LocalInterfaceDef **buffer) { if (buffer == 0) return; @@ -784,18 +784,18 @@ CORBA_AbstractInterfaceDefSeq_out::operator[] (CORBA::ULong index) } ACE_INLINE - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq (void) + _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq (void) { } ACE_INLINE - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq (CORBA::ULong maximum) + _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq (CORBA::ULong maximum) : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::allocbuf (maximum)) { } ACE_INLINE - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq (CORBA::ULong maximum, + _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq (CORBA::ULong maximum, CORBA::ULong length, CORBA::LocalInterfaceDef* *value, CORBA::Boolean release) @@ -804,7 +804,7 @@ CORBA_AbstractInterfaceDefSeq_out::operator[] (CORBA::ULong index) } ACE_INLINE - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq &rhs) + _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq &rhs) : TAO_Unbounded_Base_Sequence (rhs) { if (rhs.buffer_ != 0) @@ -823,8 +823,8 @@ CORBA_AbstractInterfaceDefSeq_out::operator[] (CORBA::ULong index) } } - ACE_INLINE CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq & - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq &rhs) + ACE_INLINE _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq & + _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq &rhs) { if (this == &rhs) return *this; @@ -859,7 +859,7 @@ CORBA_AbstractInterfaceDefSeq_out::operator[] (CORBA::ULong index) } ACE_INLINE TAO_Object_Manager<CORBA::LocalInterfaceDef,CORBA::LocalInterfaceDef_var> - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::operator[] (CORBA::ULong index) const + _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::operator[] (CORBA::ULong index) const // read-write accessor { ACE_ASSERT (index < this->maximum_); @@ -868,7 +868,7 @@ CORBA_AbstractInterfaceDefSeq_out::operator[] (CORBA::ULong index) } ACE_INLINE CORBA::LocalInterfaceDef* * - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::get_buffer (CORBA::Boolean orphan) + _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::get_buffer (CORBA::Boolean orphan) { CORBA::LocalInterfaceDef **result = 0; if (orphan == 0) @@ -902,7 +902,7 @@ CORBA_AbstractInterfaceDefSeq_out::operator[] (CORBA::ULong index) } ACE_INLINE const CORBA::LocalInterfaceDef* * - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::get_buffer (void) const + _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::get_buffer (void) const { return ACE_reinterpret_cast(const CORBA::LocalInterfaceDef ** ACE_CAST_CONST, this->buffer_); } @@ -4334,7 +4334,7 @@ CORBA_ExceptionDescription_out::operator-> (void) #define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_EXCEPTIONDEFSEQ_CI_ ACE_INLINE CORBA::ExceptionDef ** - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::allocbuf (CORBA::ULong nelems) + _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::allocbuf (CORBA::ULong nelems) { CORBA::ExceptionDef **buf = 0; @@ -4347,7 +4347,7 @@ CORBA_ExceptionDescription_out::operator-> (void) } ACE_INLINE void - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::freebuf (CORBA::ExceptionDef **buffer) + _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::freebuf (CORBA::ExceptionDef **buffer) { if (buffer == 0) return; @@ -4355,18 +4355,18 @@ CORBA_ExceptionDescription_out::operator-> (void) } ACE_INLINE - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (void) + _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (void) { } ACE_INLINE - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (CORBA::ULong maximum) + _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (CORBA::ULong maximum) : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::allocbuf (maximum)) { } ACE_INLINE - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (CORBA::ULong maximum, + _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (CORBA::ULong maximum, CORBA::ULong length, CORBA::ExceptionDef* *value, CORBA::Boolean release) @@ -4375,7 +4375,7 @@ CORBA_ExceptionDescription_out::operator-> (void) } ACE_INLINE - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq &rhs) + _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq &rhs) : TAO_Unbounded_Base_Sequence (rhs) { if (rhs.buffer_ != 0) @@ -4394,8 +4394,8 @@ CORBA_ExceptionDescription_out::operator-> (void) } } - ACE_INLINE CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq & - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq &rhs) + ACE_INLINE _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq & + _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq &rhs) { if (this == &rhs) return *this; @@ -4430,7 +4430,7 @@ CORBA_ExceptionDescription_out::operator-> (void) } ACE_INLINE TAO_Object_Manager<CORBA::ExceptionDef,CORBA::ExceptionDef_var> - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::operator[] (CORBA::ULong index) const + _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::operator[] (CORBA::ULong index) const // read-write accessor { ACE_ASSERT (index < this->maximum_); @@ -4439,7 +4439,7 @@ CORBA_ExceptionDescription_out::operator-> (void) } ACE_INLINE CORBA::ExceptionDef* * - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::get_buffer (CORBA::Boolean orphan) + _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::get_buffer (CORBA::Boolean orphan) { CORBA::ExceptionDef **result = 0; if (orphan == 0) @@ -4473,7 +4473,7 @@ CORBA_ExceptionDescription_out::operator-> (void) } ACE_INLINE const CORBA::ExceptionDef* * - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::get_buffer (void) const + _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::get_buffer (void) const { return ACE_reinterpret_cast(const CORBA::ExceptionDef ** ACE_CAST_CONST, this->buffer_); } @@ -4703,7 +4703,7 @@ CORBA_ExceptionDefSeq_out::operator[] (CORBA::ULong index) // = Static operations. ACE_INLINE CORBA::ExceptionDescription * - CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::allocbuf (CORBA::ULong size) + _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::allocbuf (CORBA::ULong size) // Allocate storage for the sequence. { CORBA::ExceptionDescription *retval = 0; @@ -4711,25 +4711,25 @@ CORBA_ExceptionDefSeq_out::operator[] (CORBA::ULong index) return retval; } - ACE_INLINE void CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::freebuf (CORBA::ExceptionDescription *buffer) + ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::freebuf (CORBA::ExceptionDescription *buffer) // Free the sequence. { delete [] buffer; } ACE_INLINE - CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (void) // Default constructor. + _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (void) // Default constructor. { } ACE_INLINE - CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value. + _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value. : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::allocbuf (maximum)) { } ACE_INLINE - CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (CORBA::ULong maximum, + _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (CORBA::ULong maximum, CORBA::ULong length, CORBA::ExceptionDescription *data, CORBA::Boolean release) @@ -4738,7 +4738,7 @@ CORBA_ExceptionDefSeq_out::operator[] (CORBA::ULong index) } ACE_INLINE - CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq &rhs) + _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq &rhs) // Copy constructor. : TAO_Unbounded_Base_Sequence (rhs) { @@ -4758,8 +4758,8 @@ CORBA_ExceptionDefSeq_out::operator[] (CORBA::ULong index) } } - ACE_INLINE CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq & - CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq &rhs) + ACE_INLINE _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq & + _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq &rhs) // Assignment operator. { if (this == &rhs) @@ -4791,7 +4791,7 @@ CORBA_ExceptionDefSeq_out::operator[] (CORBA::ULong index) // = Accessors. ACE_INLINE CORBA::ExceptionDescription & - CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::operator[] (CORBA::ULong i) + _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::operator[] (CORBA::ULong i) // operator [] { ACE_ASSERT (i < this->maximum_); @@ -4800,7 +4800,7 @@ CORBA_ExceptionDefSeq_out::operator[] (CORBA::ULong index) } ACE_INLINE const CORBA::ExceptionDescription & - CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::operator[] (CORBA::ULong i) const + _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::operator[] (CORBA::ULong i) const // operator [] { ACE_ASSERT (i < this->maximum_); @@ -4811,7 +4811,7 @@ CORBA_ExceptionDefSeq_out::operator[] (CORBA::ULong index) // Implement the TAO_Base_Sequence methods (see Sequence.h) ACE_INLINE CORBA::ExceptionDescription * - CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::get_buffer (CORBA::Boolean orphan) + _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::get_buffer (CORBA::Boolean orphan) { CORBA::ExceptionDescription *result = 0; if (orphan == 0) @@ -4845,13 +4845,13 @@ CORBA_ExceptionDefSeq_out::operator[] (CORBA::ULong index) } ACE_INLINE const CORBA::ExceptionDescription * - CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::get_buffer (void) const + _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::get_buffer (void) const { return ACE_reinterpret_cast(const CORBA::ExceptionDescription * ACE_CAST_CONST, this->buffer_); } ACE_INLINE void - CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::replace (CORBA::ULong max, + _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::replace (CORBA::ULong max, CORBA::ULong length, CORBA::ExceptionDescription *data, CORBA::Boolean release) @@ -5670,7 +5670,7 @@ CORBA_ParameterDescription_out::operator-> (void) // = Static operations. ACE_INLINE CORBA::ParameterDescription * - CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::allocbuf (CORBA::ULong size) + _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::allocbuf (CORBA::ULong size) // Allocate storage for the sequence. { CORBA::ParameterDescription *retval = 0; @@ -5678,25 +5678,25 @@ CORBA_ParameterDescription_out::operator-> (void) return retval; } - ACE_INLINE void CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::freebuf (CORBA::ParameterDescription *buffer) + ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::freebuf (CORBA::ParameterDescription *buffer) // Free the sequence. { delete [] buffer; } ACE_INLINE - CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (void) // Default constructor. + _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (void) // Default constructor. { } ACE_INLINE - CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value. + _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value. : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::allocbuf (maximum)) { } ACE_INLINE - CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (CORBA::ULong maximum, + _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (CORBA::ULong maximum, CORBA::ULong length, CORBA::ParameterDescription *data, CORBA::Boolean release) @@ -5705,7 +5705,7 @@ CORBA_ParameterDescription_out::operator-> (void) } ACE_INLINE - CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq &rhs) + _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq &rhs) // Copy constructor. : TAO_Unbounded_Base_Sequence (rhs) { @@ -5725,8 +5725,8 @@ CORBA_ParameterDescription_out::operator-> (void) } } - ACE_INLINE CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq & - CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq &rhs) + ACE_INLINE _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq & + _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq &rhs) // Assignment operator. { if (this == &rhs) @@ -5758,7 +5758,7 @@ CORBA_ParameterDescription_out::operator-> (void) // = Accessors. ACE_INLINE CORBA::ParameterDescription & - CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::operator[] (CORBA::ULong i) + _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::operator[] (CORBA::ULong i) // operator [] { ACE_ASSERT (i < this->maximum_); @@ -5767,7 +5767,7 @@ CORBA_ParameterDescription_out::operator-> (void) } ACE_INLINE const CORBA::ParameterDescription & - CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::operator[] (CORBA::ULong i) const + _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::operator[] (CORBA::ULong i) const // operator [] { ACE_ASSERT (i < this->maximum_); @@ -5778,7 +5778,7 @@ CORBA_ParameterDescription_out::operator-> (void) // Implement the TAO_Base_Sequence methods (see Sequence.h) ACE_INLINE CORBA::ParameterDescription * - CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::get_buffer (CORBA::Boolean orphan) + _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::get_buffer (CORBA::Boolean orphan) { CORBA::ParameterDescription *result = 0; if (orphan == 0) @@ -5812,13 +5812,13 @@ CORBA_ParameterDescription_out::operator-> (void) } ACE_INLINE const CORBA::ParameterDescription * - CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::get_buffer (void) const + _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::get_buffer (void) const { return ACE_reinterpret_cast(const CORBA::ParameterDescription * ACE_CAST_CONST, this->buffer_); } ACE_INLINE void - CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::replace (CORBA::ULong max, + _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::replace (CORBA::ULong max, CORBA::ULong length, CORBA::ParameterDescription *data, CORBA::Boolean release) @@ -6868,7 +6868,7 @@ CORBA_RepositoryIdSeq_out::operator[] (CORBA::ULong index) // = Static operations. ACE_INLINE CORBA::OperationDescription * - CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::allocbuf (CORBA::ULong size) + _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::allocbuf (CORBA::ULong size) // Allocate storage for the sequence. { CORBA::OperationDescription *retval = 0; @@ -6876,25 +6876,25 @@ CORBA_RepositoryIdSeq_out::operator[] (CORBA::ULong index) return retval; } - ACE_INLINE void CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::freebuf (CORBA::OperationDescription *buffer) + ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::freebuf (CORBA::OperationDescription *buffer) // Free the sequence. { delete [] buffer; } ACE_INLINE - CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (void) // Default constructor. + _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (void) // Default constructor. { } ACE_INLINE - CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value. + _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value. : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::allocbuf (maximum)) { } ACE_INLINE - CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (CORBA::ULong maximum, + _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (CORBA::ULong maximum, CORBA::ULong length, CORBA::OperationDescription *data, CORBA::Boolean release) @@ -6903,7 +6903,7 @@ CORBA_RepositoryIdSeq_out::operator[] (CORBA::ULong index) } ACE_INLINE - CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq &rhs) + _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq &rhs) // Copy constructor. : TAO_Unbounded_Base_Sequence (rhs) { @@ -6923,8 +6923,8 @@ CORBA_RepositoryIdSeq_out::operator[] (CORBA::ULong index) } } - ACE_INLINE CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq & - CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq &rhs) + ACE_INLINE _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq & + _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq &rhs) // Assignment operator. { if (this == &rhs) @@ -6956,7 +6956,7 @@ CORBA_RepositoryIdSeq_out::operator[] (CORBA::ULong index) // = Accessors. ACE_INLINE CORBA::OperationDescription & - CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::operator[] (CORBA::ULong i) + _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::operator[] (CORBA::ULong i) // operator [] { ACE_ASSERT (i < this->maximum_); @@ -6965,7 +6965,7 @@ CORBA_RepositoryIdSeq_out::operator[] (CORBA::ULong index) } ACE_INLINE const CORBA::OperationDescription & - CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::operator[] (CORBA::ULong i) const + _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::operator[] (CORBA::ULong i) const // operator [] { ACE_ASSERT (i < this->maximum_); @@ -6976,7 +6976,7 @@ CORBA_RepositoryIdSeq_out::operator[] (CORBA::ULong index) // Implement the TAO_Base_Sequence methods (see Sequence.h) ACE_INLINE CORBA::OperationDescription * - CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::get_buffer (CORBA::Boolean orphan) + _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::get_buffer (CORBA::Boolean orphan) { CORBA::OperationDescription *result = 0; if (orphan == 0) @@ -7010,13 +7010,13 @@ CORBA_RepositoryIdSeq_out::operator[] (CORBA::ULong index) } ACE_INLINE const CORBA::OperationDescription * - CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::get_buffer (void) const + _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::get_buffer (void) const { return ACE_reinterpret_cast(const CORBA::OperationDescription * ACE_CAST_CONST, this->buffer_); } ACE_INLINE void - CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::replace (CORBA::ULong max, + _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::replace (CORBA::ULong max, CORBA::ULong length, CORBA::OperationDescription *data, CORBA::Boolean release) @@ -7262,7 +7262,7 @@ CORBA_OpDescriptionSeq_out::operator[] (CORBA::ULong index) // = Static operations. ACE_INLINE CORBA::AttributeDescription * - CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::allocbuf (CORBA::ULong size) + _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::allocbuf (CORBA::ULong size) // Allocate storage for the sequence. { CORBA::AttributeDescription *retval = 0; @@ -7270,25 +7270,25 @@ CORBA_OpDescriptionSeq_out::operator[] (CORBA::ULong index) return retval; } - ACE_INLINE void CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::freebuf (CORBA::AttributeDescription *buffer) + ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::freebuf (CORBA::AttributeDescription *buffer) // Free the sequence. { delete [] buffer; } ACE_INLINE - CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (void) // Default constructor. + _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (void) // Default constructor. { } ACE_INLINE - CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value. + _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value. : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::allocbuf (maximum)) { } ACE_INLINE - CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (CORBA::ULong maximum, + _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (CORBA::ULong maximum, CORBA::ULong length, CORBA::AttributeDescription *data, CORBA::Boolean release) @@ -7297,7 +7297,7 @@ CORBA_OpDescriptionSeq_out::operator[] (CORBA::ULong index) } ACE_INLINE - CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq &rhs) + _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq &rhs) // Copy constructor. : TAO_Unbounded_Base_Sequence (rhs) { @@ -7317,8 +7317,8 @@ CORBA_OpDescriptionSeq_out::operator[] (CORBA::ULong index) } } - ACE_INLINE CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq & - CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq &rhs) + ACE_INLINE _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq & + _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq &rhs) // Assignment operator. { if (this == &rhs) @@ -7350,7 +7350,7 @@ CORBA_OpDescriptionSeq_out::operator[] (CORBA::ULong index) // = Accessors. ACE_INLINE CORBA::AttributeDescription & - CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::operator[] (CORBA::ULong i) + _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::operator[] (CORBA::ULong i) // operator [] { ACE_ASSERT (i < this->maximum_); @@ -7359,7 +7359,7 @@ CORBA_OpDescriptionSeq_out::operator[] (CORBA::ULong index) } ACE_INLINE const CORBA::AttributeDescription & - CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::operator[] (CORBA::ULong i) const + _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::operator[] (CORBA::ULong i) const // operator [] { ACE_ASSERT (i < this->maximum_); @@ -7370,7 +7370,7 @@ CORBA_OpDescriptionSeq_out::operator[] (CORBA::ULong index) // Implement the TAO_Base_Sequence methods (see Sequence.h) ACE_INLINE CORBA::AttributeDescription * - CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::get_buffer (CORBA::Boolean orphan) + _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::get_buffer (CORBA::Boolean orphan) { CORBA::AttributeDescription *result = 0; if (orphan == 0) @@ -7404,13 +7404,13 @@ CORBA_OpDescriptionSeq_out::operator[] (CORBA::ULong index) } ACE_INLINE const CORBA::AttributeDescription * - CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::get_buffer (void) const + _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::get_buffer (void) const { return ACE_reinterpret_cast(const CORBA::AttributeDescription * ACE_CAST_CONST, this->buffer_); } ACE_INLINE void - CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::replace (CORBA::ULong max, + _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::replace (CORBA::ULong max, CORBA::ULong length, CORBA::AttributeDescription *data, CORBA::Boolean release) diff --git a/TAO/tao/IFR_Client/IFR_ExtendedC.cpp b/TAO/tao/IFR_Client/IFR_ExtendedC.cpp index 45a9975bc61..f6cb1bfc861 100644 --- a/TAO/tao/IFR_Client/IFR_ExtendedC.cpp +++ b/TAO/tao/IFR_Client/IFR_ExtendedC.cpp @@ -43,7 +43,7 @@ // The Base_Sequence functions, please see tao/Sequence.h void - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_allocate_buffer (CORBA::ULong length) + _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_allocate_buffer (CORBA::ULong length) { CORBA::ValueDef **tmp = 0; tmp = _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::allocbuf (length); @@ -65,7 +65,7 @@ } void - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_deallocate_buffer (void) + _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_deallocate_buffer (void) { if (this->buffer_ == 0 || this->release_ == 0) return; @@ -79,13 +79,13 @@ this->buffer_ = 0; } - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::~_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (void) + _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::~_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (void) { this->_deallocate_buffer (); } void - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol) + _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol) { CORBA::ValueDef **tmp = ACE_reinterpret_cast (CORBA::ValueDef**, this->buffer_); @@ -96,7 +96,7 @@ } } void - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_downcast ( + _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_downcast ( void* target, CORBA_Object *src, CORBA_Environment &ACE_TRY_ENV @@ -108,7 +108,7 @@ } CORBA_Object* - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_upcast (void *src) const + _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_upcast (void *src) const { CORBA::ValueDef **tmp = ACE_static_cast (CORBA::ValueDef**, src); return *tmp; @@ -1527,13 +1527,13 @@ _TAO_FixedDef_Remote_Proxy_Broker::select_proxy ( // default constructor -CORBA::FixedDef::FixedDef (int collocated) +CORBA_FixedDef::CORBA_FixedDef (int collocated) { this->CORBA_FixedDef_setup_collocation (collocated); } // destructor -CORBA::FixedDef::~FixedDef (void) +CORBA_FixedDef::~CORBA_FixedDef (void) {} void @@ -1997,7 +1997,7 @@ void CORBA::ValueMember::_tao_any_destructor (void *x) #define __TAO_UNBOUNDED_SEQUENCE_CORBA_VALUEMEMBERSEQ_CS_ void - CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_allocate_buffer (CORBA::ULong length) + _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_allocate_buffer (CORBA::ULong length) { CORBA::ValueMember* tmp = 0; tmp = _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::allocbuf (length); @@ -2017,7 +2017,7 @@ void CORBA::ValueMember::_tao_any_destructor (void *x) } void - CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_deallocate_buffer (void) + _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_deallocate_buffer (void) { if (this->buffer_ == 0 || this->release_ == 0) return; @@ -2028,7 +2028,7 @@ void CORBA::ValueMember::_tao_any_destructor (void *x) this->buffer_ = 0; } - CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::~_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (void) // Dtor. + _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::~_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (void) // Dtor. { this->_deallocate_buffer (); } @@ -2934,13 +2934,13 @@ _TAO_ValueMemberDef_Remote_Proxy_Broker::select_proxy ( // default constructor -CORBA::ValueMemberDef::ValueMemberDef (int collocated) +CORBA_ValueMemberDef::CORBA_ValueMemberDef (int collocated) { this->CORBA_ValueMemberDef_setup_collocation (collocated); } // destructor -CORBA::ValueMemberDef::~ValueMemberDef (void) +CORBA_ValueMemberDef::~CORBA_ValueMemberDef (void) {} void @@ -6603,13 +6603,13 @@ _TAO_ValueDef_Remote_Proxy_Broker::select_proxy ( // default constructor -CORBA::ValueDef::ValueDef (int collocated) +CORBA_ValueDef::CORBA_ValueDef (int collocated) { this->CORBA_ValueDef_setup_collocation (collocated); } // destructor -CORBA::ValueDef::~ValueDef (void) +CORBA_ValueDef::~CORBA_ValueDef (void) {} void @@ -10145,13 +10145,13 @@ _TAO_ValueBoxDef_Remote_Proxy_Broker::select_proxy ( // default constructor -CORBA::ValueBoxDef::ValueBoxDef (int collocated) +CORBA_ValueBoxDef::CORBA_ValueBoxDef (int collocated) { this->CORBA_ValueBoxDef_setup_collocation (collocated); } // destructor -CORBA::ValueBoxDef::~ValueBoxDef (void) +CORBA_ValueBoxDef::~CORBA_ValueBoxDef (void) {} void diff --git a/TAO/tao/IFR_Client/IFR_ExtendedC.h b/TAO/tao/IFR_Client/IFR_ExtendedC.h index d529f9319cb..ce32c47633a 100644 --- a/TAO/tao/IFR_Client/IFR_ExtendedC.h +++ b/TAO/tao/IFR_Client/IFR_ExtendedC.h @@ -23,13 +23,12 @@ #define TAO_IDL_IFR_EXTENDEDC_H #include "ace/pre.h" +#include "IFR_BasicC.h" #if !defined (ACE_LACKS_PRAGMA_ONCE) # pragma once #endif /* ACE_LACKS_PRAGMA_ONCE */ -#include "IFR_BasicC.h" - #if defined (TAO_EXPORT_MACRO) #undef TAO_EXPORT_MACRO #endif @@ -3766,8 +3765,6 @@ TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORB TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::ValueBoxDef_ptr); TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ValueBoxDef *&); -#ifndef __ACE_INLINE__ - // ************************************************************** // CDR operators for class moved from IFR_BaseC.h @@ -3787,6 +3784,8 @@ TAO_IFR_Client_Export CORBA::Boolean operator>> ( // ************************************************************** +#ifndef __ACE_INLINE__ + TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::FixedDef_ptr ); TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::FixedDef_ptr &); TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ValueMember &); diff --git a/TAO/tao/IFR_Client/IFR_ExtendedC.i b/TAO/tao/IFR_Client/IFR_ExtendedC.i index ea9fef81789..0a05122927c 100644 --- a/TAO/tao/IFR_Client/IFR_ExtendedC.i +++ b/TAO/tao/IFR_Client/IFR_ExtendedC.i @@ -28,7 +28,7 @@ #define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_VALUEDEFSEQ_CI_ ACE_INLINE CORBA::ValueDef ** - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::allocbuf (CORBA::ULong nelems) + _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::allocbuf (CORBA::ULong nelems) { CORBA::ValueDef **buf = 0; @@ -41,7 +41,7 @@ } ACE_INLINE void - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::freebuf (CORBA::ValueDef **buffer) + _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::freebuf (CORBA::ValueDef **buffer) { if (buffer == 0) return; @@ -49,18 +49,18 @@ } ACE_INLINE - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (void) + _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (void) { } ACE_INLINE - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (CORBA::ULong maximum) + _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (CORBA::ULong maximum) : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::allocbuf (maximum)) { } ACE_INLINE - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (CORBA::ULong maximum, + _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (CORBA::ULong maximum, CORBA::ULong length, CORBA::ValueDef* *value, CORBA::Boolean release) @@ -69,7 +69,7 @@ } ACE_INLINE - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq &rhs) + _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq &rhs) : TAO_Unbounded_Base_Sequence (rhs) { if (rhs.buffer_ != 0) @@ -88,8 +88,8 @@ } } - ACE_INLINE CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq & - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq &rhs) + ACE_INLINE _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq & + _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq &rhs) { if (this == &rhs) return *this; @@ -124,7 +124,7 @@ } ACE_INLINE TAO_Object_Manager<CORBA::ValueDef,CORBA::ValueDef_var> - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::operator[] (CORBA::ULong index) const + _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::operator[] (CORBA::ULong index) const // read-write accessor { ACE_ASSERT (index < this->maximum_); @@ -133,7 +133,7 @@ } ACE_INLINE CORBA::ValueDef* * - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::get_buffer (CORBA::Boolean orphan) + _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::get_buffer (CORBA::Boolean orphan) { CORBA::ValueDef **result = 0; if (orphan == 0) @@ -167,7 +167,7 @@ } ACE_INLINE const CORBA::ValueDef* * - CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::get_buffer (void) const + _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::get_buffer (void) const { return ACE_reinterpret_cast(const CORBA::ValueDef ** ACE_CAST_CONST, this->buffer_); } @@ -778,7 +778,7 @@ CORBA_ValueMember_out::operator-> (void) // = Static operations. ACE_INLINE CORBA::ValueMember * - CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::allocbuf (CORBA::ULong size) + _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::allocbuf (CORBA::ULong size) // Allocate storage for the sequence. { CORBA::ValueMember *retval = 0; @@ -786,25 +786,25 @@ CORBA_ValueMember_out::operator-> (void) return retval; } - ACE_INLINE void CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::freebuf (CORBA::ValueMember *buffer) + ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::freebuf (CORBA::ValueMember *buffer) // Free the sequence. { delete [] buffer; } ACE_INLINE - CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (void) // Default constructor. + _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (void) // Default constructor. { } ACE_INLINE - CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (CORBA::ULong maximum) // Constructor using a maximum length value. + _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (CORBA::ULong maximum) // Constructor using a maximum length value. : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::allocbuf (maximum)) { } ACE_INLINE - CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (CORBA::ULong maximum, + _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (CORBA::ULong maximum, CORBA::ULong length, CORBA::ValueMember *data, CORBA::Boolean release) @@ -813,7 +813,7 @@ CORBA_ValueMember_out::operator-> (void) } ACE_INLINE - CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (const _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq &rhs) + _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (const _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq &rhs) // Copy constructor. : TAO_Unbounded_Base_Sequence (rhs) { @@ -833,8 +833,8 @@ CORBA_ValueMember_out::operator-> (void) } } - ACE_INLINE CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq & - CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq &rhs) + ACE_INLINE _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq & + _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq &rhs) // Assignment operator. { if (this == &rhs) @@ -866,7 +866,7 @@ CORBA_ValueMember_out::operator-> (void) // = Accessors. ACE_INLINE CORBA::ValueMember & - CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::operator[] (CORBA::ULong i) + _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::operator[] (CORBA::ULong i) // operator [] { ACE_ASSERT (i < this->maximum_); @@ -875,7 +875,7 @@ CORBA_ValueMember_out::operator-> (void) } ACE_INLINE const CORBA::ValueMember & - CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::operator[] (CORBA::ULong i) const + _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::operator[] (CORBA::ULong i) const // operator [] { ACE_ASSERT (i < this->maximum_); @@ -886,7 +886,7 @@ CORBA_ValueMember_out::operator-> (void) // Implement the TAO_Base_Sequence methods (see Sequence.h) ACE_INLINE CORBA::ValueMember * - CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::get_buffer (CORBA::Boolean orphan) + _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::get_buffer (CORBA::Boolean orphan) { CORBA::ValueMember *result = 0; if (orphan == 0) @@ -920,13 +920,13 @@ CORBA_ValueMember_out::operator-> (void) } ACE_INLINE const CORBA::ValueMember * - CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::get_buffer (void) const + _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::get_buffer (void) const { return ACE_reinterpret_cast(const CORBA::ValueMember * ACE_CAST_CONST, this->buffer_); } ACE_INLINE void - CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::replace (CORBA::ULong max, + _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::replace (CORBA::ULong max, CORBA::ULong length, CORBA::ValueMember *data, CORBA::Boolean release) |