void test__hash_multiset_equal_range__hash_multiset_equal_range_varg__libcstl_builtin_equal(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);
hash_multiset_insert(pt_hash_multiset, plist);
}
list_clear(plist);
list_push_back(plist, 6);
r_range = _hash_multiset_equal_range(pt_hash_multiset, plist);
assert_true(*(int*)list_front((list_t*)iterator_get_pointer(r_range.it_begin)) == 6);
assert_true(*(int*)list_front((list_t*)iterator_get_pointer(r_range.it_end)) == 7);
hash_multiset_destroy(pt_hash_multiset);
list_destroy(plist);
}
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));
}
}
void test__slist_iterator_next__successfully(void** state)
{
slist_iterator_t it_iter;
slist_t* pslist = create_slist(int);
slist_init_elem(pslist, 1, 100);
slist_push_front(pslist, 200);
it_iter = slist_begin(pslist);
assert_true(*(int*)iterator_get_pointer(it_iter) == 200);
it_iter = _slist_iterator_next(it_iter);
assert_true(*(int*)iterator_get_pointer(it_iter) == 100);
slist_destroy(pslist);
}
/**
* Finds the position of the first element in an ordered range that has a value greater than or equivalent to a specified value,
* where the ordering criterion may be specified by a binary predicate.
*/
forward_iterator_t _algo_lower_bound_if_varg(forward_iterator_t it_first, forward_iterator_t it_last, bfun_t bfun_op, va_list val_elemlist)
{
void* pv_value = NULL;
bool_t b_result = false;
size_t t_len = 0;
size_t t_halflen = 0;
iterator_t it_middle;
assert(_iterator_valid_range(it_first, it_last, _FORWARD_ITERATOR));
if (bfun_op == NULL) {
bfun_op = _fun_get_binary(it_first, _LESS_FUN);
}
pv_value = _iterator_allocate_init_elem(it_first);
_type_get_varg_value(_iterator_get_typeinfo(it_first), val_elemlist, pv_value);
if (strncmp(_iterator_get_typebasename(it_first), _C_STRING_TYPE, _TYPE_NAME_SIZE) == 0) {
t_len = iterator_distance(it_first, it_last);
while (t_len > 0) {
t_halflen = t_len >> 1;
it_middle = iterator_advance(it_first, t_halflen);
(*bfun_op)(iterator_get_pointer(it_middle), string_c_str((string_t*)pv_value), &b_result);
if (b_result) { /* *it_middle < value */
it_first = iterator_next(it_middle);
t_len = t_len - t_halflen - 1;
} else {
t_len = t_halflen;
}
}
} else {
void test__hash_multiset_find__hash_multiset_find_varg__libcstl_builtin_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, 6);
it_iter = _hash_multiset_find(pt_hash_multiset, plist);
assert_true(*(int*)list_front((list_t*)iterator_get_pointer(it_iter)) == 6);
hash_multiset_destroy(pt_hash_multiset);
list_destroy(plist);
}
/**
* 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));
}
static void _test__hash_private__libcstl_builtin_hash(const void* cpv_input, void* pv_output)
{
list_t* plist = (list_t*)cpv_input;
list_iterator_t it_iter;
*(size_t*)pv_output = 0;
for(it_iter = list_begin(plist); !iterator_equal(it_iter, list_end(plist)); it_iter = iterator_next(it_iter))
{
*(size_t*)pv_output += *(int*)iterator_get_pointer(it_iter);
}
}
void test__hash_multiset_equal_range__hash_multiset_equal_range_varg__c_builtin_equal(void** state)
{
hash_multiset_t* pt_hash_multiset = _create_hash_multiset("int");
range_t r_range;
int elem;
int i;
hash_multiset_init(pt_hash_multiset);
for(i = 0; i < 10; ++i)
{
hash_multiset_insert(pt_hash_multiset, i);
}
elem = 2;
r_range = _hash_multiset_equal_range(pt_hash_multiset, elem);
assert_true(*(int*)iterator_get_pointer(r_range.it_begin) == 2);
assert_true(*(int*)iterator_get_pointer(r_range.it_end) == 3);
hash_multiset_destroy(pt_hash_multiset);
}
int test_container_list(void)
{
int ret = 0;
allocator_t *allocator;
iterator_t it,next,end;
container_t *ct;
allocator = allocator_creator(ALLOCATOR_TYPE_SYS_MALLOC,0);
/*
*allocator = allocator_creator(ALLOCATOR_TYPE_CTR_MALLOC,0);
*allocator_ctr_init(allocator, 0, 0, 1024);
*/
dbg_str(DBG_CONTAINER_DETAIL,"list allocator addr:%p",allocator);
ct = container_creator(CONTAINER_TYPE_LIST,allocator,0);
container_init(ct,sizeof(struct test));
/*
*container_push_front(ct,&test);
*container_push_front(ct,&test2);
*container_push_front(ct,&test3);
*/
container_push_back(ct,&test);
container_push_back(ct,&test2);
container_push_back(ct,&test3);
dbg_str(DBG_CONTAINER_DETAIL,"iter ordinal");
for( container_begin(ct,&it),iterator_next(&it,&next);
!iterator_equal(&it,container_end(ct,&end));
it= next,iterator_next(&it,&next))
{
print_test((struct test *)iterator_get_pointer(&it));
}
container_insert(ct,&it,&test4);
dbg_str(DBG_CONTAINER_DETAIL,"iter delte test");
container_for_each_safe(it,next,ct){
print_test((struct test *)iterator_get_pointer(&it));
}
/**
* Access an element with specific index.
*/
void* _map_at_varg(map_t* pmap_map, va_list val_elemlist)
{
map_iterator_t it_iter;
va_list val_elemlist_copy;
assert(pmap_map != NULL);
assert(_pair_is_inited(&pmap_map->_pair_temp));
va_copy(val_elemlist_copy, val_elemlist);
_type_get_varg_value(&pmap_map->_pair_temp._t_typeinfofirst, val_elemlist, pmap_map->_pair_temp._pv_first);
#ifdef CSTL_MAP_AVL_TREE
it_iter = _avl_tree_insert_unique(&pmap_map->_t_tree, &pmap_map->_pair_temp);
#else
it_iter = _rb_tree_insert_unique(&pmap_map->_t_tree, &pmap_map->_pair_temp);
#endif
_ITERATOR_CONTAINER(it_iter) = pmap_map;
_MAP_ITERATOR_CONTAINER_TYPE(it_iter) = _MAP_CONTAINER;
_MAP_ITERATOR_ITERATOR_TYPE(it_iter) = _BIDIRECTIONAL_ITERATOR;
if(iterator_equal(it_iter, map_end(pmap_map)))
{
it_iter = _map_find_varg(pmap_map, val_elemlist_copy);
}
va_end(val_elemlist_copy);
/* char* */
if(strncmp(_GET_MAP_SECOND_TYPE_BASENAME(pmap_map), _C_STRING_TYPE, _TYPE_NAME_SIZE) == 0)
{
return (char*)string_c_str((string_t*)((pair_t*)iterator_get_pointer(it_iter))->_pv_second);
}
else
{
return ((pair_t*)iterator_get_pointer(it_iter))->_pv_second;
}
}
/**
* Return the median of three random_access_iterator_t
*/
random_access_iterator_t _algo_median_of_three_if(
random_access_iterator_t it_first, random_access_iterator_t it_middle, random_access_iterator_t it_last, bfun_t bfun_op)
{
bool_t b_result = false;
assert(_iterator_valid_range(it_first, it_middle, _RANDOM_ACCESS_ITERATOR));
assert(_iterator_valid_range(it_middle, it_last, _RANDOM_ACCESS_ITERATOR));
assert(bfun_op != NULL);
(*bfun_op)(iterator_get_pointer(it_first), iterator_get_pointer(it_middle), &b_result);
if (b_result) { /* it_first < it_middle */
(*bfun_op)(iterator_get_pointer(it_middle), iterator_get_pointer(it_last), &b_result);
if (b_result){ /* it_first < it_middle < it_last */
return it_middle;
} else { /* it_last <= it_middle */
(*bfun_op)(iterator_get_pointer(it_first), iterator_get_pointer(it_last), &b_result);
if (b_result) { /* it_first < it_last <= it_middle */
return it_last;
}else { /* it_last <= it_first <= it_middle */
return it_first;
}
}
} else { /* it_middle <= it_first */
(*bfun_op)(iterator_get_pointer(it_first), iterator_get_pointer(it_last), &b_result);
if (b_result) { /* it_middle <= it_first < it_last */
return it_first;
} else { /* it_last <= it_first */
(*bfun_op)(iterator_get_pointer(it_middle), iterator_get_pointer(it_last), &b_result);
if (b_result) { /* it_middle < it_last <= it_first */
return it_last;
} else { /* it_last <= it_middle <= it_first */
return it_middle;
}
}
}
}
void test__hash_multiset_find__hash_multiset_find_varg__cstr_find(void** state)
{
hash_multiset_t* pt_hash_multiset = _create_hash_multiset("char*");
hash_multiset_iterator_t it_iter;
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");
it_iter = hash_multiset_find(pt_hash_multiset, "ggg");
assert_true(strcmp((char*)iterator_get_pointer(it_iter), "ggg") == 0);
hash_multiset_destroy(pt_hash_multiset);
}
void test__hash_multiset_equal_range__hash_multiset_equal_range_varg__cstr_upper_equal(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, "ggg");
assert_true(strcmp((char*)iterator_get_pointer(r_range.it_begin), "ggg") == 0);
assert_true(iterator_equal(r_range.it_end, hash_multiset_end(pt_hash_multiset)));
hash_multiset_destroy(pt_hash_multiset);
}
void test__hash_multiset_find__hash_multiset_find_varg__c_builtin_find(void** state)
{
hash_multiset_t* pt_hash_multiset = _create_hash_multiset("int");
hash_multiset_iterator_t it_iter;
int elem;
int i;
hash_multiset_init(pt_hash_multiset);
for(i = 0; i < 10; ++i)
{
hash_multiset_insert(pt_hash_multiset, i);
}
elem = 2;
it_iter = _hash_multiset_find(pt_hash_multiset, elem);
assert_true(*(int*)iterator_get_pointer(it_iter) == 2);
hash_multiset_destroy(pt_hash_multiset);
}
/**
* Inserts an range of unique element into a map.
*/
void map_insert_range(map_t* pmap_map, map_iterator_t it_begin, map_iterator_t it_end)
{
map_iterator_t it_iter;
assert(pmap_map != NULL);
assert(_pair_is_inited(&pmap_map->_pair_temp));
assert(_GET_MAP_CONTAINER_TYPE(it_begin) == _MAP_CONTAINER);
assert(_GET_MAP_ITERATOR_TYPE(it_begin) == _BIDIRECTIONAL_ITERATOR);
assert(_GET_MAP_CONTAINER_TYPE(it_end) == _MAP_CONTAINER);
assert(_GET_MAP_ITERATOR_TYPE(it_end) == _BIDIRECTIONAL_ITERATOR);
assert(_GET_MAP_CONTAINER(it_begin) != pmap_map);
assert(_GET_MAP_CONTAINER(it_end) != pmap_map);
assert(_GET_MAP_CONTAINER(it_begin) == _GET_MAP_CONTAINER(it_end));
assert(_map_same_pair_type(&pmap_map->_pair_temp, &_GET_MAP_CONTAINER(it_begin)->_pair_temp));
for(it_iter = it_begin; !iterator_equal(it_iter, it_end); it_iter = iterator_next(it_iter))
{
map_insert(pmap_map, (pair_t*)iterator_get_pointer(it_iter));
}
}
/**
* Inserts an range of unique element into a hash_multimap.
*/
void hash_multimap_insert_range(hash_multimap_t* phmmap_map, hash_multimap_iterator_t it_begin, hash_multimap_iterator_t it_end)
{
hash_multimap_iterator_t it_iter;
assert(phmmap_map != NULL);
assert(_pair_is_inited(&phmmap_map->_pair_temp));
assert(_GET_HASH_MULTIMAP_CONTAINER_TYPE(it_begin) == _HASH_MULTIMAP_CONTAINER);
assert(_GET_HASH_MULTIMAP_ITERATOR_TYPE(it_begin) == _BIDIRECTIONAL_ITERATOR);
assert(_GET_HASH_MULTIMAP_CONTAINER_TYPE(it_end) == _HASH_MULTIMAP_CONTAINER);
assert(_GET_HASH_MULTIMAP_ITERATOR_TYPE(it_end) == _BIDIRECTIONAL_ITERATOR);
assert(_GET_HASH_MULTIMAP_CONTAINER(it_begin) != phmmap_map);
assert(_GET_HASH_MULTIMAP_CONTAINER(it_end) != phmmap_map);
assert(_GET_HASH_MULTIMAP_CONTAINER(it_begin) == _GET_HASH_MULTIMAP_CONTAINER(it_end));
assert(_hash_multimap_same_pair_type(&phmmap_map->_pair_temp, &_GET_HASH_MULTIMAP_CONTAINER(it_begin)->_pair_temp));
for(it_iter = it_begin; !iterator_equal(it_iter, it_end); it_iter = iterator_next(it_iter))
{
hash_multimap_insert(phmmap_map, (pair_t*)iterator_get_pointer(it_iter));
}
}
int main(int argc, char* argv[])
{
string_t* pstr_hello = create_string();
string_t* pstr_s = create_string();
string_iterator_t it_pos;
if(pstr_hello == NULL || pstr_s == NULL)
{
return -1;
}
string_init_cstr(pstr_hello, "Hello, how are you?");
string_init_copy_range(pstr_s,
string_begin(pstr_hello), string_end(pstr_hello));
for(it_pos = string_begin(pstr_s);
!iterator_equal(it_pos, string_end(pstr_s));
it_pos = iterator_next(it_pos))
{
printf("%c", *(char*)iterator_get_pointer(it_pos));
}
printf("\n");
algo_reverse(string_begin(pstr_s), string_end(pstr_s));
printf("reverse: %s\n", string_c_str(pstr_s));
algo_sort(string_begin(pstr_s), string_end(pstr_s));
printf("ordered: %s\n", string_c_str(pstr_s));
string_erase_range(pstr_s,
algo_unique(string_begin(pstr_s), string_end(pstr_s)),
string_end(pstr_s));
printf("uniqued: %s\n", string_c_str(pstr_s));
string_destroy(pstr_hello);
string_destroy(pstr_s);
return 0;
}
void map_insert_range(
map_t* pt_map, map_iterator_t t_begin, map_iterator_t t_end)
{
map_iterator_t t_iterator;
assert(pt_map != NULL);
assert(
_GET_MAP_CONTAINER_TYPE(&t_begin) == _MAP_CONTAINER &&
_GET_MAP_ITERATOR_TYPE(&t_begin) == _BIDIRECTIONAL_ITERATOR &&
_GET_MAP_CONTAINER_TYPE(&t_end) == _MAP_CONTAINER &&
_GET_MAP_ITERATOR_TYPE(&t_end) == _BIDIRECTIONAL_ITERATOR);
assert(
_GET_MAP_CONTAINER(&t_begin) != pt_map &&
_GET_MAP_CONTAINER(&t_end) != pt_map &&
_GET_MAP_CONTAINER(&t_begin) == _GET_MAP_CONTAINER(&t_end));
for(t_iterator = t_begin;
!iterator_equal(&t_iterator, t_end);
iterator_next(&t_iterator))
{
map_insert(pt_map, (pair_t*)iterator_get_pointer(&t_iterator));
}
}
void test__hash_multiset_find__hash_multiset_find_varg__user_define_find(void** state)
{
hash_multiset_t* pt_hash_multiset = NULL;
hash_multiset_iterator_t it_iter;
_test__hash_multiset_find__hash_multiset_find_varg__user_define_t elem;
int i = 0;
type_register(_test__hash_multiset_find__hash_multiset_find_varg__user_define_t, NULL, NULL, NULL, NULL);
pt_hash_multiset = _create_hash_multiset("_test__hash_multiset_find__hash_multiset_find_varg__user_define_t");
hash_multiset_init(pt_hash_multiset);
for(i = 0; i < 10; ++i)
{
elem.n_elem = i;
hash_multiset_insert(pt_hash_multiset, &elem);
}
elem.n_elem = 8;
it_iter = _hash_multiset_find(pt_hash_multiset, &elem);
assert_true(((_test__hash_multiset_find__hash_multiset_find_varg__user_define_t*)iterator_get_pointer(it_iter))->n_elem == 8);
hash_multiset_destroy(pt_hash_multiset);
}
int main(int argc, char* argv[])
{
list_t* pt_list = create_list(vector_t<int>);
vector_t* pt_vec = create_vector(int);
iterator_t t_it_list;
iterator_t t_it_vec;
size_t t_i = 0;
size_t t_j = 0;
size_t t_count = 0;
if(pt_list == NULL || pt_vec == NULL)
{
return -1;
}
list_init(pt_list);
vector_init(pt_vec);
srand((unsigned)time(NULL));
for(t_i = 0; t_i < 10; ++t_i)
{
t_count = rand() % 10;
vector_clear(pt_vec);
for(t_j = 0; t_j < t_count; ++t_j)
{
vector_push_back(pt_vec, rand() - rand());
}
list_push_back(pt_list, pt_vec);
}
printf("before sorting:\n");
for(t_it_list = list_begin(pt_list);
!iterator_equal(t_it_list, list_end(pt_list));
t_it_list = iterator_next(t_it_list))
{
for(t_it_vec = vector_begin(iterator_get_pointer(t_it_list));
!iterator_equal(t_it_vec, vector_end(iterator_get_pointer(t_it_list)));
t_it_vec = iterator_next(t_it_vec))
{
printf("%d, ", *(int*)iterator_get_pointer(t_it_vec));
}
printf("\n");
}
printf("\n");
list_sort(pt_list);
printf("before sorting:\n");
for(t_it_list = list_begin(pt_list);
!iterator_equal(t_it_list, list_end(pt_list));
t_it_list = iterator_next(t_it_list))
{
for(t_it_vec = vector_begin(iterator_get_pointer(t_it_list));
!iterator_equal(t_it_vec, vector_end(iterator_get_pointer(t_it_list)));
t_it_vec = iterator_next(t_it_vec))
{
printf("%d, ", *(int*)iterator_get_pointer(t_it_vec));
}
printf("\n");
}
printf("\n");
list_destroy(pt_list);
vector_destroy(pt_vec);
return 0;
}
void test__hash_multiset_equal_range__hash_multiset_equal_range_varg__user_define_equal(void** state)
{
hash_multiset_t* pt_hash_multiset = NULL;
range_t r_range;
_test__hash_multiset_equal_range__hash_multiset_equal_range_varg__user_define_t elem;
int i = 0;
type_register(_test__hash_multiset_equal_range__hash_multiset_equal_range_varg__user_define_t, NULL, NULL, NULL, NULL);
pt_hash_multiset = _create_hash_multiset("_test__hash_multiset_equal_range__hash_multiset_equal_range_varg__user_define_t");
hash_multiset_init(pt_hash_multiset);
for(i = 0; i < 10; ++i)
{
elem.n_elem = i;
hash_multiset_insert(pt_hash_multiset, &elem);
}
elem.n_elem = 8;
r_range = _hash_multiset_equal_range(pt_hash_multiset, &elem);
assert_true(((_test__hash_multiset_equal_range__hash_multiset_equal_range_varg__user_define_t*)iterator_get_pointer(r_range.it_begin))->n_elem == 8);
assert_true(((_test__hash_multiset_equal_range__hash_multiset_equal_range_varg__user_define_t*)iterator_get_pointer(r_range.it_end))->n_elem == 9);
hash_multiset_destroy(pt_hash_multiset);
}
/**
* Insertion sort for specify range.
*/
void _algo_insertion_sort_if(random_access_iterator_t it_first, random_access_iterator_t it_last, bfun_t bfun_op, void* pv_value)
{
iterator_t it_bound;
iterator_t it_next;
iterator_t it_tmp;
iterator_t it_prev;
bool_t b_result = false;
assert(_iterator_valid_range(it_first, it_last, _RANDOM_ACCESS_ITERATOR));
assert(pv_value != NULL);
assert(bfun_op != NULL);
if (iterator_equal(it_first, it_last)) {
return;
}
if (strncmp(_iterator_get_typebasename(it_first), _C_STRING_TYPE, _TYPE_NAME_SIZE) == 0) {
for (it_bound = iterator_next(it_first); !iterator_equal(it_bound, it_last); it_bound = iterator_next(it_bound)) {
string_assign_cstr((string_t*)pv_value, (char*)iterator_get_pointer(it_bound));
(*bfun_op)(string_c_str((string_t*)pv_value), iterator_get_pointer(it_first), &b_result);
if (b_result) { /* pv_value < *it_first */
it_next = iterator_next(it_bound);
algo_copy_backward(it_first, it_bound, it_next);
iterator_set_value(it_first, string_c_str((string_t*)pv_value));
} else {
it_tmp = it_bound;
it_prev = iterator_prev(it_tmp);
(*bfun_op)(string_c_str((string_t*)pv_value), iterator_get_pointer(it_prev), &b_result);
while (b_result) { /* pv_value < *it_prev */
iterator_set_value(it_tmp, iterator_get_pointer(it_prev));
it_tmp = it_prev;
it_prev = iterator_prev(it_prev);
(*bfun_op)(string_c_str((string_t*)pv_value), iterator_get_pointer(it_prev), &b_result);
}
iterator_set_value(it_tmp, string_c_str((string_t*)pv_value));
}
}
} else {
for (it_bound = iterator_next(it_first); !iterator_equal(it_bound, it_last); it_bound = iterator_next(it_bound)) {
iterator_get_value(it_bound, pv_value);
(*bfun_op)(pv_value, iterator_get_pointer(it_first), &b_result);
if (b_result) { /* pv_value < *it_first */
it_next = iterator_next(it_bound);
algo_copy_backward(it_first, it_bound, it_next);
iterator_set_value(it_first, pv_value);
} else {
it_tmp = it_bound;
it_prev = iterator_prev(it_tmp);
(*bfun_op)(pv_value, iterator_get_pointer(it_prev), &b_result);
while (b_result) { /* pv_value < *it_prev */
iterator_set_value(it_tmp, iterator_get_pointer(it_prev));
it_tmp = it_prev;
it_prev = iterator_prev(it_prev);
(*bfun_op)(pv_value, iterator_get_pointer(it_prev), &b_result);
}
iterator_set_value(it_tmp, pv_value);
}
}
}
}
/**
* Quick sort or heap sort for specify range.
*/
void _algo_intro_sort_if(
random_access_iterator_t it_first, random_access_iterator_t it_last, bfun_t bfun_op, size_t t_depth, void* pv_value)
{
iterator_t it_pivot;
iterator_t it_begin;
iterator_t it_end;
iterator_t it_prev;
bool_t b_result = false;
assert(_iterator_valid_range(it_first, it_last, _RANDOM_ACCESS_ITERATOR));
assert(pv_value != NULL);
assert(bfun_op != NULL);
if (iterator_distance(it_first, it_last) < 2) {
return;
}
if (t_depth == 0){
/* do heap sort */
algo_partial_sort_if(it_first, it_last, it_last, bfun_op);
return;
}
t_depth--;
it_pivot = iterator_advance(it_first, iterator_distance(it_first, it_last) / 2);
it_prev = iterator_prev(it_last);
it_pivot = _algo_median_of_three_if(it_first, it_pivot, it_prev, bfun_op);
/* the pv_value must be string_t type when the container type is char* */
if (strncmp(_iterator_get_typebasename(it_first), _C_STRING_TYPE, _TYPE_NAME_SIZE) == 0) {
string_assign_cstr((string_t*)pv_value, (char*)iterator_get_pointer(it_pivot));
it_begin = it_first;
it_end = it_last;
for (;;) {
/* move begin */
(*bfun_op)(iterator_get_pointer(it_begin), string_c_str((string_t*)pv_value), &b_result);
while (b_result) {
it_begin = iterator_next(it_begin);
(*bfun_op)(iterator_get_pointer(it_begin), string_c_str((string_t*)pv_value), &b_result);
}
/* move end */
it_end = iterator_prev(it_end);
(*bfun_op)(string_c_str((string_t*)pv_value), iterator_get_pointer(it_end), &b_result);
while (b_result) {
it_end = iterator_prev(it_end);
(*bfun_op)(string_c_str((string_t*)pv_value), iterator_get_pointer(it_end), &b_result);
}
/* across */
if (!iterator_less(it_begin, it_end)) {
it_pivot = it_begin;
break;
} else {
algo_iter_swap(it_begin, it_end);
it_begin = iterator_next(it_begin);
}
}
} else {
iterator_get_value(it_pivot, pv_value);
it_begin = it_first;
it_end = it_last;
for (;;) {
/* move begin */
(*bfun_op)(iterator_get_pointer(it_begin), pv_value, &b_result);
while (b_result) {
it_begin = iterator_next(it_begin);
(*bfun_op)(iterator_get_pointer(it_begin), pv_value, &b_result);
}
/* move end */
it_end = iterator_prev(it_end);
(*bfun_op)(pv_value, iterator_get_pointer(it_end), &b_result);
while (b_result) {
it_end = iterator_prev(it_end);
(*bfun_op)(pv_value, iterator_get_pointer(it_end), &b_result);
}
/* across */
if (!iterator_less(it_begin, it_end)) {
it_pivot = it_begin;
break;
} else {
algo_iter_swap(it_begin, it_end);
it_begin = iterator_next(it_begin);
}
}
}
/* sort [it_first, it_pivot) */
_algo_intro_sort_if(it_first, it_pivot, bfun_op, t_depth, pv_value);
/* sort [it_pivot, it_last) */
_algo_intro_sort_if(it_pivot, it_last, bfun_op, t_depth, pv_value);
}
