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();
}
void
__vector__<_Tp, _Alloc>::_M_assign_aux(_ForwardIter __first, _ForwardIter __last,
forward_iterator_tag) {
size_type __len = 0;
distance(__first, __last, __len);
if (__len > capacity()) {
iterator __tmp = _M_allocate_and_copy(__len, __first, __last);
_Destroy(_M_start, _M_finish);
_M_end_of_storage.deallocate(_M_start, _M_end_of_storage._M_data - _M_start);
_M_start = __tmp;
_M_end_of_storage._M_data = _M_finish = _M_start + __len;
}
else if (size() >= __len) {
iterator __new_finish = copy(__first, __last, _M_start);
_Destroy(__new_finish, _M_finish);
_M_finish = __new_finish;
}
else {
_ForwardIter __mid = __first;
advance(__mid, size());
copy(__first, __mid, _M_start);
_M_finish = uninitialized_copy(__mid, __last, _M_finish);
}
}
// Change the string's capacity so that it is large enough to hold
// at least __res_arg elements, plus the terminating _CharT(). Note that,
// if __res_arg < capacity(), this member function may actually decrease
// the string's capacity.
template <class _CharT, class _Traits, class _Alloc> void basic_string<_CharT,_Traits,_Alloc>::reserve(size_type __res_arg) {
if (__res_arg >= capacity())
{
if (__res_arg > max_size())
this->_M_throw_length_error();
size_type __n = __res_arg + 1;
pointer __new_start = this->_M_end_of_storage.allocate(__n);
pointer __new_finish = __new_start;
_STLP_TRY {
__new_finish = uninitialized_copy(this->_M_start, this->_M_finish, __new_start);
_M_construct_null(__new_finish);
}
_STLP_UNWIND((_STLP_STD::_Destroy(__new_start, __new_finish),
this->_M_end_of_storage.deallocate(__new_start, __n)));
_STLP_STD::_Destroy(this->_M_start, this->_M_finish + 1);
this->_M_deallocate_block();
this->_M_start = __new_start;
this->_M_finish = __new_finish;
this->_M_end_of_storage._M_data = __new_start + __n;
}
}
OSCL_EXPORT_REF void Oscl_Vector_Base::construct(Oscl_Opaque_Type_Alloc* aType, const Oscl_Vector_Base& x)
{
numelems = x.numelems;
bufsize = x.numelems;//only enough for current elements
pOpaqueType = aType;
elems = pOpaqueType->allocate(bufsize * sizeof_T);
uninitialized_copy(x.begin(), x.end(), begin());
}
// Create(it,it)
template<class T> void vec<T>::create(iterator beg, iterator end)
{
//get size of memory to be allocated and allocate
ptrdiff_t size = end - begin;
data = memManage.allocate(size);
//Initilize memory with data delimited by iterators
endData = uninitialized_copy(begin,end,data);
limit = endData;
}
std::pair<std::string *, std::string *>
alloc_and_copy(const std::string *begin, const std::string *end)
{
// allocate `unconstructed` space to hold elements
// *cxx-iter-arithmetic*
auto data = alloc.allocate(end - begin);
// uninitialized_copy()
// * construct copies of given elements in uninitialized space
// * returns the position after the last initialized element.
return {data, uninitialized_copy(begin, end, data)};
}
template<class T> void Vec<T>::grow() {
// when growing, allocate twice as much space as currently in use
size_type new_size = max(2 * (limit - data), std::ptrdiff_t(1));
// allocate new space and copy existing elements to the new space
iterator new_data = alloc.allocate(new_size);
iterator new_avail = uninitialized_copy(data, avail, new_data);
// return the old space
uncreate();
// reset pointers to point to the newly allocated space
data = new_data;
avail = new_avail;
limit = data + new_size;
}
void __vector__<_Tp, _Alloc>::_M_range_insert(
__iterator__ __position,
_ForwardIterator __first,
_ForwardIterator __last,
forward_iterator_tag)
# endif /* MEMBER_TEMPLATES */
# if !( defined ( __STL_MEMBER_TEMPLATES ) && defined (__STL_INLINE_MEMBER_TEMPLATES))
{
if (__first != __last) {
size_type __n = 0;
distance(__first, __last, __n);
if (size_type(_M_end_of_storage._M_data - _M_finish) >= __n) {
const size_type __elems_after = _M_finish - __position;
pointer __old_finish = _M_finish;
if (__elems_after > __n) {
uninitialized_copy(_M_finish - __n, _M_finish, _M_finish);
_M_finish += __n;
copy_backward(__position, __old_finish - __n, __old_finish);
copy(__first, __last, __position);
}
else {
# if (defined ( __STL_MEMBER_TEMPLATES ) && ! defined (__STL_INLINE_MEMBER_TEMPLATES))
_ForwardIterator __mid = __first;
advance(__mid, __elems_after);
# else
__const_pointer__ __mid = __first + __elems_after;
# endif
uninitialized_copy(__mid, __last, _M_finish);
_M_finish += __n - __elems_after;
uninitialized_copy(__position, __old_finish, _M_finish);
_M_finish += __elems_after;
copy(__first, __mid, __position);
}
}
else {
const size_type __old_size = size();
const size_type __len = __old_size + max(__old_size, __n);
pointer __new_start = _M_end_of_storage.allocate(__len);
pointer __new_finish = __new_start;
__STL_TRY {
__new_finish = uninitialized_copy(_M_start, __position, __new_start);
__new_finish = uninitialized_copy(__first, __last, __new_finish);
__new_finish
= uninitialized_copy(__position, _M_finish, __new_finish);
}
__STL_UNWIND((_Destroy(__new_start,__new_finish),
_M_end_of_storage.deallocate(__new_start,__len)));
_Destroy(_M_start, _M_finish);
_M_end_of_storage.deallocate(_M_start, _M_end_of_storage._M_data - _M_start);
_M_start = __new_start;
_M_finish = __new_finish;
_M_end_of_storage._M_data = __new_start + __len;
}
}
void String::reallocate()
{
auto newcapacity = size() ? size()*2 : 1;
// auto new_data = alloc.allocate(newcapacity);
// auto dest = new_data;
// auto elem = elements;
// for(size_t i=0; i !=size(); i++){
// alloc.construct(dest++, std::move(*elem++));
// }
auto first = alloc.allocate(newcapacity);
auto last = uninitialized_copy(make_move_iterator(begin()), make_move_iterator(end()), first);
free();
// elements = new_data;
// first_free = dest;
elements = first;
first_free = last;
cap = elements + newcapacity;
}
//grow
template<class T> void vec<T>::grow()
{
//To ensure low overhead, preallocate
//Everytime grow request arrives, allocate tiwce the number of
//current mem allocated
size_type new_size = max(2*(limit-data),ptrdiff_t(1));
// allocate and copy data to new region
iterator new_data = memManage.allocate(new_size);
iterator new_endData = uninitialized_copy(data,endData,new_data);
//Destroy old region
destroy();
//update iterator members
data = new_data;
endData = new_endData;
limit = data + new_size;
}
void Vec<T>::grow()
{
//when growing ,allocate twice as much space as currently in use
//策略，每次分配时，都分配双倍的空间，当然vec当前可能为空，因为我们可以选择一个元素的空间和已有空间的2倍来比较大小。
//由于max的2个参数必须类型相同，所有我们显式构造了ptr_diff(1)
size_type new_size=max(2*(limit-data),ptrdiff_t(1));
/**
我们首先把要分配多少元素的空间保存在new_size中，接下来分配适当大小的空间，并且调用uninitialze_copy把当前空间的元素，复制到新
空间中，然后调用uncreate函数来释放原先的内存，最后我们重新设置指针的值。
**/
iterator new_data=alloc.allocate(new_size);
iterator new_avail=uninitialized_copy(data,avail,new_data);
uncreate();
//reset pointer
data=new_data;
avail=new_avail;
limit=data+new_size;
}
void Vec<T>::create(const_iterator i, const_iterator j) {
data = alloc.allocate(j-i);
limit = avail = uninitialized_copy(i, j, data);
}
pair<char*, char*> String::alloc_n_copy(const char *b, const char *e)
{
auto data = alloc.allocate(e - b);
return {data, uninitialized_copy(b, e, data)};
}
pair<string *, string *> StrVec::alloc_n_copy(const string * b, const string * e)
{
// allocate space to hold as many elements as are in the range
auto data = alloc.allocate(e - b);
return{data, uninitialized_copy(b, e, data)};
}
std::pair<std::string*,std::string*> str_vec::alloc_n_copy(std::string *b,std::string *e)
{
std::string *p= alloc.allocate(e-b);
return make_pair(p,uninitialized_copy(b,e,p));
}
ForwardIterator uninitialized_move_if_noexcept_impl(InputIterator first, InputIterator last, ForwardIterator dest, Alloc& a,
false_type) {
return uninitialized_copy(first, last, dest, a);
}
pair<string * ,string *> StrVec::alloc_n_copy(const string *b, const string *e)
{
auto data = alloc.allocate(e-b);
return {data ,uninitialized_copy(b,e,data)};
}
byte_array::byte_array(std::initializer_list<uint8_t> data)
{
resize(data.size());
uninitialized_copy(data.begin(), data.end(), value.begin());
}
pair<char * , char *> String::alloc_n_copy(const char *b,const char *e)
{
auto ret = alloc.allocate(e-b);
return {ret , uninitialized_copy(b,e,ret)};
}
