template <class T> void ACE_Array_Base<T>::operator= (const ACE_Array_Base<T> &s) { // Check for "self-assignment". if (this != &s) { if (this->max_size_ < s.size ()) { ACE_DES_ARRAY_FREE (this->array_, this->max_size_, this->allocator_->free, T); ACE_ALLOCATOR (this->array_, (T *) this->allocator_->malloc (s.size () * sizeof (T))); this->max_size_ = s.size (); } else { ACE_DES_ARRAY_NOFREE (this->array_, s.size (), T); } this->cur_size_ = s.size (); for (size_t i = 0; i < this->size (); i++) new (&this->array_[i]) T (s.array_[i]); } }
ACE_Array_Base<T>::ACE_Array_Base (const ACE_Array_Base<T> &s) : max_size_ (s.size ()), cur_size_ (s.size ()), allocator_ (s.allocator_) { if (this->allocator_ == 0) this->allocator_ = ACE_Allocator::instance (); ACE_ALLOCATOR (this->array_, (T *) this->allocator_->malloc (s.size () * sizeof (T))); for (size_t i = 0; i < this->size (); i++) new (&this->array_[i]) T (s.array_[i]); }
void TAO_Cleanup_Func_Registry::cleanup (ACE_Array_Base <void *> &ts_objects) { size_t const len = ts_objects.size (); // The allocated slot may never have been used. It is therefore // possible that the TSS array size may be less than the cleanup // function size. However, there is still a one-to-one // correspondence between cleanup_func[foo] and ts_object[foo]. ACE_ASSERT (len <= this->cleanup_funcs_.size ()); /// Cleanup each TSS object. for (size_t i = 0; i < len; ++i) { ACE_CLEANUP_FUNC destructor = this->cleanup_funcs_[i]; if (destructor != 0) destructor (ts_objects[i], 0); } }