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);
}
}
