/**
* Initialize data within range [it_begin, it_end) according to deque element data type.
*/
void _deque_init_elem_range_auxiliary(deque_t* pdeq_deque, deque_iterator_t it_begin, deque_iterator_t it_end)
{
deque_iterator_t it_iter;
assert(pdeq_deque != NULL);
assert(_deque_is_inited(pdeq_deque) || _deque_is_created(pdeq_deque));
assert(_deque_iterator_belong_to_deque(_GET_DEQUE_CONTAINER(it_begin), it_begin));
assert(_deque_iterator_belong_to_deque(_GET_DEQUE_CONTAINER(it_end), it_end));
assert(iterator_equal(it_begin, it_end) || _deque_iterator_before(it_begin, it_end));
/* initialize new elements */
if(_GET_DEQUE_TYPE_STYLE(pdeq_deque) == _TYPE_CSTL_BUILTIN)
{
/* get element type name */
char s_elemtypename[_TYPE_NAME_SIZE + 1];
_type_get_elem_typename(_GET_DEQUE_TYPE_NAME(pdeq_deque), s_elemtypename);
for(it_iter = it_begin; !iterator_equal(it_iter, it_end); it_iter = iterator_next(it_iter))
{
_GET_DEQUE_TYPE_INIT_FUNCTION(pdeq_deque)(_deque_iterator_get_pointer_auxiliary(it_iter), s_elemtypename);
}
}
else
{
for(it_iter = it_begin; !iterator_equal(it_iter, it_end); it_iter = iterator_next(it_iter))
{
bool_t t_result = _GET_DEQUE_TYPE_SIZE(pdeq_deque);
_GET_DEQUE_TYPE_INIT_FUNCTION(pdeq_deque)(_deque_iterator_get_pointer_auxiliary(it_iter), &t_result);
assert(t_result);
}
}
}
/**
* 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);
}
}
}
/**
* Initialize pair container.
*/
void pair_init(pair_t* ppair_pair)
{
assert(ppair_pair != NULL);
assert(_pair_is_created(ppair_pair));
if ((ppair_pair->_pv_first = malloc(_GET_PAIR_FIRST_TYPE_SIZE(ppair_pair))) == NULL) {
fprintf(stderr, "CSTL FATAL ERROR: memory allocation error!\n");
exit(EXIT_FAILURE);
} else {
memset(ppair_pair->_pv_first, 0x00, _GET_PAIR_FIRST_TYPE_SIZE(ppair_pair));
}
if ((ppair_pair->_pv_second = malloc(_GET_PAIR_SECOND_TYPE_SIZE(ppair_pair))) == NULL) {
fprintf(stderr, "CSTL FATAL ERROR: memory allocation error!\n");
exit(EXIT_FAILURE);
} else {
memset(ppair_pair->_pv_second, 0x00, _GET_PAIR_SECOND_TYPE_SIZE(ppair_pair));
}
/* initialize new elements */
if (_GET_PAIR_FIRST_TYPE_STYLE(ppair_pair) == _TYPE_CSTL_BUILTIN) {
/* get element type name */
char s_elemtypename[_TYPE_NAME_SIZE + 1];
_type_get_elem_typename(_GET_PAIR_FIRST_TYPE_NAME(ppair_pair), s_elemtypename);
_GET_PAIR_FIRST_TYPE_INIT_FUNCTION(ppair_pair)(ppair_pair->_pv_first, s_elemtypename);
} else {
bool_t b_result = _GET_PAIR_FIRST_TYPE_SIZE(ppair_pair);
_GET_PAIR_FIRST_TYPE_INIT_FUNCTION(ppair_pair)(ppair_pair->_pv_first, &b_result);
assert(b_result);
}
if (_GET_PAIR_SECOND_TYPE_STYLE(ppair_pair) == _TYPE_CSTL_BUILTIN) {
/* get element type name */
char s_elemtypename[_TYPE_NAME_SIZE + 1];
_type_get_elem_typename(_GET_PAIR_SECOND_TYPE_NAME(ppair_pair), s_elemtypename);
_GET_PAIR_SECOND_TYPE_INIT_FUNCTION(ppair_pair)(ppair_pair->_pv_second, s_elemtypename);
} else {
bool_t b_result = _GET_PAIR_SECOND_TYPE_SIZE(ppair_pair);
_GET_PAIR_SECOND_TYPE_INIT_FUNCTION(ppair_pair)(ppair_pair->_pv_second, &b_result);
assert(b_result);
}
}
/**
* Initialize element auxiliary function
*/
void _set_init_elem_auxiliary(set_t* pset_set, void* pv_value)
{
assert(pset_set != NULL);
assert(pv_value != NULL);
/* initialize new elements */
if (_GET_SET_TYPE_STYLE(pset_set) == _TYPE_CSTL_BUILTIN) {
/* get element type name */
char s_elemtypename[_TYPE_NAME_SIZE + 1];
_type_get_elem_typename(_GET_SET_TYPE_NAME(pset_set), s_elemtypename);
_GET_SET_TYPE_INIT_FUNCTION(pset_set)(pv_value, s_elemtypename);
} else {
bool_t b_result = _GET_SET_TYPE_SIZE(pset_set);
_GET_SET_TYPE_INIT_FUNCTION(pset_set)(pv_value, &b_result);
assert(b_result);
}
}
/**
* 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);
}
}
/**
* Initialize element auxiliary function
*/
void _avl_tree_init_elem_auxiliary(_avl_tree_t* pt_avl_tree, _avlnode_t* pt_node)
{
assert(pt_avl_tree != NULL);
assert(pt_node != NULL);
assert(_avl_tree_is_inited(pt_avl_tree) || _avl_tree_is_created(pt_avl_tree));
/* initialize new elements */
if (_GET_AVL_TREE_TYPE_STYLE(pt_avl_tree) == _TYPE_CSTL_BUILTIN) {
/* get element type name */
char s_elemtypename[_TYPE_NAME_SIZE + 1];
_type_get_elem_typename(_GET_AVL_TREE_TYPE_NAME(pt_avl_tree), s_elemtypename);
_GET_AVL_TREE_TYPE_INIT_FUNCTION(pt_avl_tree)(pt_node->_pby_data, s_elemtypename);
} else {
bool_t b_result = _GET_AVL_TREE_TYPE_SIZE(pt_avl_tree);
_GET_AVL_TREE_TYPE_INIT_FUNCTION(pt_avl_tree)(pt_node->_pby_data, &b_result);
assert(b_result);
}
}
/**
* Initialize element auxiliary function
*/
void _hash_multimap_init_elem_auxiliary(hash_multimap_t* phmmap_map, void* pv_elem)
{
assert(phmmap_map != NULL);
assert(pv_elem != NULL);
assert(_pair_is_inited(&phmmap_map->_pair_temp) || _pair_is_created(&phmmap_map->_pair_temp));
/* initialize new elements */
if(phmmap_map->_t_hashtable._t_typeinfo._t_style == _TYPE_CSTL_BUILTIN)
{
/* get element type name */
char s_elemtypename[_TYPE_NAME_SIZE + 1];
_type_get_elem_typename(phmmap_map->_t_hashtable._t_typeinfo._sz_typename, s_elemtypename);
phmmap_map->_t_hashtable._t_typeinfo._pt_type->_t_typeinit(pv_elem, s_elemtypename);
}
else
{
bool_t b_result = phmmap_map->_t_hashtable._t_typeinfo._pt_type->_t_typesize;
phmmap_map->_t_hashtable._t_typeinfo._pt_type->_t_typeinit(pv_elem, &b_result);
assert(b_result);
}
}
/**
* Initialize slist node auxiliary function.
*/
void _slist_init_node_auxiliary(slist_t* pslist_slist, _slistnode_t* pt_node)
{
assert(pslist_slist != NULL);
assert(pt_node != NULL);
assert(_slist_is_inited(pslist_slist) || _slist_is_created(pslist_slist));
/* initialize new elements */
if(_GET_SLIST_TYPE_STYLE(pslist_slist) == _TYPE_CSTL_BUILTIN)
{
/* get element type name */
char s_elemtypename[_TYPE_NAME_SIZE + 1];
_type_get_elem_typename(_GET_SLIST_TYPE_NAME(pslist_slist), s_elemtypename);
_GET_SLIST_TYPE_INIT_FUNCTION(pslist_slist)(pt_node->_pby_data, s_elemtypename);
}
else
{
bool_t b_result = _GET_SLIST_TYPE_SIZE(pslist_slist);
_GET_SLIST_TYPE_INIT_FUNCTION(pslist_slist)(pt_node->_pby_data, &b_result);
assert(b_result);
}
}
void test__type_get_elem_typename__container(void** state)
{
char s_elemtypename[_TYPE_NAME_SIZE + 1] = {'\0'};
_type_get_elem_typename("hash_set_t<vector_t<abc_t>>", s_elemtypename);
assert_true(strncmp(s_elemtypename, "vector_t<abc_t>", _TYPE_NAME_SIZE) == 0);
}
void test__type_get_elem_typename__invliad_typename(void** state)
{
char s_elemtypename[_TYPE_NAME_SIZE + 1] = {'\0'};
expect_assert_failure(_type_get_elem_typename("abc_t", s_elemtypename));
}
void test__type_get_elem_typename__string(void** state)
{
char s_elemtypename[_TYPE_NAME_SIZE + 1] = {'\0'};
_type_get_elem_typename("string_t", s_elemtypename);
assert_true(strncmp(s_elemtypename, "string_t", _TYPE_NAME_SIZE) == 0);
}
void test__type_get_elem_typename__iterator(void** state)
{
char s_elemtypename[_TYPE_NAME_SIZE + 1] = {'\0'};
_type_get_elem_typename("vector_iterator_t", s_elemtypename);
assert_true(strncmp(s_elemtypename, "vector_iterator_t", _TYPE_NAME_SIZE) == 0);
}
void test__type_get_elem_typename__null_elemtypename(void** state)
{
expect_assert_failure(_type_get_elem_typename("iterator_t", NULL));
}
void test__type_get_elem_typename__null_typename(void** state)
{
char s_elemtypename[_TYPE_NAME_SIZE + 1] = {'\0'};
expect_assert_failure(_type_get_elem_typename(NULL, s_elemtypename));
}
