/**
* Test the type that saved in the vector container is same.
*/
bool_t _vector_same_type(const vector_t* cpvec_first, const vector_t* cpvec_second)
{
assert(cpvec_first != NULL);
assert(cpvec_second != NULL);
assert(_vector_is_inited(cpvec_first) || _vector_is_created(cpvec_first));
assert(_vector_is_inited(cpvec_second) || _vector_is_created(cpvec_second));
if (cpvec_first == cpvec_second) {
return true;
}
return (cpvec_first->_t_typeinfo._pt_type == cpvec_second->_t_typeinfo._pt_type) &&
(cpvec_first->_t_typeinfo._t_style == cpvec_second->_t_typeinfo._t_style) &&
_type_is_same(_GET_VECTOR_TYPE_NAME(cpvec_first), _GET_VECTOR_TYPE_NAME(cpvec_second));
}
/**
* Destroy vector container auxiliary function.
*/
void _vector_destroy_auxiliary(vector_t* pvec_vector)
{
vector_iterator_t it_iter;
vector_iterator_t it_begin;
vector_iterator_t it_end;
bool_t b_result = false;
assert(pvec_vector != NULL);
assert(_vector_is_inited(pvec_vector) || _vector_is_created(pvec_vector));
/* destroy all elements */
it_begin = vector_begin(pvec_vector);
it_end = vector_end(pvec_vector);
for (it_iter = it_begin; !iterator_equal(it_iter, it_end); it_iter = iterator_next(it_iter)) {
b_result = _GET_VECTOR_TYPE_SIZE(pvec_vector);
_GET_VECTOR_TYPE_DESTROY_FUNCTION(pvec_vector)(_VECTOR_ITERATOR_COREPOS(it_iter), &b_result);
assert(b_result);
}
/* free vector memory */
if (pvec_vector->_pby_start != NULL) {
_alloc_deallocate(&pvec_vector->_t_allocator, pvec_vector->_pby_start, _GET_VECTOR_TYPE_SIZE(pvec_vector),
(pvec_vector->_pby_endofstorage - pvec_vector->_pby_start) / _GET_VECTOR_TYPE_SIZE(pvec_vector));
}
_alloc_destroy(&pvec_vector->_t_allocator);
pvec_vector->_pby_start = NULL;
pvec_vector->_pby_finish = NULL;
pvec_vector->_pby_endofstorage = NULL;
}
/**
* Initialize vector with variable argument list of specified element.
*/
void _vector_init_elem_varg(vector_t* pvec_vector, size_t t_count, va_list val_elemlist)
{
void* pv_varg = NULL;
bool_t b_result = false;
vector_iterator_t it_iter;
vector_iterator_t it_begin;
vector_iterator_t it_end;
assert(pvec_vector != NULL);
assert(_vector_is_created(pvec_vector));
/* initialize vector_t */
vector_init_n(pvec_vector, t_count);
if (t_count > 0) {
/* 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 varg value to each element */
it_begin = vector_begin(pvec_vector);
it_end = vector_end(pvec_vector);
for (it_iter = it_begin; !iterator_equal(it_iter, it_end); it_iter = iterator_next(it_iter)) {
/* copy from varg */
b_result = _GET_VECTOR_TYPE_SIZE(pvec_vector);
_GET_VECTOR_TYPE_COPY_FUNCTION(pvec_vector)(_VECTOR_ITERATOR_COREPOS(it_iter), pv_varg, &b_result);
assert(b_result);
}
/* destroy varg value 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);
}
}
/**
* Initialize vector container with an exist vector range.
*/
void vector_init_copy_range(vector_t* pvec_dest, vector_iterator_t it_begin, vector_iterator_t it_end)
{
vector_iterator_t it_dest;
vector_iterator_t it_src;
bool_t b_result = false;
assert(pvec_dest != NULL);
assert(_vector_is_created(pvec_dest));
assert(_vector_iterator_belong_to_vector(_VECTOR_ITERATOR_CONTAINER(it_begin), it_begin));
assert(_vector_iterator_belong_to_vector(_VECTOR_ITERATOR_CONTAINER(it_end), it_end));
assert(iterator_equal(it_begin, it_end) || _vector_iterator_before(it_begin, it_end));
assert(_vector_same_vector_iterator_type(pvec_dest, it_begin));
assert(_vector_same_vector_iterator_type(pvec_dest, it_end));
/* initialize all elements with default value */
vector_init_n(pvec_dest, iterator_distance(it_begin, it_end));
/* copy values for range */
for(it_dest = vector_begin(pvec_dest), it_src = it_begin;
!iterator_equal(it_dest, vector_end(pvec_dest)) && !iterator_equal(it_src, it_end);
it_dest = iterator_next(it_dest), it_src = iterator_next(it_src))
{
b_result = _GET_VECTOR_TYPE_SIZE(pvec_dest);
_GET_VECTOR_TYPE_COPY_FUNCTION(pvec_dest)(_VECTOR_ITERATOR_COREPOS(it_dest), _VECTOR_ITERATOR_COREPOS(it_src), &b_result);
assert(b_result);
}
assert(iterator_equal(it_dest, vector_end(pvec_dest)) && iterator_equal(it_src, it_end));
}
/**
* Initialize empty vector container.
*/
void vector_init(vector_t* pvec_vector)
{
assert(pvec_vector != NULL);
assert(_vector_is_created(pvec_vector));
vector_init_n(pvec_vector, 0);
}
/**
* Initialize data within range [pby_start, pby_finish) according to vector element data type.
*/
void _vector_init_elem_range_auxiliary(vector_t* pvec_vector, _byte_t* pby_start, _byte_t* pby_finish)
{
_byte_t* pby_pos = NULL;
assert(pvec_vector != NULL);
assert(pby_start != NULL);
assert(pby_finish != NULL);
assert(pby_start <= pby_finish);
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);
for (pby_pos = pby_start; pby_pos < pby_finish; pby_pos += _GET_VECTOR_TYPE_SIZE(pvec_vector)) {
_GET_VECTOR_TYPE_INIT_FUNCTION(pvec_vector)(pby_pos, s_elemtypename);
}
} else {
for (pby_pos = pby_start; pby_pos < pby_finish; pby_pos += _GET_VECTOR_TYPE_SIZE(pvec_vector)) {
bool_t b_result = _GET_VECTOR_TYPE_SIZE(pvec_vector);
_GET_VECTOR_TYPE_INIT_FUNCTION(pvec_vector)(pby_pos, &b_result);
assert(b_result);
}
}
}
/**
* 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));
}
/**
* 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);
}
/**
* 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));
}
/**
* Initialize vector with specified element.
*/
void _vector_init_elem(vector_t* pvec_vector, size_t t_count, ...)
{
va_list val_elemlist;
assert(pvec_vector != NULL);
assert(_vector_is_created(pvec_vector));
va_start(val_elemlist, t_count);
_vector_init_elem_varg(pvec_vector, t_count, val_elemlist);
va_end(val_elemlist);
}
/**
* 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);
}
/**
* Initialize vector container with mutiple default element.
*/
void vector_init_n(vector_t* pvec_vector, size_t t_count)
{
assert(pvec_vector != NULL);
assert(_vector_is_created(pvec_vector));
if(t_count > 0)
{
size_t t_newcapacity = _vector_calculate_new_capacity(0, t_count);
pvec_vector->_pby_start = _alloc_allocate(&pvec_vector->_t_allocator, _GET_VECTOR_TYPE_SIZE(pvec_vector), t_newcapacity);
assert(pvec_vector->_pby_start != NULL);
pvec_vector->_pby_finish = pvec_vector->_pby_start + _GET_VECTOR_TYPE_SIZE(pvec_vector) * t_count;
pvec_vector->_pby_endofstorage = pvec_vector->_pby_start + _GET_VECTOR_TYPE_SIZE(pvec_vector) * t_newcapacity;
/* initialize all elements */
_vector_init_elem_range_auxiliary(pvec_vector, pvec_vector->_pby_start, pvec_vector->_pby_finish);
}
}
/**
* 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);
}
}
/**
* Test hashtable is created by _create_hashtable.
*/
bool_t _hashtable_is_created(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_created(&cpt_hashtable->_vec_bucket)) {
return false;
}
if (cpt_hashtable->_t_nodecount != 0 || cpt_hashtable->_ufun_hash != NULL || cpt_hashtable->_bfun_compare != NULL) {
return false;
}
return _alloc_is_inited(&cpt_hashtable->_t_allocator);
}
