OSCL_EXPORT_REF void Oscl_Vector_Base::assign_vector(const Oscl_Vector_Base& x)
{
if (x.size() > capacity())
{
// allocate space and copy
OsclAny* tmp = pOpaqueType->allocate((uint32)x.end() - (uint32)x.begin());
uninitialized_copy(x.begin(), x.end(), tmp);
destroy(begin(), end());
if (elems)
pOpaqueType->deallocate(elems);
elems = tmp;
bufsize = x.size();
}
else if (size() >= x.size())
{
OsclAny* i = copy(x.begin(), x.end(), begin());
destroy(i, end());
}
else
{
copy(x.begin(), increment_T(x.begin(), size()), begin());
uninitialized_copy(increment_T(x.begin(), size()), x.end(), end());
}
numelems = x.size();
}
OsclAny* Oscl_Vector_Base::uninitialized_copy(OsclAny* first, OsclAny* last, OsclAny* result)
{
while (first != last)
{
pOpaqueType->construct(result, first);
result = increment_T(result, 1);
first = increment_T(first, 1);
}
return result;
}
OSCL_EXPORT_REF OsclAny* Oscl_Vector_Base::erase(OsclAny* pos)
{
//note: use move instead of copy here since we assume
//it's not necessary to construct/destruct just to move
//an element.
pOpaqueType->destroy(pos);
if (increment_T(pos, 1) != end())
move(increment_T(pos, 1), end(), pos);
numelems--;
return pos;
}
OSCL_EXPORT_REF void Oscl_Queue_Base::reserve(uint32 n)
{
if (n > bufsize)
{
OsclAny* newElems = pOpaqueType->allocate(n * sizeof_T);
// transfer old contents using normal operations on (this) queue
// constructing new copy in "new__" variables. Note that data
// won't wrap here, so ok to just use [i++].
uint32 i = 0;
while (! empty())
{
pOpaqueType->construct(increment_T(newElems, i++), front());
pop();
}
if (elems)
{
pOpaqueType->deallocate(elems);
}
// now set new values
elems = newElems;
bufsize = n;
numelems = i;
ifront = 0;
irear = numelems > 0 ? ifront + numelems - 1 : bufsize - 1;
}
}
OSCL_EXPORT_REF void Oscl_Vector_Base::push_front(const OsclAny* x)
{
OSCL_ASSERT(x);
if (numelems == bufsize)
{
uint32 new_bufsize = (bufsize) ? 2 * bufsize : 2;
reserve(new_bufsize);
}
for (uint32 i = numelems; i > 0; i--)
{
pOpaqueType->construct(increment_T(elems, i), increment_T(elems, i - 1));
pOpaqueType->destroy(increment_T(elems, i - 1));
}
numelems++;
pOpaqueType->construct(begin(), x);
}
void Oscl_Vector_Base::destroy(OsclAny* first, OsclAny* last)
{
while (first != last)
{
pOpaqueType->destroy(first);
first = increment_T(first, 1);
}
}
OSCL_EXPORT_REF void Oscl_Vector_Base::reserve(uint32 n)
{
if (n > bufsize)
{
OsclAny* oldmem = elems;
elems = pOpaqueType->allocate(n * sizeof_T);
OsclAny* newelems = elems;
OsclAny* oldelems = oldmem;
for (uint32 i = 0; i < numelems; i++)
{
pOpaqueType->construct(newelems, oldelems);
newelems = increment_T(newelems, 1);
oldelems = increment_T(oldelems, 1);
}
if (oldmem)
{
destroy(oldmem, increment_T(oldmem, numelems));
pOpaqueType->deallocate(oldmem);
}
bufsize = n;
}
}
OSCL_EXPORT_REF OsclAny* Oscl_Vector_Base::insert(OsclAny* pos, const OsclAny* x)
{
OSCL_ASSERT(x);
if (numelems == bufsize)
{
uint32 new_bufsize = (bufsize) ? 2 * bufsize : 2;
OsclAny* oldPtr = elems;
reserve(new_bufsize);
int32 diff = ((char*)elems) - ((char*)oldPtr);
pos = (OsclAny*)(((char*)pos) + diff);
}
OsclAny* ptr = increment_T(elems, numelems);
while (ptr > pos)
{
OsclAny* previous = increment_T(ptr, -1);
pOpaqueType->construct(ptr, previous);
pOpaqueType->destroy(previous);
ptr = previous;
}
numelems++;
pOpaqueType->construct(pos, x);
return pos;
}
