/**
* Test the two vectors are equal.
*/
bool_t vector_equal(const vector_t* cpvec_first, const vector_t* cpvec_second)
{
vector_iterator_t it_first;
vector_iterator_t it_second;
bool_t b_less = false;
bool_t b_greater = false;
assert(cpvec_first != NULL);
assert(cpvec_second != NULL);
assert(_vector_is_inited(cpvec_first));
assert(_vector_is_inited(cpvec_second));
/* same vector container */
if(cpvec_first == cpvec_second)
{
return true;
}
/* the element type is equal */
if(!_vector_same_type(cpvec_first, cpvec_second))
{
return false;
}
/* the element count is equal */
if(vector_size(cpvec_first) != vector_size(cpvec_second))
{
return false;
}
/* each element is equal */
for(it_first = vector_begin(cpvec_first), it_second = vector_begin(cpvec_second);
!iterator_equal(it_first, vector_end(cpvec_first)) && !iterator_equal(it_second, vector_end(cpvec_second));
it_first = iterator_next(it_first), it_second = iterator_next(it_second))
{
b_less = _GET_VECTOR_TYPE_SIZE(cpvec_first);
b_greater = _GET_VECTOR_TYPE_SIZE(cpvec_second);
_GET_VECTOR_TYPE_LESS_FUNCTION(cpvec_first)(_VECTOR_ITERATOR_COREPOS(it_first), _VECTOR_ITERATOR_COREPOS(it_second), &b_less);
_GET_VECTOR_TYPE_LESS_FUNCTION(cpvec_second)(_VECTOR_ITERATOR_COREPOS(it_second), _VECTOR_ITERATOR_COREPOS(it_first), &b_greater);
if(b_less || b_greater)
{
return false;
}
}
assert(iterator_equal(it_first, vector_end(cpvec_first)) &&
iterator_equal(it_second, vector_end(cpvec_second)));
return true;
}
/**
* Test the type that saved in the vector container and referenced by it_iter are same.
*/
bool_t _vector_same_iterator_type(const vector_t* cpvec_vector, iterator_t it_iter)
{
assert(cpvec_vector != NULL);
assert(_vector_is_inited(cpvec_vector) || _vector_is_created(cpvec_vector));
assert(_iterator_is_valid(it_iter));
return _type_is_same_ex(&cpvec_vector->_t_typeinfo, _iterator_get_typeinfo(it_iter));
}
/**
* Access last vector data.
*/
void* vector_back(const vector_t* cpvec_vector)
{
assert(cpvec_vector != NULL);
assert(_vector_is_inited(cpvec_vector));
assert(!vector_empty(cpvec_vector));
return vector_at(cpvec_vector, vector_size(cpvec_vector) - 1);
}
/**
* Access first vector data.
*/
void* vector_front(const vector_t* cpvec_vector)
{
assert(cpvec_vector != NULL);
assert(_vector_is_inited(cpvec_vector));
assert(!vector_empty(cpvec_vector));
return vector_at(cpvec_vector, 0);
}
/**
* Access vector data using subscript.
*/
void* vector_at(const vector_t* cpvec_vector, size_t t_pos)
{
assert(cpvec_vector != NULL);
assert(_vector_is_inited(cpvec_vector));
assert(t_pos < vector_size(cpvec_vector));
return (void*)iterator_get_pointer(iterator_next_n(vector_begin(cpvec_vector), t_pos));
}
/**
* Set vector capacity.
*/
void vector_reserve(vector_t* pvec_vector, size_t t_reservesize)
{
_byte_t* pby_reservemem = NULL; /* new memory for reserve */
_byte_t* pby_newstart = NULL;
_byte_t* pby_newfinish = NULL;
_byte_t* pby_newendofstorage = NULL;
_byte_t* pby_newpos = NULL;
_byte_t* pby_oldpos = NULL;
size_t t_oldsize = 0;
size_t t_oldcapacity = 0;
bool_t b_result = false;
assert(pvec_vector != NULL);
assert(_vector_is_inited(pvec_vector));
if(vector_capacity(pvec_vector) < t_reservesize)
{
/* allocate the new vector with reserve size */
pby_reservemem = _alloc_allocate(&pvec_vector->_t_allocator, _GET_VECTOR_TYPE_SIZE(pvec_vector), t_reservesize);
assert(pby_reservemem != NULL);
/* get the new position */
t_oldsize = pvec_vector->_pby_finish - pvec_vector->_pby_start;
t_oldcapacity = pvec_vector->_pby_endofstorage - pvec_vector->_pby_start;
pby_newstart = pby_reservemem;
pby_newfinish = pby_reservemem + t_oldsize;
pby_newendofstorage = pby_reservemem + _GET_VECTOR_TYPE_SIZE(pvec_vector) * t_reservesize;
/* initialize new elements */
_vector_init_elem_range_auxiliary(pvec_vector, pby_newstart, pby_newfinish);
/* copy elements from old memory and destroy those */
for(pby_newpos = pby_newstart, pby_oldpos = pvec_vector->_pby_start;
pby_newpos < pby_newfinish && pby_oldpos < pvec_vector->_pby_finish;
pby_newpos += _GET_VECTOR_TYPE_SIZE(pvec_vector),
pby_oldpos += _GET_VECTOR_TYPE_SIZE(pvec_vector))
{
/* copy from old vector_t memory */
b_result = _GET_VECTOR_TYPE_SIZE(pvec_vector);
_GET_VECTOR_TYPE_COPY_FUNCTION(pvec_vector)(pby_newpos, pby_oldpos, &b_result);
assert(b_result);
/* destroy old vector_t memory */
b_result = _GET_VECTOR_TYPE_SIZE(pvec_vector);
_GET_VECTOR_TYPE_DESTROY_FUNCTION(pvec_vector)(pby_oldpos, &b_result);
assert(b_result);
}
assert(pby_newpos == pby_newfinish && pby_oldpos == pvec_vector->_pby_finish);
/* free the old vector element */
if(pvec_vector->_pby_start != NULL)
{
_alloc_deallocate(&pvec_vector->_t_allocator, pvec_vector->_pby_start,
_GET_VECTOR_TYPE_SIZE(pvec_vector), t_oldcapacity / _GET_VECTOR_TYPE_SIZE(pvec_vector));
}
pvec_vector->_pby_start = pby_newstart;
pvec_vector->_pby_finish = pby_newfinish;
pvec_vector->_pby_endofstorage = pby_newendofstorage;
}
}
/**
* Destroy vector container.
*/
void vector_destroy(vector_t* pvec_vector)
{
assert(pvec_vector != NULL);
assert(_vector_is_inited(pvec_vector) || _vector_is_created(pvec_vector));
_vector_destroy_auxiliary(pvec_vector);
/* free memory that malloced in _create_vector() function */
free(pvec_vector);
}
/**
* Removes an element in vector from specificed position.
*/
vector_iterator_t vector_erase(vector_t* pvec_vector, vector_iterator_t it_pos)
{
assert(pvec_vector != NULL);
assert(_vector_is_inited(pvec_vector));
assert(_vector_iterator_belong_to_vector(pvec_vector, it_pos));
assert(!iterator_equal(it_pos, vector_end(pvec_vector)));
return vector_erase_range(pvec_vector, it_pos, iterator_next(it_pos));
}
/**
* Obtain data from variable argument list, the data type and vector element data type are same.
*/
void _vector_get_varg_value_auxiliary(vector_t* pvec_vector, va_list val_elemlist, void* pv_varg)
{
assert(pvec_vector != NULL);
assert(pv_varg != NULL);
assert(_vector_is_inited(pvec_vector) || _vector_is_created(pvec_vector));
_vector_init_elem_auxiliary(pvec_vector, pv_varg);
_type_get_varg_value(&pvec_vector->_t_typeinfo, val_elemlist, pv_varg);
}
/**
* Initialize vector container with an exist vector container.
*/
void vector_init_copy(vector_t* pvec_dest, const vector_t* cpvec_src)
{
assert(pvec_dest != NULL);
assert(cpvec_src != NULL);
assert(_vector_is_created(pvec_dest));
assert(_vector_is_inited(cpvec_src));
assert(_vector_same_type(pvec_dest, cpvec_src));
vector_init_copy_range(pvec_dest, vector_begin(cpvec_src), vector_end(cpvec_src));
}
/**
* Reset the size of vector elements.
*/
void _vector_resize_elem(vector_t* pvec_vector, size_t t_resize, ...)
{
va_list val_elemlist;
assert(pvec_vector != NULL);
assert(_vector_is_inited(pvec_vector));
va_start(val_elemlist, t_resize);
_vector_resize_elem_varg(pvec_vector, t_resize, val_elemlist);
va_end(val_elemlist);
}
/**
* Swap vector datas.
*/
void vector_swap(vector_t* pvec_first, vector_t* pvec_second)
{
vector_t vec_swap; /* the swap temporary vector */
/* test the two vector has the same type */
assert(pvec_first != NULL);
assert(pvec_second != NULL);
assert(_vector_is_inited(pvec_first));
assert(_vector_is_inited(pvec_second));
assert(_vector_same_type(pvec_first, pvec_second));
if(vector_equal(pvec_first, pvec_second))
{
return;
}
vec_swap = *pvec_first;
*pvec_first = *pvec_second;
*pvec_second = vec_swap;
}
/**
* Add specificed element at the end of vector container.
*/
void _vector_push_back(vector_t* pvec_vector, ...)
{
va_list val_elemlist;
assert(pvec_vector != NULL);
assert(_vector_is_inited(pvec_vector));
va_start(val_elemlist, pvec_vector);
_vector_push_back_varg(pvec_vector, val_elemlist);
va_end(val_elemlist);
}
/**
* Return a iterator to the first element in the vector container.
*/
vector_iterator_t vector_begin(const vector_t* cpvec_vector)
{
vector_iterator_t it_begin; /* new vector iterator */
assert(cpvec_vector != NULL);
assert(_vector_is_inited(cpvec_vector));
it_begin = _create_vector_iterator();
_ITERATOR_CONTAINER(it_begin) = (vector_t*)cpvec_vector;
_VECTOR_ITERATOR_COREPOS(it_begin) = cpvec_vector->_pby_start;
return it_begin;
}
/**
* Destroy data, the data type and vector element data type are same.
*/
void _vector_destroy_varg_value_auxiliary(vector_t* pvec_vector, void* pv_varg)
{
bool_t b_result = false;
assert(pvec_vector != NULL);
assert(pv_varg != NULL);
assert(_vector_is_inited(pvec_vector) || _vector_is_created(pvec_vector));
/* destroy varg value and free memory */
b_result = _GET_VECTOR_TYPE_SIZE(pvec_vector);
_GET_VECTOR_TYPE_DESTROY_FUNCTION(pvec_vector)(pv_varg, &b_result);
assert(b_result);
}
vector_reverse_iterator_t vector_rend(const vector_t* cpvec_vector)
{
vector_reverse_iterator_t it_rend;
assert(cpvec_vector != NULL);
assert(_vector_is_inited(cpvec_vector));
it_rend = _create_vector_iterator();
_ITERATOR_CONTAINER(it_rend) = (vector_t*)cpvec_vector;
_VECTOR_ITERATOR_COREPOS(it_rend) = cpvec_vector->_pby_start - _GET_VECTOR_TYPE_SIZE(cpvec_vector);
return it_rend;
}
/**
* Return a iterator that points just beyond the end of vector container.
*/
vector_iterator_t vector_end(const vector_t* cpvec_vector)
{
vector_iterator_t it_end;
assert(cpvec_vector != NULL);
assert(_vector_is_inited(cpvec_vector));
it_end = _create_vector_iterator();
_ITERATOR_CONTAINER(it_end) = (vector_t*)cpvec_vector;
_VECTOR_ITERATOR_COREPOS(it_end) = cpvec_vector->_pby_finish;
return it_end;
}
/**
* Reset the size of vector elements, and filled element is from variable argument list.
*/
void _vector_resize_elem_varg(vector_t* pvec_vector, size_t t_resize, va_list val_elemlist)
{
vector_iterator_t t_cutpos; /* the cut position */
size_t t_expsize = 0;
size_t i = 0;
void* pv_varg = NULL;
_byte_t* pby_oldfinish = NULL;
bool_t b_result = false;
assert(pvec_vector != NULL);
assert(_vector_is_inited(pvec_vector));
if(t_resize == vector_size(pvec_vector))
{
return;
}
else if(t_resize < vector_size(pvec_vector))
{
t_cutpos = vector_begin(pvec_vector);
t_cutpos = iterator_next_n(t_cutpos, t_resize);
vector_erase_range(pvec_vector, t_cutpos, vector_end(pvec_vector));
}
else
{
t_expsize = t_resize - vector_size(pvec_vector);
if(t_resize > vector_capacity(pvec_vector))
{
vector_reserve(pvec_vector, _vector_calculate_new_capacity(vector_size(pvec_vector), t_expsize));
}
/* get varg value only once */
pv_varg = _alloc_allocate(&pvec_vector->_t_allocator, _GET_VECTOR_TYPE_SIZE(pvec_vector), 1);
assert(pv_varg != NULL);
_vector_get_varg_value_auxiliary(pvec_vector, val_elemlist, pv_varg);
/* initialize new elements */
pby_oldfinish = pvec_vector->_pby_finish;
pvec_vector->_pby_finish += t_expsize * _GET_VECTOR_TYPE_SIZE(pvec_vector);
_vector_init_elem_range_auxiliary(pvec_vector, pby_oldfinish, pvec_vector->_pby_finish);
/* copy value from varg to new elements */
for(i = 0; i < t_expsize; ++i)
{
b_result = _GET_VECTOR_TYPE_SIZE(pvec_vector);
_GET_VECTOR_TYPE_COPY_FUNCTION(pvec_vector)(pby_oldfinish + i * _GET_VECTOR_TYPE_SIZE(pvec_vector), pv_varg, &b_result);
assert(b_result);
}
/* destroy varg */
_vector_destroy_varg_value_auxiliary(pvec_vector, pv_varg);
_alloc_deallocate(&pvec_vector->_t_allocator, pv_varg, _GET_VECTOR_TYPE_SIZE(pvec_vector), 1);
}
}
/**
* Delete the element at the end of vector.
*/
void vector_pop_back(vector_t* pvec_vector)
{
bool_t b_result = false;
assert(pvec_vector != NULL);
assert(_vector_is_inited(pvec_vector));
assert(!vector_empty(pvec_vector));
/* destroy last element */
b_result = _GET_VECTOR_TYPE_SIZE(pvec_vector);
_GET_VECTOR_TYPE_DESTROY_FUNCTION(pvec_vector)(pvec_vector->_pby_finish - _GET_VECTOR_TYPE_SIZE(pvec_vector), &b_result);
assert(b_result);
pvec_vector->_pby_finish -= _GET_VECTOR_TYPE_SIZE(pvec_vector);
}
/**
* Insert multiple copys of element befor specificed position.
*/
vector_iterator_t _vector_insert_n(vector_t* pvec_vector, vector_iterator_t it_pos, size_t t_count, ...)
{
vector_iterator_t it_iter;
va_list val_elemlist;
assert(pvec_vector != NULL);
assert(_vector_is_inited(pvec_vector));
assert(_vector_iterator_belong_to_vector(pvec_vector, it_pos));
va_start(val_elemlist, t_count);
it_iter = _vector_insert_n_varg(pvec_vector, it_pos, t_count, val_elemlist);
va_end(val_elemlist);
return it_iter;
}
/**
* Test iterator referenced data is within the vector.
*/
bool_t _vector_iterator_belong_to_vector(const vector_t* cpvec_vector, vector_iterator_t it_iter)
{
assert(cpvec_vector != NULL);
assert(_vector_is_inited(cpvec_vector));
assert(_VECTOR_ITERATOR_ITERATOR_TYPE(it_iter) == _RANDOM_ACCESS_ITERATOR);
assert(_VECTOR_ITERATOR_CONTAINER_TYPE(it_iter) == _VECTOR_CONTAINER);
assert(_VECTOR_ITERATOR_CONTAINER(it_iter) == cpvec_vector);
if (_VECTOR_ITERATOR_COREPOS(it_iter) >= cpvec_vector->_pby_start &&
_VECTOR_ITERATOR_COREPOS(it_iter) <= cpvec_vector->_pby_finish) {
return true;
} else {
return false;
}
}
/**
* Initialize element with vector element type auxiliary function.
*/
void _vector_init_elem_auxiliary(vector_t* pvec_vector, void* pv_elem)
{
assert(pvec_vector != NULL);
assert(pv_elem != NULL);
assert(_vector_is_inited(pvec_vector) || _vector_is_created(pvec_vector));
/* initialize new elements */
if (_GET_VECTOR_TYPE_STYLE(pvec_vector) == _TYPE_CSTL_BUILTIN) {
/* get element type name */
char s_elemtypename[_TYPE_NAME_SIZE + 1];
_type_get_elem_typename(_GET_VECTOR_TYPE_NAME(pvec_vector), s_elemtypename);
_GET_VECTOR_TYPE_INIT_FUNCTION(pvec_vector)(pv_elem, s_elemtypename);
} else {
bool_t b_result = _GET_VECTOR_TYPE_SIZE(pvec_vector);
_GET_VECTOR_TYPE_INIT_FUNCTION(pvec_vector)(pv_elem, &b_result);
assert(b_result);
}
}
/**
* Add specificed element from variable argument list at the end of vector container.
*/
void _vector_push_back_varg(vector_t* pvec_vector, va_list val_elemlist)
{
_byte_t* pby_last = NULL;
assert(pvec_vector != NULL);
assert(_vector_is_inited(pvec_vector));
/* if the remain capacity is less then the element count */
if (vector_capacity(pvec_vector) == vector_size(pvec_vector)) {
vector_reserve(pvec_vector, _vector_calculate_new_capacity(vector_size(pvec_vector), 1));
}
/* initialize the last element */
pby_last = pvec_vector->_pby_finish;
assert(pby_last != NULL);
pvec_vector->_pby_finish += _GET_VECTOR_TYPE_SIZE(pvec_vector);
_vector_init_elem_auxiliary(pvec_vector, pby_last);
/* copy value from varg */
_type_get_varg_value(&pvec_vector->_t_typeinfo, val_elemlist, pby_last);
}
/**
* Removes a range of elements in vector from specificed position.
*/
vector_iterator_t vector_erase_range(vector_t* pvec_vector, vector_iterator_t it_begin, vector_iterator_t it_end)
{
size_t t_erasesize = 0;
bool_t b_result = false;
vector_iterator_t it_iter;
assert(pvec_vector != NULL);
assert(_vector_is_inited(pvec_vector));
assert(_vector_iterator_belong_to_vector(pvec_vector, it_begin));
assert(_vector_iterator_belong_to_vector(pvec_vector, it_end));
assert(iterator_equal(it_begin, it_end) || _vector_iterator_before(it_begin, it_end));
if(iterator_equal(it_begin, it_end))
{
return it_end;
}
it_iter = it_begin;
t_erasesize = iterator_distance(it_begin, it_end);
for(; !iterator_equal(it_end, vector_end(pvec_vector)); it_begin = iterator_next(it_begin), it_end = iterator_next(it_end))
{
b_result = _GET_VECTOR_TYPE_SIZE(pvec_vector);
_GET_VECTOR_TYPE_COPY_FUNCTION(pvec_vector)(_VECTOR_ITERATOR_COREPOS(it_begin), _VECTOR_ITERATOR_COREPOS(it_end), &b_result);
assert(b_result);
}
assert(_VECTOR_ITERATOR_COREPOS(it_begin) == pvec_vector->_pby_finish - t_erasesize * _GET_VECTOR_TYPE_SIZE(pvec_vector));
/* destroy the deleted elements */
for(; !iterator_equal(it_begin, it_end); it_begin = iterator_next(it_begin))
{
b_result = _GET_VECTOR_TYPE_SIZE(pvec_vector);
_GET_VECTOR_TYPE_DESTROY_FUNCTION(pvec_vector)(_VECTOR_ITERATOR_COREPOS(it_begin), &b_result);
assert(b_result);
}
pvec_vector->_pby_finish -= t_erasesize * _GET_VECTOR_TYPE_SIZE(pvec_vector);
return it_iter;
}
/**
* Test hashtable is initialized by hashtable initialization functions.
*/
bool_t _hashtable_is_inited(const _hashtable_t* cpt_hashtable)
{
assert(cpt_hashtable != NULL);
if (cpt_hashtable->_t_typeinfo._t_style != _TYPE_C_BUILTIN &&
cpt_hashtable->_t_typeinfo._t_style != _TYPE_CSTL_BUILTIN &&
cpt_hashtable->_t_typeinfo._t_style != _TYPE_USER_DEFINE) {
return false;
}
if (cpt_hashtable->_t_typeinfo._pt_type == NULL) {
return false;
}
if (!_vector_is_inited(&cpt_hashtable->_vec_bucket) ||
vector_size(&cpt_hashtable->_vec_bucket) < _HASHTABLE_FIRST_PRIME_BUCKET_COUNT) {
return false;
}
if (cpt_hashtable->_ufun_hash == NULL || cpt_hashtable->_bfun_compare == NULL) {
return false;
}
return true;
}
/**
* Insert multiple copys of element befor specificed position, the element is from variable argument list.
*/
vector_iterator_t _vector_insert_n_varg(vector_t* pvec_vector, vector_iterator_t it_pos, size_t t_count, va_list val_elemlist)
{
void* pv_varg = NULL;
bool_t b_result = false;
/* test the vector and iterator is valid */
assert(pvec_vector != NULL);
assert(_vector_is_inited(pvec_vector));
assert(_vector_iterator_belong_to_vector(pvec_vector, it_pos));
if (t_count > 0) {
size_t i = 0;
_byte_t* pby_oldfinish = NULL;
_byte_t* pby_pos = NULL; /* for initialize elments and insert elements */
_byte_t* pby_destpos = NULL;
/* if the remain capacity is less then the element count */
if (vector_size(pvec_vector) + t_count > vector_capacity(pvec_vector)) {
size_t t_insertpos = iterator_distance(vector_begin(pvec_vector), it_pos);
/* reserve the new size */
vector_reserve(pvec_vector, _vector_calculate_new_capacity(vector_size(pvec_vector), t_count));
it_pos = iterator_next_n(vector_begin(pvec_vector), t_insertpos);
}
/* insert the element counts of element to the position */
/*
* move the elements from pos to the finish of vector to the
* memory that after the pos element count.
* +-----------------------------------------+
* | | | |
* +-----------------------------------------+
* ^ ^ ^
* | | |
* start it_pos finish
* _t_count__
* / \
* +-----------------------------------------+
* | | |new element| |
* +-----------------------------------------+
* ^ ^ ^ ^
* | | | |
* start it_pos pby_oldfinish finish
*/
/* initialize new elements */
pby_oldfinish = pvec_vector->_pby_finish;
assert(pby_oldfinish != NULL);
pvec_vector->_pby_finish += t_count * _GET_VECTOR_TYPE_SIZE(pvec_vector);
_vector_init_elem_range_auxiliary(pvec_vector, pby_oldfinish, pvec_vector->_pby_finish);
/* move element from old finish to new finish */
for (pby_pos = pby_oldfinish - _GET_VECTOR_TYPE_SIZE(pvec_vector),
pby_destpos = pvec_vector->_pby_finish - _GET_VECTOR_TYPE_SIZE(pvec_vector);
pby_pos >= _VECTOR_ITERATOR_COREPOS(it_pos);
pby_pos -= _GET_VECTOR_TYPE_SIZE(pvec_vector),
pby_destpos -= _GET_VECTOR_TYPE_SIZE(pvec_vector)) {
b_result = _GET_VECTOR_TYPE_SIZE(pvec_vector);
_GET_VECTOR_TYPE_COPY_FUNCTION(pvec_vector)(pby_destpos, pby_pos, &b_result);
assert(b_result);
}
/* get varg value only once */
pv_varg = _alloc_allocate(&pvec_vector->_t_allocator, _GET_VECTOR_TYPE_SIZE(pvec_vector), 1);
assert(pv_varg != NULL);
_vector_get_varg_value_auxiliary(pvec_vector, val_elemlist, pv_varg);
/* copy value for varg */
for (i = 0; i < t_count; ++i) {
b_result = _GET_VECTOR_TYPE_SIZE(pvec_vector);
_GET_VECTOR_TYPE_COPY_FUNCTION(pvec_vector)(_VECTOR_ITERATOR_COREPOS(it_pos) + i * _GET_VECTOR_TYPE_SIZE(pvec_vector), pv_varg, &b_result);
assert(b_result);
}
/* destroy varg and free memory */
_vector_destroy_varg_value_auxiliary(pvec_vector, pv_varg);
_alloc_deallocate(&pvec_vector->_t_allocator, pv_varg, _GET_VECTOR_TYPE_SIZE(pvec_vector), 1);
}
return it_pos;
}
/**
* Insert a range of elements into vector at a specificed position.
*/
void vector_insert_range(vector_t* pvec_vector, vector_iterator_t it_pos, vector_iterator_t it_begin, vector_iterator_t it_end)
{
size_t t_count = 0; /* the element count */
bool_t b_result = false;
vector_iterator_t it_first;
vector_iterator_t it_second;
_byte_t* pby_oldfinish = NULL;
_byte_t* pby_pos = NULL;
_byte_t* pby_destpos = NULL;
/* test the vector and iterator is valid */
assert(pvec_vector != NULL);
assert(_vector_is_inited(pvec_vector));
assert(_vector_iterator_belong_to_vector(pvec_vector, it_pos));
/*assert(!_vector_iterator_belong_to_vector(pvec_vector, it_begin));*/
/*assert(!_vector_iterator_belong_to_vector(pvec_vector, it_end));*/
assert(_vector_same_vector_iterator_type(pvec_vector, it_begin));
assert(_vector_same_vector_iterator_type(pvec_vector, it_end));
assert(iterator_equal(it_begin, it_end) || _vector_iterator_before(it_begin, it_end));
t_count = iterator_distance(it_begin, it_end);
if(t_count > 0)
{
/* if the remain capacity is less then the element count */
if(vector_size(pvec_vector) + t_count > vector_capacity(pvec_vector))
{
size_t t_distance = _VECTOR_ITERATOR_COREPOS(it_pos) - pvec_vector->_pby_start;
/* reserve the new size */
vector_reserve(pvec_vector, _vector_calculate_new_capacity(vector_size(pvec_vector), t_count));
_VECTOR_ITERATOR_COREPOS(it_pos) = pvec_vector->_pby_start + t_distance;
}
/* initialize new elements */
pby_oldfinish = pvec_vector->_pby_finish;
assert(pby_oldfinish != NULL);
pvec_vector->_pby_finish += t_count * _GET_VECTOR_TYPE_SIZE(pvec_vector);
_vector_init_elem_range_auxiliary(pvec_vector, pby_oldfinish, pvec_vector->_pby_finish);
/* move element from old finish to new finish */
for(pby_pos = pby_oldfinish - _GET_VECTOR_TYPE_SIZE(pvec_vector),
pby_destpos = pvec_vector->_pby_finish - _GET_VECTOR_TYPE_SIZE(pvec_vector);
pby_pos >= _VECTOR_ITERATOR_COREPOS(it_pos);
pby_pos -= _GET_VECTOR_TYPE_SIZE(pvec_vector),
pby_destpos -= _GET_VECTOR_TYPE_SIZE(pvec_vector))
{
b_result = _GET_VECTOR_TYPE_SIZE(pvec_vector);
_GET_VECTOR_TYPE_COPY_FUNCTION(pvec_vector)(pby_destpos, pby_pos, &b_result);
assert(b_result);
}
/* insert element counts copys to the pos */
for(it_first = it_pos, it_second = it_begin;
!iterator_equal(it_second, it_end);
it_first = iterator_next(it_first), it_second = iterator_next(it_second))
{
b_result = _GET_VECTOR_TYPE_SIZE(pvec_vector);
_GET_VECTOR_TYPE_COPY_FUNCTION(pvec_vector)(_VECTOR_ITERATOR_COREPOS(it_first), _VECTOR_ITERATOR_COREPOS(it_second), &b_result);
assert(b_result);
}
assert(_VECTOR_ITERATOR_COREPOS(it_first) == _VECTOR_ITERATOR_COREPOS(it_pos) +
(_VECTOR_ITERATOR_COREPOS(it_end) - _VECTOR_ITERATOR_COREPOS(it_begin)));
}
}
