/**
* 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);
}
}
}
/**
* Test the type that saved in the deque container is same.
*/
bool_t _deque_same_type(const deque_t* cpdeq_first, const deque_t* cpdeq_second)
{
assert(cpdeq_first != NULL);
assert(cpdeq_second != NULL);
assert(_deque_is_inited(cpdeq_first) || _deque_is_created(cpdeq_first));
assert(_deque_is_inited(cpdeq_second) || _deque_is_created(cpdeq_second));
if(cpdeq_first == cpdeq_second)
{
return true;
}
return (cpdeq_first->_t_typeinfo._pt_type == cpdeq_second->_t_typeinfo._pt_type) &&
(cpdeq_first->_t_typeinfo._t_style == cpdeq_second->_t_typeinfo._t_style) &&
_type_is_same(_GET_DEQUE_TYPE_NAME(cpdeq_first), _GET_DEQUE_TYPE_NAME(cpdeq_second));
}
/**
* Obtain data from variable argument list, the data type and deque element data type are same.
*/
void _deque_get_varg_value_auxiliary(deque_t* pdeq_deque, va_list val_elemlist, void* pv_varg)
{
assert(pdeq_deque != NULL);
assert(_deque_is_inited(pdeq_deque) || _deque_is_created(pdeq_deque));
_deque_init_elem_auxiliary(pdeq_deque, pv_varg);
_type_get_varg_value(&pdeq_deque->_t_typeinfo, val_elemlist, pv_varg);
}
void test__create_deque__libcstl_builtin_type(void** state)
{
deque_t* pdeq = _create_deque("vector_t < int> ");
assert_true(pdeq != NULL);
assert_true(strcmp(_GET_DEQUE_TYPE_NAME(pdeq), "vector_t<int>") == 0);
assert_true(_deque_is_created(pdeq));
deque_destroy(pdeq);
}
void test__create_deque__c_builtin_type(void** state)
{
deque_t* pdeq = _create_deque("unsigned int");
assert_true(pdeq != NULL);
assert_true(strcmp(_GET_DEQUE_TYPE_NAME(pdeq), "unsigned int") == 0);
assert_true(_deque_is_created(pdeq));
deque_destroy(pdeq);
}
void test__create_deque_auxiliary__libcstl_builtin(void** state)
{
deque_t* pdeq = malloc(sizeof(deque_t));
assert_true(_create_deque_auxiliary(pdeq, "deque_t< vector_t < string_t>> "));
assert_true(strcmp(_GET_DEQUE_TYPE_NAME(pdeq), "deque_t<vector_t<string_t>>") == 0);
assert_true(_alloc_is_inited(&pdeq->_t_allocator));
assert_true(_deque_is_created(pdeq));
deque_destroy(pdeq);
}
void test__create_deque__user_defined_type_dup(void** state)
{
deque_t* pdeq = NULL;
type_duplicate(struct _tag_test__create_deque__user_defined_type, _test__create_deque__user_defined_type_t);
pdeq = _create_deque("_test__create_deque__user_defined_type_t");
assert_true(pdeq != NULL);
assert_true(strcmp(_GET_DEQUE_TYPE_NAME(pdeq), "_test__create_deque__user_defined_type_t") == 0);
assert_true(_deque_is_created(pdeq));
deque_destroy(pdeq);
}
void test__create_deque__user_defined_type(void** state)
{
deque_t* pdeq = NULL;
type_register(struct _tag_test__create_deque__user_defined_type, NULL, NULL, NULL, NULL);
pdeq = _create_deque("struct _tag_test__create_deque__user_defined_type");
assert_true(pdeq != NULL);
assert_true(strcmp(_GET_DEQUE_TYPE_NAME(pdeq), "struct _tag_test__create_deque__user_defined_type") == 0);
assert_true(_deque_is_created(pdeq));
deque_destroy(pdeq);
}
void test__create_deque_auxiliary__user_defined_dup(void** state)
{
deque_t* pdeq = NULL;
type_duplicate(struct _tag_test__create_deque_auxiliary__user_defined, _test__create_deque_auxiliary__user_defined_t);
pdeq = malloc(sizeof(deque_t));
assert_true(_create_deque_auxiliary(pdeq, "_test__create_deque_auxiliary__user_defined_t"));
assert_true(strcmp(_GET_DEQUE_TYPE_NAME(pdeq), "_test__create_deque_auxiliary__user_defined_t") == 0);
assert_true(_alloc_is_inited(&pdeq->_t_allocator));
assert_true(_deque_is_created(pdeq));
deque_destroy(pdeq);
}
/**
* Destroy data, the data type and deque element data type are same.
*/
void _deque_destroy_varg_value_auxiliary(deque_t* pdeq_deque, void* pv_varg)
{
bool_t b_result = false;
assert(pdeq_deque != NULL);
assert(_deque_is_inited(pdeq_deque) || _deque_is_created(pdeq_deque));
/* destroy varg value and free memory */
b_result = _GET_DEQUE_TYPE_SIZE(pdeq_deque);
_GET_DEQUE_TYPE_DESTROY_FUNCTION(pdeq_deque)(pv_varg, &b_result);
assert(b_result);
}
