/**
* 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);
}
}
}
/**
* Return an iterator that addresses the first element in the hashtable.
*/
_hashtable_iterator_t _hashtable_begin(const _hashtable_t* cpt_hashtable)
{
vector_iterator_t it_bucket;
_hashtable_iterator_t it_iter = _create_hashtable_iterator();
assert(cpt_hashtable != NULL);
assert(_hashtable_is_inited(cpt_hashtable));
for(it_bucket = vector_begin(&cpt_hashtable->_vec_bucket);
!iterator_equal(it_bucket, vector_end(&cpt_hashtable->_vec_bucket));
it_bucket = iterator_next(it_bucket))
{
_GET_HASHTABLE_BUCKETPOS(it_iter) = _GET_VECTOR_COREPOS(it_bucket);
if(*(_hashnode_t**)_GET_HASHTABLE_BUCKETPOS(it_iter) != NULL)
{
_GET_HASHTABLE_COREPOS(it_iter) = (_byte_t*)*(_hashnode_t**)_GET_HASHTABLE_BUCKETPOS(it_iter);
break;
}
}
if(iterator_equal(it_bucket, vector_end(&cpt_hashtable->_vec_bucket)))
{
assert(_GET_HASHTABLE_COREPOS(it_iter) == NULL);
_GET_HASHTABLE_BUCKETPOS(it_iter) = _GET_VECTOR_COREPOS(it_bucket);
}
_GET_HASHTABLE_POINTER(it_iter) = (_hashtable_t*)cpt_hashtable;
return it_iter;
}
void test__hash_multiset_equal_range__hash_multiset_equal_range_varg__libcstl_builtin_greater(void** state)
{
hash_multiset_t* pt_hash_multiset = _create_hash_multiset("list_t<int>");
range_t r_range;
list_t* plist = create_list(int);
int i = 0;
hash_multiset_init_ex(pt_hash_multiset, 0, _test__hash_private__libcstl_builtin_hash, NULL);
list_init(plist);
for(i = 0; i < 10; i++)
{
list_clear(plist);
list_push_back(plist, i * 2);
hash_multiset_insert(pt_hash_multiset, plist);
}
list_clear(plist);
list_push_back(plist, 5);
r_range = _hash_multiset_equal_range(pt_hash_multiset, plist);
assert_true(iterator_equal(r_range.it_begin, hash_multiset_end(pt_hash_multiset)));
assert_true(iterator_equal(r_range.it_end, hash_multiset_end(pt_hash_multiset)));
hash_multiset_destroy(pt_hash_multiset);
list_destroy(plist);
}
/**
* 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));
}
/**
* Test the first vector is less than the second vector.
*/
bool_t vector_less(const vector_t* cpvec_first, const vector_t* cpvec_second)
{
bool_t b_result = false;
vector_iterator_t it_first;
vector_iterator_t it_second;
assert(cpvec_first != NULL);
assert(cpvec_second != NULL);
assert(_vector_is_inited(cpvec_first));
assert(_vector_is_inited(cpvec_second));
assert(_vector_same_type(cpvec_first, cpvec_second));
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_result = _GET_VECTOR_TYPE_SIZE(cpvec_first);
_GET_VECTOR_TYPE_LESS_FUNCTION(cpvec_first)(_VECTOR_ITERATOR_COREPOS(it_first), _VECTOR_ITERATOR_COREPOS(it_second), &b_result);
/* if any element in first vector are less then the second return true */
if(b_result)
{
return true;
}
b_result = _GET_VECTOR_TYPE_SIZE(cpvec_first);
_GET_VECTOR_TYPE_LESS_FUNCTION(cpvec_first)(_VECTOR_ITERATOR_COREPOS(it_second), _VECTOR_ITERATOR_COREPOS(it_first), &b_result);
/* if any element in first vector are greater then the second return false */
if(b_result)
{
return false;
}
}
/* if the first n elements in two vector are equal then compare the vector size */
return vector_size(cpvec_first) < vector_size(cpvec_second) ? true : false;
}
/**
* Assign vector element with an exist vector container range.
*/
void vector_assign_range(vector_t* pvec_vector, vector_iterator_t it_begin, vector_iterator_t it_end)
{
iterator_t it_dest;
iterator_t it_src;
bool_t b_result = false;
/* assign the two iterator is as the same type as pvec_vector */
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(_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));
/* copy value from range [it_begin, it_end) for each element */
vector_resize(pvec_vector, iterator_distance(it_begin, it_end));
for(it_dest = vector_begin(pvec_vector), it_src = it_begin;
!iterator_equal(it_dest, vector_end(pvec_vector)) && !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_vector);
_GET_VECTOR_TYPE_COPY_FUNCTION(pvec_vector)(_VECTOR_ITERATOR_COREPOS(it_dest), _VECTOR_ITERATOR_COREPOS(it_src), &b_result);
assert(b_result);
}
assert(iterator_equal(it_dest, vector_end(pvec_vector)) && iterator_equal(it_src, it_end));
}
int test_list(void)
{
int ret = 0;
allocator_t *allocator;
iterator_t it,next;
container_t *ct;
/*
*allocator = allocator_creator(ALLOCATOR_TYPE_SYS_MALLOC);
*/
allocator = allocator_creator(ALLOCATOR_TYPE_CDS_MALLOC);
allocator_cds_init(allocator, 0, 0, 1024);
dbg_str(DBG_CONTAINER_DETAIL,"list allocator addr:%p",allocator);
ct = container_creator(CONTAINER_TYPE_LIST,allocator);
container_list_init(ct,sizeof(struct test));
/*
*container_push_front(ct,&test);
*container_push_front(ct,&test2);
*container_push_front(ct,&test3);
*/
dbg_str(DBG_CONTAINER_DETAIL,"run at here");
container_push_back(ct,&test);
container_push_back(ct,&test2);
container_push_back(ct,&test3);
dbg_str(DBG_CONTAINER_DETAIL,"iter ordinal");
for( it = container_begin(ct);
!iterator_equal(it,container_end(ct));
it = iterator_next(it))
{
print_test((struct test *)iterator_get_pointer(it));
}
dbg_str(DBG_CONTAINER_DETAIL,"iter insert test");
int i = 0;
for( it = container_begin(ct);
!iterator_equal(it,container_end(ct));
it = iterator_next(it),i++)
{
if(i == 1){
break;
}
}
dbg_str(DBG_CONTAINER_DETAIL,"it list_head:%p",it.pos.list_head_p);
container_insert(ct,it,&test4);
dbg_str(DBG_CONTAINER_DETAIL,"iter delte test");
container_for_each_safe(it,next,ct){
//container_delete(ct,it);
print_test((struct test *)iterator_get_pointer(it));
}
/**
* Inserts an range of unique element into a hash_multimap.
*/
void hash_multimap_insert_range(hash_multimap_t* phmmap_map, iterator_t it_begin, iterator_t it_end)
{
iterator_t it_iter;
assert(phmmap_map != NULL);
assert(_pair_is_inited(&phmmap_map->_pair_temp));
assert(iterator_equal(it_begin, it_end) || _iterator_before(it_begin, it_end));
for (it_iter = it_begin; !iterator_equal(it_iter, it_end); it_iter = iterator_next(it_iter)) {
assert(_hash_multimap_same_pair_type(&phmmap_map->_pair_temp, (pair_t*)iterator_get_pointer(it_iter)));
hash_multimap_insert(phmmap_map, (pair_t*)iterator_get_pointer(it_iter));
}
}
/**
* Inserts an range into a hashtable.
*/
void _hashtable_insert_equal_range(_hashtable_t* pt_hashtable, iterator_t it_begin, iterator_t it_end)
{
iterator_t it_iter;
assert(pt_hashtable != NULL);
assert(_hashtable_is_inited(pt_hashtable));
assert(_hashtable_same_iterator_type(pt_hashtable, it_begin));
assert(_hashtable_same_iterator_type(pt_hashtable, it_end));
assert(iterator_equal(it_begin, it_end) || _iterator_before(it_begin, it_end));
for (it_iter = it_begin; !iterator_equal(it_iter, it_end); it_iter = iterator_next(it_iter)) {
_hashtable_insert_equal(pt_hashtable, _iterator_get_pointer_ignore_cstr(it_iter));
}
}
/**
* Inserts an range of unique element into a avl tree.
*/
void _avl_tree_insert_unique_range(_avl_tree_t* pt_avl_tree, iterator_t it_begin, iterator_t it_end)
{
iterator_t it_iter;
assert(pt_avl_tree != NULL);
assert(_avl_tree_is_inited(pt_avl_tree));
assert(_avl_tree_same_iterator_type(pt_avl_tree, it_begin));
assert(_avl_tree_same_iterator_type(pt_avl_tree, it_end));
assert(iterator_equal(it_begin, it_end) || _iterator_before(it_begin, it_end));
for (it_iter = it_begin; !iterator_equal(it_iter, it_end); it_iter = iterator_next(it_iter)) {
_avl_tree_insert_unique(pt_avl_tree, _iterator_get_pointer_ignore_cstr(it_iter));
}
}
/**
* Shrink deque at begin.
*/
void _deque_shrink_at_begin(deque_t* pdeq_deque, size_t t_shrinksize)
{
deque_iterator_t it_oldbegin;
deque_iterator_t it_newbegin;
deque_iterator_t it_iter;
_mappointer_t ppby_map = NULL;
bool_t b_result = false;
assert(pdeq_deque != NULL);
assert(_deque_is_inited(pdeq_deque));
it_oldbegin = deque_begin(pdeq_deque);
t_shrinksize = t_shrinksize < deque_size(pdeq_deque) ? t_shrinksize : deque_size(pdeq_deque);
it_newbegin = iterator_next_n(deque_begin(pdeq_deque), t_shrinksize);
assert(_deque_iterator_belong_to_deque(pdeq_deque, it_newbegin));
/* destroy all elements */
for(it_iter = it_oldbegin; !iterator_equal(it_iter, it_newbegin); it_iter = iterator_next(it_iter))
{
b_result = _GET_DEQUE_TYPE_SIZE(pdeq_deque);
_GET_DEQUE_TYPE_DESTROY_FUNCTION(pdeq_deque)(_deque_iterator_get_pointer_auxiliary(it_iter), &b_result);
assert(b_result);
}
pdeq_deque->_t_start = it_newbegin;
for(ppby_map = _GET_DEQUE_MAP_POINTER(pdeq_deque->_t_start) - 1; ppby_map >= _GET_DEQUE_MAP_POINTER(it_oldbegin); --ppby_map)
{
_alloc_deallocate(&pdeq_deque->_t_allocator, *ppby_map, _GET_DEQUE_TYPE_SIZE(pdeq_deque), _DEQUE_ELEM_COUNT);
*ppby_map = NULL;
}
}
void test__hash_multiset_find__hash_multiset_find_varg__libcstl_builtin_not_find(void** state)
{
hash_multiset_t* pt_hash_multiset = _create_hash_multiset("list_t<int>");
hash_multiset_iterator_t it_iter;
list_t* plist = create_list(int);
int i = 0;
hash_multiset_init_ex(pt_hash_multiset, 0, _test__hash_private__libcstl_builtin_hash, NULL);
list_init(plist);
for(i = 0; i < 10; i++)
{
list_clear(plist);
list_push_back(plist, i);
hash_multiset_insert(pt_hash_multiset, plist);
}
list_clear(plist);
list_push_back(plist, 96);
it_iter = _hash_multiset_find(pt_hash_multiset, plist);
assert_true(iterator_equal(it_iter, hash_multiset_end(pt_hash_multiset)));
hash_multiset_destroy(pt_hash_multiset);
list_destroy(plist);
}
/**
* Get data value pointer referenced by iterator, but ignore char*.
*/
const void* _slist_iterator_get_pointer_ignore_cstr(slist_iterator_t it_iter)
{
assert(_slist_iterator_belong_to_slist(_SLIST_ITERATOR_CONTAINER(it_iter), it_iter));
assert(!iterator_equal(it_iter, slist_end(_SLIST_ITERATOR_CONTAINER(it_iter))));
return ((_slistnode_t*)_SLIST_ITERATOR_COREPOS(it_iter))->_pby_data;
}
/**
* 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;
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 */
for(it_iter = vector_begin(pvec_vector);
!iterator_equal(it_iter, vector_end(pvec_vector));
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);
}
}
/**
* Assign vector with variable argument list of specificed element.
*/
void _vector_assign_elem_varg(vector_t* pvec_vector, size_t t_count, va_list val_elemlist)
{
iterator_t it_iter;
iterator_t it_begin;
iterator_t it_end;
bool_t b_result = false;
void* pv_varg = NULL;
assert(pvec_vector != NULL);
assert(_vector_is_inited(pvec_vector));
/* get value from varg */
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 from varg for each element */
vector_resize(pvec_vector, t_count);
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_COPY_FUNCTION(pvec_vector)(_VECTOR_ITERATOR_COREPOS(it_iter), 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);
}
/**
* 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;
}
/**
* Append specific range to destination string.
*/
void string_append_range(string_t* pstr_string, string_iterator_t it_begin, string_iterator_t it_end)
{
assert(!iterator_equal(it_end, basic_string_end(_BASIC_STRING_ITERATOR_CONTAINER(it_end))));
_basic_string_pop_back(pstr_string);
basic_string_append_range(pstr_string, it_begin, it_end);
basic_string_push_back(pstr_string, '\0');
}
/**
* Inserts an range of unique element into a hash_set.
*/
void hash_set_insert_range(hash_set_t* phset_set, iterator_t it_begin, iterator_t it_end)
{
assert(phset_set != NULL);
assert(iterator_equal(it_begin, it_end) || _iterator_before(it_begin, it_end));
_hashtable_insert_unique_range(&phset_set->_t_hashtable, it_begin, it_end);
}
/**
* Remove element that specificed by variable argument slist from slist container.
*/
void _slist_remove_varg(slist_t* pslist_slist, va_list val_elemlist)
{
slist_iterator_t it_iter; /* for iterate */
_slistnode_t* pt_varg = NULL;
bool_t b_less = false;
bool_t b_greater = false;
/* test the pointer is valid */
assert(pslist_slist != NULL);
assert(_slist_is_inited(pslist_slist));
pt_varg = _alloc_allocate(&pslist_slist->_t_allocator, _SLIST_NODE_SIZE(_GET_SLIST_TYPE_SIZE(pslist_slist)), 1);
assert(pt_varg != NULL);
_slist_get_varg_value_auxiliary(pslist_slist, val_elemlist, pt_varg);
it_iter = slist_begin(pslist_slist);
while (!iterator_equal(it_iter, slist_end(pslist_slist))) {
b_less = b_greater = _GET_SLIST_TYPE_SIZE(pslist_slist);
_GET_SLIST_TYPE_LESS_FUNCTION(pslist_slist)(
pt_varg->_pby_data, ((_slistnode_t*)_SLIST_ITERATOR_COREPOS(it_iter))->_pby_data, &b_less);
_GET_SLIST_TYPE_LESS_FUNCTION(pslist_slist)(
((_slistnode_t*)_SLIST_ITERATOR_COREPOS(it_iter))->_pby_data, pt_varg->_pby_data, &b_greater);
if (b_less || b_greater) {
it_iter = iterator_next(it_iter);
} else {
it_iter = slist_erase(pslist_slist, it_iter);
}
}
_slist_destroy_varg_value_auxiliary(pslist_slist, pt_varg);
_alloc_deallocate(&pslist_slist->_t_allocator, pt_varg, _SLIST_NODE_SIZE(_GET_SLIST_TYPE_SIZE(pslist_slist)), 1);
}
/**
* Insert multiple copys of element befor specificed position.
*/
void _slist_insert_n(slist_t* pslist_slist, slist_iterator_t it_pos, size_t t_count, ...)
{
va_list val_elemlist;
/* test the slist pointer and pos is valid */
assert(pslist_slist != NULL);
assert(_slist_is_inited(pslist_slist));
assert(_slist_iterator_belong_to_slist(pslist_slist, it_pos));
/* if the pos is slist begin */
va_start(val_elemlist, t_count);
if (iterator_equal(it_pos, slist_begin(pslist_slist))) {
size_t i = 0;
/* call slist push front t_count times */
for (i = 0; i < t_count; ++i) {
va_list val_elemlist_copy;
va_copy(val_elemlist_copy, val_elemlist);
_slist_push_front_varg(pslist_slist, val_elemlist_copy);
va_end(val_elemlist_copy);
}
} else {
_slist_insert_after_n_varg(pslist_slist, slist_previous(pslist_slist, it_pos), t_count, val_elemlist);
}
va_end(val_elemlist);
}
/**
* Assign slist with variable argument of specificed element.
*/
void _slist_assign_elem_varg(slist_t* pslist_slist, size_t t_count, va_list val_elemlist)
{
slist_iterator_t it_iter;
_slistnode_t* pt_varg = NULL;
bool_t b_result = false;
assert(pslist_slist != NULL);
assert(_slist_is_inited(pslist_slist));
slist_resize(pslist_slist, t_count);
/* get varg value */
pt_varg = _alloc_allocate(&pslist_slist->_t_allocator, _SLIST_NODE_SIZE(_GET_SLIST_TYPE_SIZE(pslist_slist)), 1);
assert(pt_varg != NULL);
_slist_get_varg_value_auxiliary(pslist_slist, val_elemlist, pt_varg);
/* copy value from varg */
for (it_iter = slist_begin(pslist_slist);
!iterator_equal(it_iter, slist_end(pslist_slist));
it_iter = iterator_next(it_iter)) {
b_result = _GET_SLIST_TYPE_SIZE(pslist_slist);
_GET_SLIST_TYPE_COPY_FUNCTION(pslist_slist)(
((_slistnode_t*)_SLIST_ITERATOR_COREPOS(it_iter))->_pby_data, pt_varg->_pby_data, &b_result);
assert(b_result);
}
/* destroy varg value */
_slist_destroy_varg_value_auxiliary(pslist_slist, pt_varg);
_alloc_deallocate(&pslist_slist->_t_allocator, pt_varg, _SLIST_NODE_SIZE(_GET_SLIST_TYPE_SIZE(pslist_slist)), 1);
}
/**
* 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;
}
/**
* Initialize hash_set container with specific range and compare function.
*/
void hash_set_init_copy_range_ex(hash_set_t* phset_set, iterator_t it_begin, iterator_t it_end,
size_t t_bucketcount, unary_function_t ufun_hash, binary_function_t bfun_compare)
{
assert(phset_set != NULL);
assert(iterator_equal(it_begin, it_end) || _iterator_before(it_begin, it_end));
_hashtable_init_copy_unique_range(&phset_set->_t_hashtable, it_begin, it_end, t_bucketcount, ufun_hash, bfun_compare);
}
/**
* Test first iterator is greater than or equal to second iterator.
*/
bool_t iterator_greater_equal(iterator_t it_first, iterator_t it_second)
{
if (iterator_greater(it_first, it_second) || iterator_equal(it_first, it_second)) {
return true;
} else {
return false;
}
}
/**
* Transfer the range [it_begin, it_end) to position it_pos+1.
*/
void _slist_transfer_after(slist_iterator_t it_pos, slist_iterator_t it_begin, slist_iterator_t it_end)
{
assert(_slist_iterator_belong_to_slist(_SLIST_ITERATOR_CONTAINER(it_pos), it_pos));
assert(!iterator_equal(it_pos, slist_end(_SLIST_ITERATOR_CONTAINER(it_pos))));
assert(_slist_iterator_belong_to_slist(_SLIST_ITERATOR_CONTAINER(it_begin), it_begin));
assert(_slist_iterator_belong_to_slist(_SLIST_ITERATOR_CONTAINER(it_end), it_end));
assert(_SLIST_ITERATOR_CONTAINER(it_begin) == _SLIST_ITERATOR_CONTAINER(it_end));
assert(iterator_equal(it_begin, it_end) || _slist_iterator_before(it_begin, it_end));
assert(_slist_same_slist_iterator_type(_SLIST_ITERATOR_CONTAINER(it_pos), it_begin));
/* empty range */
if(iterator_equal(it_begin, it_end))
{
return;
}
/* same slist container */
if(_SLIST_ITERATOR_CONTAINER(it_pos) == _SLIST_ITERATOR_CONTAINER(it_begin))
{
iterator_t it_iter = iterator_next(it_pos);
assert(iterator_equal(it_iter, it_begin) || iterator_equal(it_iter, it_end) ||
_slist_iterator_before(it_iter, it_begin) || _slist_iterator_before(it_end, it_iter));
if(iterator_equal(it_iter, it_begin) || iterator_equal(it_iter, it_end))
{
return;
}
}
slist_insert_after_range(_SLIST_ITERATOR_CONTAINER(it_pos), it_pos, it_begin, it_end);
slist_erase_range(_SLIST_ITERATOR_CONTAINER(it_begin), it_begin, it_end);
}
/**
* Return iterator reference next element.
*/
slist_iterator_t _slist_iterator_next(slist_iterator_t it_iter)
{
assert(_slist_iterator_belong_to_slist(_SLIST_ITERATOR_CONTAINER(it_iter), it_iter));
assert(!iterator_equal(it_iter, slist_end(_SLIST_ITERATOR_CONTAINER(it_iter))));
_SLIST_ITERATOR_COREPOS(it_iter) = (_byte_t*)(((_slistnode_t*)_SLIST_ITERATOR_COREPOS(it_iter))->_pt_next);
return it_iter;
}
/**
* 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));
}
cstl_iterator forward_list_erase_after_range(cstl_forward_list *cfl, cstl_iterator beging, cstl_iterator end)
{
while (!iterator_equal(beging, end))
{
beging = forward_list_erase_after(cfl, beging);
}
return beging;
}
void test__hash_multiset_equal_range__hash_multiset_equal_range_varg__cstr_greater(void** state)
{
hash_multiset_t* pt_hash_multiset = _create_hash_multiset("char*");
range_t r_range;
hash_multiset_init(pt_hash_multiset);
hash_multiset_insert(pt_hash_multiset, "aaa");
hash_multiset_insert(pt_hash_multiset, "ggg");
hash_multiset_insert(pt_hash_multiset, "nghl");
hash_multiset_insert(pt_hash_multiset, "asery");
hash_multiset_insert(pt_hash_multiset, "linux");
r_range = _hash_multiset_equal_range(pt_hash_multiset, "vvvv");
assert_true(iterator_equal(r_range.it_begin, hash_multiset_end(pt_hash_multiset)));
assert_true(iterator_equal(r_range.it_end, hash_multiset_end(pt_hash_multiset)));
hash_multiset_destroy(pt_hash_multiset);
}
/**
* Initialize string container with an exist string range.
*/
void string_init_copy_range(string_t* pstr_string, string_iterator_t it_begin, string_iterator_t it_end)
{
assert(pstr_string != NULL);
basic_string_init_copy_range(pstr_string, it_begin, it_end);
if(!iterator_equal(it_end, basic_string_end(_BASIC_STRING_ITERATOR_CONTAINER(it_end))))
{
basic_string_push_back(pstr_string, '\0');
}
}
