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