/**
* Set data value referenced by iterator.
*/
void _slist_iterator_set_value(slist_iterator_t it_iter, const void* cpv_value)
{
assert(cpv_value != NULL);
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))));
/* char* */
if (strncmp(_GET_SLIST_TYPE_BASENAME(_SLIST_ITERATOR_CONTAINER(it_iter)), _C_STRING_TYPE, _TYPE_NAME_SIZE) == 0) {
string_assign_cstr((string_t*)((_slistnode_t*)_SLIST_ITERATOR_COREPOS(it_iter))->_pby_data, (char*)cpv_value);
} else {
bool_t b_result = _GET_SLIST_TYPE_SIZE(_SLIST_ITERATOR_CONTAINER(it_iter));
_GET_SLIST_TYPE_COPY_FUNCTION(_SLIST_ITERATOR_CONTAINER(it_iter))(
((_slistnode_t*)_SLIST_ITERATOR_COREPOS(it_iter))->_pby_data, cpv_value, &b_result);
assert(b_result);
}
}
/**
* Set iterator reference data.
*/
void _vector_iterator_set_value(vector_iterator_t it_iter, const void* cpv_value)
{
bool_t b_result = false;
assert(cpv_value != NULL);
assert(_vector_iterator_belong_to_vector(_VECTOR_ITERATOR_CONTAINER(it_iter), it_iter));
assert(!_vector_iterator_equal(it_iter, vector_end(_VECTOR_ITERATOR_CONTAINER(it_iter))));
/* char* */
if (strncmp(_GET_VECTOR_TYPE_BASENAME(_VECTOR_ITERATOR_CONTAINER(it_iter)), _C_STRING_TYPE, _TYPE_NAME_SIZE) == 0) {
string_assign_cstr((string_t*)_VECTOR_ITERATOR_COREPOS(it_iter), (char*)cpv_value);
} else {
b_result = _GET_VECTOR_TYPE_SIZE(_VECTOR_ITERATOR_CONTAINER(it_iter));
_GET_VECTOR_TYPE_COPY_FUNCTION(_VECTOR_ITERATOR_CONTAINER(it_iter))(_VECTOR_ITERATOR_COREPOS(it_iter), cpv_value, &b_result);
assert(b_result);
}
}
/**
* Set iterator reference data.
*/
void _deque_iterator_set_value(deque_iterator_t it_iter, const void* cpv_value)
{
bool_t b_result = false;
assert(cpv_value != NULL);
assert(_deque_iterator_belong_to_deque(_DEQUE_ITERATOR_CONTAINER(it_iter), it_iter));
assert(!iterator_equal(it_iter, deque_end(_DEQUE_ITERATOR_CONTAINER(it_iter))));
/* char* */
if(strncmp(_GET_DEQUE_TYPE_BASENAME(_DEQUE_ITERATOR_CONTAINER(it_iter)), _C_STRING_TYPE, _TYPE_NAME_SIZE) == 0)
{
string_assign_cstr((string_t*)_deque_iterator_get_pointer_auxiliary(it_iter), (char*)cpv_value);
}
else
{
b_result = _GET_DEQUE_TYPE_SIZE(_DEQUE_ITERATOR_CONTAINER(it_iter));
_GET_DEQUE_TYPE_COPY_FUNCTION(_DEQUE_ITERATOR_CONTAINER(it_iter))(
_deque_iterator_get_pointer_auxiliary(it_iter), cpv_value, &b_result);
assert(b_result);
}
}
/**
* Inserts an array of unique element into a avl tree.
*/
void _avl_tree_insert_unique_array(_avl_tree_t* pt_avl_tree, const void* cpv_array, size_t t_count)
{
size_t i = 0;
assert(pt_avl_tree != NULL);
assert(_avl_tree_is_inited(pt_avl_tree));
assert(cpv_array != NULL);
/*
* Copy the elements from src array to dest avl tree.
* The array of c builtin and user define or cstl builtin are different,
* the elements of c builtin array are element itself, but the elements of
* c string, user define or cstl are pointer of element.
*/
if (strncmp(_GET_AVL_TREE_TYPE_BASENAME(pt_avl_tree), _C_STRING_TYPE, _TYPE_NAME_SIZE) == 0) {
/*
* We need built a string_t for c string element.
*/
string_t* pstr_elem = create_string();
assert(pstr_elem != NULL);
string_init(pstr_elem);
for (i = 0; i < t_count; ++i) {
string_assign_cstr(pstr_elem, *((const char**)cpv_array + i));
_avl_tree_insert_unique(pt_avl_tree, pstr_elem);
}
string_destroy(pstr_elem);
} else if (_GET_AVL_TREE_TYPE_STYLE(pt_avl_tree) == _TYPE_C_BUILTIN) {
for (i = 0; i < t_count; ++i) {
_avl_tree_insert_unique(pt_avl_tree, (unsigned char*)cpv_array + i * _GET_AVL_TREE_TYPE_SIZE(pt_avl_tree));
}
} else {
for (i = 0; i < t_count; ++i) {
_avl_tree_insert_unique(pt_avl_tree, *((void**)cpv_array + i));
}
}
}
/**
* 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);
}
/**
* 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);
}
}
}
}
