diff options
Diffstat (limited to 'TAO/tao/Valuetype/Sequence_T.cpp')
| -rw-r--r-- | TAO/tao/Valuetype/Sequence_T.cpp | 362 |
1 files changed, 181 insertions, 181 deletions
diff --git a/TAO/tao/Valuetype/Sequence_T.cpp b/TAO/tao/Valuetype/Sequence_T.cpp index 1aba6361a74..4d88da21b92 100644 --- a/TAO/tao/Valuetype/Sequence_T.cpp +++ b/TAO/tao/Valuetype/Sequence_T.cpp @@ -17,10 +17,10 @@ ACE_RCSID (Valuetype, // class TAO_Valuetype_Manager // ************************************************************* -template <typename T, typename T_var, typename T_life> -TAO_Valuetype_Manager<T,T_var,T_life> & -TAO_Valuetype_Manager<T,T_var,T_life>::operator= ( - const TAO_Valuetype_Manager<T,T_var,T_life> & rhs +template <typename T, typename T_var> +TAO_Valuetype_Manager<T,T_var> & +TAO_Valuetype_Manager<T,T_var>::operator= ( + const TAO_Valuetype_Manager<T,T_var> & rhs ) { if (this == &rhs) @@ -30,9 +30,9 @@ TAO_Valuetype_Manager<T,T_var,T_life>::operator= ( if (this->release_) { - T_life::tao_remove_ref (*this->ptr_); + TAO::Value_Traits<T>::tao_remove_ref (*this->ptr_); *this->ptr_ = *rhs.ptr_; - T_life::tao_add_ref (*this->ptr_); + TAO::Value_Traits<T>::tao_add_ref (*this->ptr_); } else { @@ -42,9 +42,9 @@ TAO_Valuetype_Manager<T,T_var,T_life>::operator= ( return *this; } -template <typename T, typename T_var, typename T_life> -TAO_Valuetype_Manager<T,T_var,T_life> & -TAO_Valuetype_Manager<T,T_var,T_life>::operator= (T * p) +template <typename T, typename T_var> +TAO_Valuetype_Manager<T,T_var> & +TAO_Valuetype_Manager<T,T_var>::operator= (T * p) { if (this->release_) { @@ -52,7 +52,7 @@ TAO_Valuetype_Manager<T,T_var,T_life>::operator= (T * p) // that of a var variable. Therefore we will not duplicate the // user provided pointer before assigning it to the internal // variable. - T_life::tao_remove_ref (*this->ptr_); + TAO::Value_Traits<T>::tao_remove_ref (*this->ptr_); *this->ptr_ = p; } else @@ -63,9 +63,9 @@ TAO_Valuetype_Manager<T,T_var,T_life>::operator= (T * p) return *this; } -template <typename T, typename T_var, typename T_life> -TAO_Valuetype_Manager<T,T_var,T_life> & -TAO_Valuetype_Manager<T,T_var,T_life>::operator= (const T_var & p) +template <typename T, typename T_var> +TAO_Valuetype_Manager<T,T_var> & +TAO_Valuetype_Manager<T,T_var>::operator= (const T_var & p) { if (this->release_) { @@ -78,9 +78,9 @@ TAO_Valuetype_Manager<T,T_var,T_life>::operator= (const T_var & p) (*this->ptr_)->_remove_ref (); } - T_life::tao_remove_ref (*this->ptr_); + TAO::Value_Traits<T>::tao_remove_ref (*this->ptr_); *this->ptr_ = p.in (); - T_life::tao_add_ref (*this->ptr_); + TAO::Value_Traits<T>::tao_add_ref (*this->ptr_); } else { @@ -94,10 +94,10 @@ TAO_Valuetype_Manager<T,T_var,T_life>::operator= (const T_var & p) // class TAO_Abstract_Manager // ************************************************************* -template<typename T, typename T_var, typename T_life> -TAO_Abstract_Manager<T,T_var,T_life> & -TAO_Abstract_Manager<T,T_var,T_life>::operator= ( - const TAO_Abstract_Manager<T,T_var,T_life> & rhs +template<typename T, typename T_var> +TAO_Abstract_Manager<T,T_var> & +TAO_Abstract_Manager<T,T_var>::operator= ( + const TAO_Abstract_Manager<T,T_var> & rhs ) { if (this == &rhs) @@ -107,17 +107,17 @@ TAO_Abstract_Manager<T,T_var,T_life>::operator= ( if (this->release_) { - T_life::tao_release (*this->ptr_); - T_life::tao_duplicate (*rhs->ptr_); + TAO::Objref_Traits<T>::tao_release (*this->ptr_); + TAO::Objref_Traits<T>::tao_duplicate (*rhs->ptr_); } *this->ptr_ = *rhs.ptr_; return *this; } -template<typename T, typename T_var, typename T_life> -TAO_Abstract_Manager<T,T_var,T_life> & -TAO_Abstract_Manager<T,T_var,T_life>::operator= (T * p) +template<typename T, typename T_var> +TAO_Abstract_Manager<T,T_var> & +TAO_Abstract_Manager<T,T_var>::operator= (T * p) { if (this->release_) { @@ -125,16 +125,16 @@ TAO_Abstract_Manager<T,T_var,T_life>::operator= (T * p) // that of a var variable. Therefore we will not duplicate the // user provided pointer before assigning it to the internal // variable. - T_life::tao_release (*this->ptr_); + TAO::Objref_Traits<T>::tao_release (*this->ptr_); } *this->ptr_ = p; return *this; } -template<typename T, typename T_var, typename T_life> -TAO_Abstract_Manager<T,T_var,T_life> & -TAO_Abstract_Manager<T,T_var,T_life>::operator= (const T_var & p) +template<typename T, typename T_var> +TAO_Abstract_Manager<T,T_var> & +TAO_Abstract_Manager<T,T_var>::operator= (const T_var & p) { if (this->release_) { @@ -142,26 +142,26 @@ TAO_Abstract_Manager<T,T_var,T_life>::operator= (const T_var & p) // that of a var variable. Therefore we duplicate p's // pointer before assigning it to the internal // variable. - T_life::tao_release (*this->ptr_); - T_life::tao_duplicate (p.in ()); + TAO::Objref_Traits<T>::tao_release (*this->ptr_); + TAO::Objref_Traits<T>::tao_duplicate (p.in ()); } *this->ptr_ = p.in (); return *this; } -template<typename T, typename T_var, typename T_life> -TAO_Abstract_Manager<T,T_var,T_life>::operator const T_var () const +template<typename T, typename T_var> +TAO_Abstract_Manager<T,T_var>::operator const T_var () const { - T_life::tao_duplicate (*this->ptr_); + TAO::Objref_Traits<T>::tao_duplicate (*this->ptr_); return *this->ptr_; } -template<typename T, typename T_var, typename T_life> +template<typename T, typename T_var> T *& -TAO_Abstract_Manager<T,T_var,T_life>::out (void) +TAO_Abstract_Manager<T,T_var>::out (void) { - T_life::tao_release (*this->ptr_); + TAO::Objref_Traits<T>::tao_release (*this->ptr_); *this->ptr_ = 0; return *this->ptr_; } @@ -170,29 +170,27 @@ TAO_Abstract_Manager<T,T_var,T_life>::out (void) // Operations for class TAO_Unbounded_Valuetype_Sequence // ************************************************************* -template <typename T, typename T_var, typename T_life> -TAO_Unbounded_Valuetype_Sequence<T,T_var,T_life>:: -TAO_Unbounded_Valuetype_Sequence ( +template <typename T, typename T_var> +TAO_Unbounded_Valuetype_Sequence<T,T_var>::TAO_Unbounded_Valuetype_Sequence ( CORBA::ULong maximum ) : TAO_Unbounded_Base_Sequence ( maximum, - TAO_Unbounded_Valuetype_Sequence<T,T_var,T_life>::allocbuf (maximum) + TAO_Unbounded_Valuetype_Sequence<T,T_var>::allocbuf (maximum) ) { } -template <typename T, typename T_var, typename T_life> -TAO_Unbounded_Valuetype_Sequence<T,T_var,T_life>:: -TAO_Unbounded_Valuetype_Sequence ( - const TAO_Unbounded_Valuetype_Sequence<T,T_var,T_life> & rhs +template <typename T, typename T_var> +TAO_Unbounded_Valuetype_Sequence<T,T_var>::TAO_Unbounded_Valuetype_Sequence ( + const TAO_Unbounded_Valuetype_Sequence<T,T_var> & rhs ) : TAO_Unbounded_Base_Sequence (rhs) { if (rhs.buffer_ != 0) { T ** tmp1 = - TAO_Unbounded_Valuetype_Sequence<T,T_var,T_life>::allocbuf ( + TAO_Unbounded_Valuetype_Sequence<T,T_var>::allocbuf ( this->maximum_ ); T ** const tmp2 = @@ -201,7 +199,7 @@ TAO_Unbounded_Valuetype_Sequence ( for (CORBA::ULong i = 0; i < rhs.length_; ++i) { - T_life::tao_add_ref (tmp2[i]); + TAO::Value_Traits<T>::tao_add_ref (tmp2[i]); tmp1[i] = tmp2[i]; } @@ -213,17 +211,18 @@ TAO_Unbounded_Valuetype_Sequence ( } } -template <typename T, typename T_var, typename T_life> -TAO_Unbounded_Valuetype_Sequence<T,T_var,T_life>:: -~TAO_Unbounded_Valuetype_Sequence (void) +template <typename T, typename T_var> +TAO_Unbounded_Valuetype_Sequence<T,T_var>::~TAO_Unbounded_Valuetype_Sequence ( + void + ) { this->_deallocate_buffer (); } -template <typename T, typename T_var, typename T_life> -TAO_Unbounded_Valuetype_Sequence<T,T_var,T_life> & -TAO_Unbounded_Valuetype_Sequence<T,T_var,T_life>::operator= ( - const TAO_Unbounded_Valuetype_Sequence<T,T_var,T_life> & rhs +template <typename T, typename T_var> +TAO_Unbounded_Valuetype_Sequence<T,T_var> & +TAO_Unbounded_Valuetype_Sequence<T,T_var>::operator= ( + const TAO_Unbounded_Valuetype_Sequence<T,T_var> & rhs ) { if (this == &rhs) @@ -238,15 +237,15 @@ TAO_Unbounded_Valuetype_Sequence<T,T_var,T_life>::operator= ( for (CORBA::ULong i = 0; i < this->length_; ++i) { - T_life::tao_remove_ref (tmp[i]); + TAO::Value_Traits<T>::tao_remove_ref (tmp[i]); tmp[i] = 0; } if (this->maximum_ < rhs.maximum_) { - TAO_Unbounded_Valuetype_Sequence<T,T_var,T_life>::freebuf (tmp); + TAO_Unbounded_Valuetype_Sequence<T,T_var>::freebuf (tmp); this->buffer_ = - TAO_Unbounded_Valuetype_Sequence<T,T_var,T_life>::allocbuf (rhs.maximum_); + TAO_Unbounded_Valuetype_Sequence<T,T_var>::allocbuf (rhs.maximum_); } } else @@ -258,7 +257,7 @@ TAO_Unbounded_Valuetype_Sequence<T,T_var,T_life>::operator= ( else { this->buffer_ = - TAO_Unbounded_Valuetype_Sequence<T,T_var,T_life>::allocbuf ( + TAO_Unbounded_Valuetype_Sequence<T,T_var>::allocbuf ( rhs.maximum_ ); } @@ -273,16 +272,16 @@ TAO_Unbounded_Valuetype_Sequence<T,T_var,T_life>::operator= ( for (CORBA::ULong i = 0; i < rhs.length_; ++i) { - T_life::tao_add_ref (tmp2[i]); + TAO::Value_Traits<T>::tao_add_ref (tmp2[i]); tmp1[i] = tmp2[i]; } return *this; } -template <typename T, typename T_var, typename T_life> +template <typename T, typename T_var> T ** -TAO_Unbounded_Valuetype_Sequence<T,T_var,T_life>::allocbuf (CORBA::ULong nelems) +TAO_Unbounded_Valuetype_Sequence<T,T_var>::allocbuf (CORBA::ULong nelems) { T ** buf = 0; ACE_NEW_RETURN (buf, @@ -297,9 +296,9 @@ TAO_Unbounded_Valuetype_Sequence<T,T_var,T_life>::allocbuf (CORBA::ULong nelems) return buf; } -template <typename T, typename T_var, typename T_life> +template <typename T, typename T_var> void -TAO_Unbounded_Valuetype_Sequence<T,T_var,T_life>::freebuf (T ** buffer) +TAO_Unbounded_Valuetype_Sequence<T,T_var>::freebuf (T ** buffer) { if (buffer == 0) { @@ -321,14 +320,14 @@ TAO_Unbounded_Valuetype_Sequence<T,T_var,T_life>::freebuf (T ** buffer) delete [] buffer; } -template <typename T, typename T_var, typename T_life> +template <typename T, typename T_var> void -TAO_Unbounded_Valuetype_Sequence<T,T_var,T_life>::_allocate_buffer ( +TAO_Unbounded_Valuetype_Sequence<T,T_var>::_allocate_buffer ( CORBA::ULong length ) { T ** tmp = - TAO_Unbounded_Valuetype_Sequence<T,T_var,T_life>::allocbuf (length); + TAO_Unbounded_Valuetype_Sequence<T,T_var>::allocbuf (length); if (this->buffer_ != 0) { @@ -343,7 +342,7 @@ TAO_Unbounded_Valuetype_Sequence<T,T_var,T_life>::_allocate_buffer ( // the old instances. if (!this->release_) { - T_life::tao_add_ref (tmp[i]); + TAO::Value_Traits<T>::tao_add_ref (tmp[i]); tmp[i] = old[i]; } else @@ -360,9 +359,9 @@ TAO_Unbounded_Valuetype_Sequence<T,T_var,T_life>::_allocate_buffer ( this->buffer_ = tmp; } -template <typename T, typename T_var, typename T_life> +template <typename T, typename T_var> void -TAO_Unbounded_Valuetype_Sequence<T,T_var,T_life>::_deallocate_buffer (void) +TAO_Unbounded_Valuetype_Sequence<T,T_var>::_deallocate_buffer (void) { if (this->buffer_ == 0 || this->release_ == 0) { @@ -374,17 +373,17 @@ TAO_Unbounded_Valuetype_Sequence<T,T_var,T_life>::_deallocate_buffer (void) for (CORBA::ULong i = 0; i < this->length_; ++i) { - T_life::tao_remove_ref (tmp[i]); + TAO::Value_Traits<T>::tao_remove_ref (tmp[i]); tmp[i] = 0; } - TAO_Unbounded_Valuetype_Sequence<T,T_var,T_life>::freebuf (tmp); + TAO_Unbounded_Valuetype_Sequence<T,T_var>::freebuf (tmp); this->buffer_ = 0; } -template <typename T, typename T_var, typename T_life> +template <typename T, typename T_var> void -TAO_Unbounded_Valuetype_Sequence<T,T_var,T_life>::_shrink_buffer ( +TAO_Unbounded_Valuetype_Sequence<T,T_var>::_shrink_buffer ( CORBA::ULong nl, CORBA::ULong ol ) @@ -394,7 +393,7 @@ TAO_Unbounded_Valuetype_Sequence<T,T_var,T_life>::_shrink_buffer ( for (CORBA::ULong i = nl; i < ol; ++i) { - T_life::tao_remove_ref (tmp[i]); + TAO::Value_Traits<T>::tao_remove_ref (tmp[i]); tmp[i] = 0; } } @@ -403,34 +402,34 @@ TAO_Unbounded_Valuetype_Sequence<T,T_var,T_life>::_shrink_buffer ( // Operations for class TAO_Bounded_Valuetype_Sequence // ************************************************************* -template <typename T, typename T_var, typename T_life, size_t MAX> -TAO_Bounded_Valuetype_Sequence<T,T_var,T_life,MAX>:: -TAO_Bounded_Valuetype_Sequence (void) +template <typename T, typename T_var, size_t MAX> +TAO_Bounded_Valuetype_Sequence<T,T_var,MAX>::TAO_Bounded_Valuetype_Sequence ( + void + ) : TAO_Bounded_Base_Sequence ( MAX, - TAO_Bounded_Valuetype_Sequence<T,T_var,T_life,MAX>::allocbuf (MAX) + TAO_Bounded_Valuetype_Sequence<T,T_var,MAX>::allocbuf (MAX) ) { } -template <typename T, typename T_var, typename T_life, size_t MAX> -TAO_Bounded_Valuetype_Sequence<T,T_var,T_life,MAX>:: -TAO_Bounded_Valuetype_Sequence ( - const TAO_Bounded_Valuetype_Sequence<T,T_var,T_life,MAX> & rhs +template <typename T, typename T_var, size_t MAX> +TAO_Bounded_Valuetype_Sequence<T,T_var,MAX>::TAO_Bounded_Valuetype_Sequence ( + const TAO_Bounded_Valuetype_Sequence<T,T_var,MAX> & rhs ) : TAO_Bounded_Base_Sequence (rhs) { if (rhs.buffer_ != 0) { T ** tmp1 = - TAO_Bounded_Valuetype_Sequence<T,T_var,T_life,MAX>::allocbuf (MAX); + TAO_Bounded_Valuetype_Sequence<T,T_var,MAX>::allocbuf (MAX); T ** const tmp2 = ACE_reinterpret_cast (T ** ACE_CAST_CONST, rhs.buffer_); for (CORBA::ULong i = 0; i < rhs.length_; ++i) { - T_life::tao_add_ref (tmp2[i]); + TAO::Value_Traits<T>::tao_add_ref (tmp2[i]); tmp1[i] = tmp2[i]; } @@ -442,10 +441,10 @@ TAO_Bounded_Valuetype_Sequence ( } } -template <typename T, typename T_var, typename T_life, size_t MAX> -TAO_Bounded_Valuetype_Sequence<T,T_var,T_life,MAX>& -TAO_Bounded_Valuetype_Sequence<T,T_var,T_life,MAX>::operator= ( - const TAO_Bounded_Valuetype_Sequence<T,T_var,T_life,MAX> & rhs +template <typename T, typename T_var, size_t MAX> +TAO_Bounded_Valuetype_Sequence<T,T_var,MAX>& +TAO_Bounded_Valuetype_Sequence<T,T_var,MAX>::operator= ( + const TAO_Bounded_Valuetype_Sequence<T,T_var,MAX> & rhs ) { if (this == &rhs) @@ -460,7 +459,7 @@ TAO_Bounded_Valuetype_Sequence<T,T_var,T_life,MAX>::operator= ( for (CORBA::ULong i = 0; i < this->length_; ++i) { - T_life::tao_remove_ref (tmp[i]); + TAO::Value_Traits<T>::tao_remove_ref (tmp[i]); tmp[i] = 0; } // No need to reallocate the buffer since it is always of size @@ -475,7 +474,7 @@ TAO_Bounded_Valuetype_Sequence<T,T_var,T_life,MAX>::operator= ( else { this->buffer_ = - TAO_Bounded_Valuetype_Sequence<T,T_var,T_life,MAX>::allocbuf ( + TAO_Bounded_Valuetype_Sequence<T,T_var,MAX>::allocbuf ( rhs.maximum_ ); } @@ -490,16 +489,16 @@ TAO_Bounded_Valuetype_Sequence<T,T_var,T_life,MAX>::operator= ( for (CORBA::ULong i = 0; i < rhs.length_; ++i) { - T_life::tao_add_ref (tmp2[i]); + TAO::Value_Traits<T>::tao_add_ref (tmp2[i]); tmp1[i] = tmp2[i]; } return *this; } -template <typename T, typename T_var, typename T_life, size_t MAX> +template <typename T, typename T_var, size_t MAX> T ** -TAO_Bounded_Valuetype_Sequence<T,T_var,T_life,MAX>::allocbuf (CORBA::ULong) +TAO_Bounded_Valuetype_Sequence<T,T_var,MAX>::allocbuf (CORBA::ULong) { T ** buf = 0; ACE_NEW_RETURN (buf, @@ -514,9 +513,9 @@ TAO_Bounded_Valuetype_Sequence<T,T_var,T_life,MAX>::allocbuf (CORBA::ULong) return buf; } -template <typename T, typename T_var, typename T_life, size_t MAX> +template <typename T, typename T_var, size_t MAX> void -TAO_Bounded_Valuetype_Sequence<T,T_var,T_life,MAX>::freebuf (T ** buffer) +TAO_Bounded_Valuetype_Sequence<T,T_var,MAX>::freebuf (T ** buffer) { // How much do we deallocate? Easy! allocbuf() always creates MAX // elements and initialize them to T::_nil(). So we can be @@ -525,7 +524,7 @@ TAO_Bounded_Valuetype_Sequence<T,T_var,T_life,MAX>::freebuf (T ** buffer) { if (buffer[i] != 0) { - T_life::tao_remove_ref (buffer[i]); + TAO::Value_Traits<T>::tao_remove_ref (buffer[i]); buffer[i] = 0; } } @@ -533,21 +532,21 @@ TAO_Bounded_Valuetype_Sequence<T,T_var,T_life,MAX>::freebuf (T ** buffer) delete [] buffer; } -template <typename T, typename T_var, typename T_life, size_t MAX> +template <typename T, typename T_var, size_t MAX> void -TAO_Bounded_Valuetype_Sequence<T,T_var,T_life,MAX>::_allocate_buffer ( +TAO_Bounded_Valuetype_Sequence<T,T_var,MAX>::_allocate_buffer ( CORBA::ULong length ) { // For this class memory is never reallocated so the implementation // is *really* simple. this->buffer_ = - TAO_Bounded_Valuetype_Sequence<T,T_var,T_life,MAX>::allocbuf (length); + TAO_Bounded_Valuetype_Sequence<T,T_var,MAX>::allocbuf (length); } -template <typename T, typename T_var, typename T_life, size_t MAX> +template <typename T, typename T_var, size_t MAX> void -TAO_Bounded_Valuetype_Sequence<T,T_var,T_life,MAX>::_deallocate_buffer (void) +TAO_Bounded_Valuetype_Sequence<T,T_var,MAX>::_deallocate_buffer (void) { if (this->release_ == 0) { @@ -556,13 +555,13 @@ TAO_Bounded_Valuetype_Sequence<T,T_var,T_life,MAX>::_deallocate_buffer (void) T ** tmp = ACE_reinterpret_cast (T **, this->buffer_); - TAO_Bounded_Valuetype_Sequence<T,T_var,T_life,MAX>::freebuf (tmp); + TAO_Bounded_Valuetype_Sequence<T,T_var,MAX>::freebuf (tmp); this->buffer_ = 0; } -template <typename T, typename T_var, typename T_life, size_t MAX> +template <typename T, typename T_var, size_t MAX> void -TAO_Bounded_Valuetype_Sequence<T,T_var,T_life,MAX>::_shrink_buffer ( +TAO_Bounded_Valuetype_Sequence<T,T_var,MAX>::_shrink_buffer ( CORBA::ULong nl, CORBA::ULong ol ) @@ -572,7 +571,7 @@ TAO_Bounded_Valuetype_Sequence<T,T_var,T_life,MAX>::_shrink_buffer ( for (CORBA::ULong i = nl; i < ol; ++i) { - T_life::tao_remove_ref (tmp[i]); + TAO::Value_Traits<T>::tao_remove_ref (tmp[i]); tmp[i] = 0; } } @@ -581,27 +580,27 @@ TAO_Bounded_Valuetype_Sequence<T,T_var,T_life,MAX>::_shrink_buffer ( // Operations for class TAO_Unbounded_Abstract_Sequence // ************************************************************* -template <typename T, typename T_var, typename T_life> -TAO_Unbounded_Abstract_Sequence<T,T_var,T_life>:: -TAO_Unbounded_Abstract_Sequence (CORBA::ULong maximum) +template <typename T, typename T_var> +TAO_Unbounded_Abstract_Sequence<T,T_var>::TAO_Unbounded_Abstract_Sequence ( + CORBA::ULong maximum + ) : TAO_Unbounded_Base_Sequence ( maximum, - TAO_Unbounded_Abstract_Sequence<T,T_var,T_life>::allocbuf (maximum) + TAO_Unbounded_Abstract_Sequence<T,T_var>::allocbuf (maximum) ) { } -template <typename T, typename T_var, typename T_life> -TAO_Unbounded_Abstract_Sequence<T,T_var,T_life>:: -TAO_Unbounded_Abstract_Sequence ( - const TAO_Unbounded_Abstract_Sequence<T,T_var,T_life> & rhs +template <typename T, typename T_var> +TAO_Unbounded_Abstract_Sequence<T,T_var>::TAO_Unbounded_Abstract_Sequence ( + const TAO_Unbounded_Abstract_Sequence<T,T_var> & rhs ) : TAO_Unbounded_Base_Sequence (rhs) { if (rhs.buffer_ != 0) { T ** tmp1 = - TAO_Unbounded_Abstract_Sequence<T,T_var,T_life>::allocbuf ( + TAO_Unbounded_Abstract_Sequence<T,T_var>::allocbuf ( this->maximum_ ); T ** const tmp2 = @@ -610,7 +609,7 @@ TAO_Unbounded_Abstract_Sequence ( for (CORBA::ULong i = 0; i < rhs.length_; ++i) { - tmp1[i] = T_life::tao_duplicate (tmp2[i]); + tmp1[i] = TAO::Objref_Traits<T>::tao_duplicate (tmp2[i]); } this->buffer_ = tmp1; @@ -621,17 +620,18 @@ TAO_Unbounded_Abstract_Sequence ( } } -template <typename T, typename T_var, typename T_life> -TAO_Unbounded_Abstract_Sequence<T,T_var,T_life>:: -~TAO_Unbounded_Abstract_Sequence (void) +template <typename T, typename T_var> +TAO_Unbounded_Abstract_Sequence<T,T_var>::~TAO_Unbounded_Abstract_Sequence ( + void + ) { this->_deallocate_buffer (); } -template <typename T, typename T_var, typename T_life> -TAO_Unbounded_Abstract_Sequence<T,T_var,T_life> & -TAO_Unbounded_Abstract_Sequence<T,T_var,T_life>::operator= ( - const TAO_Unbounded_Abstract_Sequence<T,T_var,T_life> & rhs +template <typename T, typename T_var> +TAO_Unbounded_Abstract_Sequence<T,T_var> & +TAO_Unbounded_Abstract_Sequence<T,T_var>::operator= ( + const TAO_Unbounded_Abstract_Sequence<T,T_var> & rhs ) { if (this == &rhs) @@ -646,15 +646,15 @@ TAO_Unbounded_Abstract_Sequence<T,T_var,T_life>::operator= ( for (CORBA::ULong i = 0; i < this->length_; ++i) { - T_life::tao_release (tmp[i]); - tmp[i] = T_life::tao_nil (); + TAO::Objref_Traits<T>::tao_release (tmp[i]); + tmp[i] = TAO::Objref_Traits<T>::tao_nil (); } if (this->maximum_ < rhs.maximum_) { - TAO_Unbounded_Abstract_Sequence<T,T_var,T_life>::freebuf (tmp); + TAO_Unbounded_Abstract_Sequence<T,T_var>::freebuf (tmp); this->buffer_ = - TAO_Unbounded_Abstract_Sequence<T,T_var,T_life>::allocbuf ( + TAO_Unbounded_Abstract_Sequence<T,T_var>::allocbuf ( rhs.maximum_ ); } @@ -668,7 +668,7 @@ TAO_Unbounded_Abstract_Sequence<T,T_var,T_life>::operator= ( else { this->buffer_ = - TAO_Unbounded_Abstract_Sequence<T,T_var,T_life>::allocbuf ( + TAO_Unbounded_Abstract_Sequence<T,T_var>::allocbuf ( rhs.maximum_ ); } @@ -683,15 +683,15 @@ TAO_Unbounded_Abstract_Sequence<T,T_var,T_life>::operator= ( for (CORBA::ULong i = 0; i < rhs.length_; ++i) { - tmp1[i] = T_life::tao_duplicate (tmp2[i]); + tmp1[i] = TAO::Objref_Traits<T>::tao_duplicate (tmp2[i]); } return *this; } -template <typename T, typename T_var, typename T_life> +template <typename T, typename T_var> T ** -TAO_Unbounded_Abstract_Sequence<T,T_var,T_life>::allocbuf ( +TAO_Unbounded_Abstract_Sequence<T,T_var>::allocbuf ( CORBA::ULong nelems ) { @@ -702,15 +702,15 @@ TAO_Unbounded_Abstract_Sequence<T,T_var,T_life>::allocbuf ( for (CORBA::ULong i = 0; i < nelems; ++i) { - buf[i] = T_life::tao_nil (); + buf[i] = TAO::Objref_Traits<T>::tao_nil (); } return buf; } -template <typename T, typename T_var, typename T_life> +template <typename T, typename T_var> void -TAO_Unbounded_Abstract_Sequence<T,T_var,T_life>::freebuf (T ** buffer) +TAO_Unbounded_Abstract_Sequence<T,T_var>::freebuf (T ** buffer) { if (buffer == 0) { @@ -732,13 +732,13 @@ TAO_Unbounded_Abstract_Sequence<T,T_var,T_life>::freebuf (T ** buffer) delete [] buffer; } -template <typename T, typename T_var, typename T_life> +template <typename T, typename T_var> void -TAO_Unbounded_Abstract_Sequence<T,T_var,T_life>::_allocate_buffer ( +TAO_Unbounded_Abstract_Sequence<T,T_var>::_allocate_buffer ( CORBA::ULong length ) { - T ** tmp = TAO_Unbounded_Abstract_Sequence<T,T_var,T_life>::allocbuf (length); + T ** tmp = TAO_Unbounded_Abstract_Sequence<T,T_var>::allocbuf (length); if (this->buffer_ != 0) { @@ -753,7 +753,7 @@ TAO_Unbounded_Abstract_Sequence<T,T_var,T_life>::_allocate_buffer ( // the old instances. if (!this->release_) { - tmp[i] = T_life::tao_duplicate (old[i]); + tmp[i] = TAO::Objref_Traits<T>::tao_duplicate (old[i]); } else { @@ -769,9 +769,9 @@ TAO_Unbounded_Abstract_Sequence<T,T_var,T_life>::_allocate_buffer ( this->buffer_ = tmp; } -template <typename T, typename T_var, typename T_life> +template <typename T, typename T_var> void -TAO_Unbounded_Abstract_Sequence<T,T_var,T_life>::_deallocate_buffer (void) +TAO_Unbounded_Abstract_Sequence<T,T_var>::_deallocate_buffer (void) { if (this->buffer_ == 0 || this->release_ == 0) { @@ -783,17 +783,17 @@ TAO_Unbounded_Abstract_Sequence<T,T_var,T_life>::_deallocate_buffer (void) for (CORBA::ULong i = 0; i < this->length_; ++i) { - T_life::tao_release (tmp[i]); - tmp[i] = T_life::tao_nil (); + TAO::Objref_Traits<T>::tao_release (tmp[i]); + tmp[i] = TAO::Objref_Traits<T>::tao_nil (); } - TAO_Unbounded_Abstract_Sequence<T,T_var,T_life>::freebuf (tmp); + TAO_Unbounded_Abstract_Sequence<T,T_var>::freebuf (tmp); this->buffer_ = 0; } -template <typename T, typename T_var, typename T_life> +template <typename T, typename T_var> void -TAO_Unbounded_Abstract_Sequence<T,T_var,T_life>::_shrink_buffer ( +TAO_Unbounded_Abstract_Sequence<T,T_var>::_shrink_buffer ( CORBA::ULong nl, CORBA::ULong ol ) @@ -803,8 +803,8 @@ TAO_Unbounded_Abstract_Sequence<T,T_var,T_life>::_shrink_buffer ( for (CORBA::ULong i = nl; i < ol; ++i) { - T_life::tao_release (tmp[i]); - tmp[i] = T_life::tao_nil (); + TAO::Objref_Traits<T>::tao_release (tmp[i]); + tmp[i] = TAO::Objref_Traits<T>::tao_nil (); } } @@ -812,34 +812,34 @@ TAO_Unbounded_Abstract_Sequence<T,T_var,T_life>::_shrink_buffer ( // Operations for class TAO_Bounded_Abstract_Sequence // ************************************************************* -template <typename T, typename T_var, typename T_life, size_t MAX> -TAO_Bounded_Abstract_Sequence<T,T_var,T_life,MAX>:: -TAO_Bounded_Abstract_Sequence (void) +template <typename T, typename T_var, size_t MAX> +TAO_Bounded_Abstract_Sequence<T,T_var,MAX>::TAO_Bounded_Abstract_Sequence ( + void + ) : TAO_Bounded_Base_Sequence ( MAX, - TAO_Bounded_Abstract_Sequence<T,T_var,T_life,MAX>::allocbuf (MAX) + TAO_Bounded_Abstract_Sequence<T,T_var,MAX>::allocbuf (MAX) ) { } -template <typename T, typename T_var, typename T_life, size_t MAX> -TAO_Bounded_Abstract_Sequence<T,T_var,T_life,MAX>:: -TAO_Bounded_Abstract_Sequence ( - const TAO_Bounded_Abstract_Sequence<T,T_var,T_life,MAX> & rhs +template <typename T, typename T_var, size_t MAX> +TAO_Bounded_Abstract_Sequence<T,T_var,MAX>::TAO_Bounded_Abstract_Sequence ( + const TAO_Bounded_Abstract_Sequence<T,T_var,MAX> & rhs ) : TAO_Bounded_Base_Sequence (rhs) { if (rhs.buffer_ != 0) { T ** tmp1 = - TAO_Bounded_Abstract_Sequence<T,T_var,T_life,MAX>::allocbuf (MAX); + TAO_Bounded_Abstract_Sequence<T,T_var,MAX>::allocbuf (MAX); T ** const tmp2 = ACE_reinterpret_cast (T ** ACE_CAST_CONST, rhs.buffer_); for (CORBA::ULong i = 0; i < rhs.length_; ++i) { - tmp1[i] = T_life::tao_duplicate (tmp2[i]); + tmp1[i] = TAO::Objref_Traits<T>::tao_duplicate (tmp2[i]); } this->buffer_ = tmp1; @@ -850,10 +850,10 @@ TAO_Bounded_Abstract_Sequence ( } } -template <typename T, typename T_var, typename T_life, size_t MAX> -TAO_Bounded_Abstract_Sequence<T,T_var,T_life,MAX> & -TAO_Bounded_Abstract_Sequence<T,T_var,T_life,MAX>::operator= ( - const TAO_Bounded_Abstract_Sequence<T,T_var,T_life,MAX> & rhs +template <typename T, typename T_var, size_t MAX> +TAO_Bounded_Abstract_Sequence<T,T_var,MAX> & +TAO_Bounded_Abstract_Sequence<T,T_var,MAX>::operator= ( + const TAO_Bounded_Abstract_Sequence<T,T_var,MAX> & rhs ) { if (this == &rhs) @@ -868,8 +868,8 @@ TAO_Bounded_Abstract_Sequence<T,T_var,T_life,MAX>::operator= ( for (CORBA::ULong i = 0; i < this->length_; ++i) { - T_life::tao_release (tmp[i]); - tmp[i] = T_life::tao_nil (); + TAO::Objref_Traits<T>::tao_release (tmp[i]); + tmp[i] = TAO::Objref_Traits<T>::tao_nil (); } // No need to reallocate the buffer since it is always of size // MAX @@ -883,7 +883,7 @@ TAO_Bounded_Abstract_Sequence<T,T_var,T_life,MAX>::operator= ( else { this->buffer_ = - TAO_Bounded_Abstract_Sequence<T,T_var,T_life,MAX>::allocbuf ( + TAO_Bounded_Abstract_Sequence<T,T_var,MAX>::allocbuf ( rhs.maximum_ ); } @@ -898,15 +898,15 @@ TAO_Bounded_Abstract_Sequence<T,T_var,T_life,MAX>::operator= ( for (CORBA::ULong i = 0; i < rhs.length_; ++i) { - tmp1[i] = T_life::tao_duplicate (tmp2[i]); + tmp1[i] = TAO::Objref_Traits<T>::tao_duplicate (tmp2[i]); } return *this; } -template <typename T, typename T_var, typename T_life, size_t MAX> +template <typename T, typename T_var, size_t MAX> T ** -TAO_Bounded_Abstract_Sequence<T,T_var,T_life,MAX>::allocbuf (CORBA::ULong) +TAO_Bounded_Abstract_Sequence<T,T_var,MAX>::allocbuf (CORBA::ULong) { T ** buf = 0; ACE_NEW_RETURN (buf, @@ -915,46 +915,46 @@ TAO_Bounded_Abstract_Sequence<T,T_var,T_life,MAX>::allocbuf (CORBA::ULong) for (CORBA::ULong i = 0; i < MAX; ++i) { - buf[i] = T_life::tao_nil (); + buf[i] = TAO::Objref_Traits<T>::tao_nil (); } return buf; } -template <typename T, typename T_var, typename T_life, size_t MAX> +template <typename T, typename T_var, size_t MAX> void -TAO_Bounded_Abstract_Sequence<T,T_var,T_life,MAX>::freebuf (T ** buffer) +TAO_Bounded_Abstract_Sequence<T,T_var,MAX>::freebuf (T ** buffer) { // How much do we deallocate? Easy! allocbuf() always creates MAX // elements and initialize them to T::_nil(). So we can be // complaint and call CORBA::release() on each one. for (CORBA::ULong i = 0; i < MAX; ++i) { - if (buffer[i] != T_life::tao_nil ()) + if (buffer[i] != TAO::Objref_Traits<T>::tao_nil ()) { - T_life::tao_release (buffer[i]); - buffer[i] = T_life::tao_nil (); + TAO::Objref_Traits<T>::tao_release (buffer[i]); + buffer[i] = TAO::Objref_Traits<T>::tao_nil (); } } delete [] buffer; } -template <typename T, typename T_var, typename T_life, size_t MAX> +template <typename T, typename T_var, size_t MAX> void -TAO_Bounded_Abstract_Sequence<T,T_var,T_life,MAX>::_allocate_buffer ( +TAO_Bounded_Abstract_Sequence<T,T_var,MAX>::_allocate_buffer ( CORBA::ULong length ) { // For this class memory is never reallocated so the implementation // is *really* simple. this->buffer_ = - TAO_Bounded_Abstract_Sequence<T,T_var,T_life,MAX>::allocbuf (length); + TAO_Bounded_Abstract_Sequence<T,T_var,MAX>::allocbuf (length); } -template <typename T, typename T_var, typename T_life, size_t MAX> +template <typename T, typename T_var, size_t MAX> void -TAO_Bounded_Abstract_Sequence<T,T_var,T_life,MAX>::_deallocate_buffer (void) +TAO_Bounded_Abstract_Sequence<T,T_var,MAX>::_deallocate_buffer (void) { if (this->release_ == 0) { @@ -963,13 +963,13 @@ TAO_Bounded_Abstract_Sequence<T,T_var,T_life,MAX>::_deallocate_buffer (void) T ** tmp = ACE_reinterpret_cast (T **, this->buffer_); - TAO_Bounded_Abstract_Sequence<T,T_var,T_life,MAX>::freebuf (tmp); + TAO_Bounded_Abstract_Sequence<T,T_var,MAX>::freebuf (tmp); this->buffer_ = 0; } -template <typename T, typename T_var, typename T_life, size_t MAX> +template <typename T, typename T_var, size_t MAX> void -TAO_Bounded_Abstract_Sequence<T,T_var,T_life,MAX>::_shrink_buffer ( +TAO_Bounded_Abstract_Sequence<T,T_var,MAX>::_shrink_buffer ( CORBA::ULong nl, CORBA::ULong ol ) @@ -979,8 +979,8 @@ TAO_Bounded_Abstract_Sequence<T,T_var,T_life,MAX>::_shrink_buffer ( for (CORBA::ULong i = nl; i < ol; ++i) { - T_life::tao_release (tmp[i]); - tmp[i] = T_life::tao_nil (); + TAO::Objref_Traits<T>::tao_release (tmp[i]); + tmp[i] = TAO::Objref_Traits<T>::tao_nil (); } } |