/**
* Tests if the two avl tree are equal.
*/
bool_t _avl_tree_equal(const _avl_tree_t* cpt_first, const _avl_tree_t* cpt_second)
{
_avl_tree_iterator_t it_first;
_avl_tree_iterator_t it_first_begin;
_avl_tree_iterator_t it_first_end;
_avl_tree_iterator_t it_second;
_avl_tree_iterator_t it_second_begin;
_avl_tree_iterator_t it_second_end;
bool_t b_less = false;
bool_t b_greater = false;
assert(cpt_first != NULL);
assert(cpt_second != NULL);
assert(_avl_tree_is_inited(cpt_first));
assert(_avl_tree_is_inited(cpt_second));
assert(_avl_tree_same_type_ex(cpt_first, cpt_second));
if (cpt_first == cpt_second) {
return true;
}
/* test avl tree size */
if (_avl_tree_size(cpt_first) != _avl_tree_size(cpt_second)) {
return false;
}
it_first_begin = _avl_tree_begin(cpt_first);
it_first_end = _avl_tree_end(cpt_first);
it_second_begin = _avl_tree_begin(cpt_second);
it_second_end = _avl_tree_end(cpt_second);
/* test each element */
for (it_first = it_first_begin, it_second = it_second_begin;
!_avl_tree_iterator_equal(it_first, it_first_end) && !_avl_tree_iterator_equal(it_second, it_second_end);
it_first = _avl_tree_iterator_next(it_first), it_second = _avl_tree_iterator_next(it_second)) {
b_less = b_greater = _GET_AVL_TREE_TYPE_SIZE(cpt_first);
_GET_AVL_TREE_TYPE_LESS_FUNCTION(cpt_first)(
((_avlnode_t*)_AVL_TREE_ITERATOR_COREPOS(it_first))->_pby_data,
((_avlnode_t*)_AVL_TREE_ITERATOR_COREPOS(it_second))->_pby_data, &b_less);
_GET_AVL_TREE_TYPE_LESS_FUNCTION(cpt_first)(
((_avlnode_t*)_AVL_TREE_ITERATOR_COREPOS(it_second))->_pby_data,
((_avlnode_t*)_AVL_TREE_ITERATOR_COREPOS(it_first))->_pby_data, &b_greater);
if (b_less || b_greater) {
return false;
}
}
assert(_avl_tree_iterator_equal(it_first, it_first_end) && _avl_tree_iterator_equal(it_second, it_second_end));
return true;
}
/**
* Test the first iterator is before the second.
*/
bool_t _avl_tree_iterator_before(_avl_tree_iterator_t it_first, _avl_tree_iterator_t it_second)
{
_avl_tree_iterator_t it_iter;
_avl_tree_iterator_t it_end;
_avl_tree_t* pt_avl_tree = NULL;
assert(_avl_tree_iterator_belong_to_avl_tree(_AVL_TREE_ITERATOR_TREE(it_first), it_first));
assert(_avl_tree_iterator_belong_to_avl_tree(_AVL_TREE_ITERATOR_TREE(it_second), it_second));
assert(_AVL_TREE_ITERATOR_TREE(it_first) == _AVL_TREE_ITERATOR_TREE(it_second));
/* first iterator equal to second iterator */
if (_AVL_TREE_ITERATOR_COREPOS(it_first) == _AVL_TREE_ITERATOR_COREPOS(it_second)) {
return false;
}
/* else travel subtree for search second iterator */
pt_avl_tree = _AVL_TREE_ITERATOR_TREE(it_first);
it_end = _avl_tree_end(pt_avl_tree);
for (it_iter = it_first;
!_avl_tree_iterator_equal(it_iter, it_end);
it_iter = _avl_tree_iterator_next(it_iter)) {
if (_avl_tree_iterator_equal(it_iter, it_second)) {
return true;
}
}
return _avl_tree_iterator_equal(it_second, it_end) ? true : false;
}
/**
* Assign avl tree container.
*/
void _avl_tree_assign(_avl_tree_t* pt_dest, const _avl_tree_t* cpt_src)
{
assert(pt_dest != NULL);
assert(cpt_src != NULL);
assert(_avl_tree_is_inited(pt_dest));
assert(_avl_tree_is_inited(cpt_src));
assert(_avl_tree_same_type_ex(pt_dest, cpt_src));
if (!_avl_tree_equal(pt_dest, cpt_src)) {
_avl_tree_iterator_t it_iter;
_avl_tree_iterator_t it_begin;
_avl_tree_iterator_t it_end;
/* clear dest avl tree */
_avl_tree_clear(pt_dest);
it_begin = _avl_tree_begin(cpt_src);
it_end = _avl_tree_end(cpt_src);
/* insert all elements of src into dest */
for (it_iter = it_begin;
!_avl_tree_iterator_equal(it_iter, it_end);
it_iter = _avl_tree_iterator_next(it_iter)) {
_avl_tree_insert_equal(pt_dest, _avl_tree_iterator_get_pointer_ignore_cstr(it_iter));
}
}
}
/**
* Tests if the first avl tree is less than the second avl tree.
*/
bool_t _avl_tree_less(const _avl_tree_t* cpt_first, const _avl_tree_t* cpt_second)
{
_avl_tree_iterator_t it_first;
_avl_tree_iterator_t it_first_begin;
_avl_tree_iterator_t it_first_end;
_avl_tree_iterator_t it_second;
_avl_tree_iterator_t it_second_begin;
_avl_tree_iterator_t it_second_end;
bool_t b_result = false;
assert(cpt_first != NULL);
assert(cpt_second != NULL);
assert(_avl_tree_is_inited(cpt_first));
assert(_avl_tree_is_inited(cpt_second));
assert(_avl_tree_same_type_ex(cpt_first, cpt_second));
it_first_begin = _avl_tree_begin(cpt_first);
it_first_end = _avl_tree_end(cpt_first);
it_second_begin = _avl_tree_begin(cpt_second);
it_second_end = _avl_tree_end(cpt_second);
/* test each element */
for (it_first = it_first_begin, it_second = it_second_begin;
!_avl_tree_iterator_equal(it_first, it_first_end) && !_avl_tree_iterator_equal(it_second, it_second_end);
it_first = _avl_tree_iterator_next(it_first), it_second = _avl_tree_iterator_next(it_second)) {
b_result = _GET_AVL_TREE_TYPE_SIZE(cpt_first);
_GET_AVL_TREE_TYPE_LESS_FUNCTION(cpt_first)(
((_avlnode_t*)_AVL_TREE_ITERATOR_COREPOS(it_first))->_pby_data,
((_avlnode_t*)_AVL_TREE_ITERATOR_COREPOS(it_second))->_pby_data, &b_result);
if (b_result) {
return true;
}
b_result = _GET_AVL_TREE_TYPE_SIZE(cpt_first);
_GET_AVL_TREE_TYPE_LESS_FUNCTION(cpt_first)(
((_avlnode_t*)_AVL_TREE_ITERATOR_COREPOS(it_second))->_pby_data,
((_avlnode_t*)_AVL_TREE_ITERATOR_COREPOS(it_first))->_pby_data, &b_result);
if (b_result) {
return false;
}
}
return _avl_tree_size(cpt_first) < _avl_tree_size(cpt_second) ? true : false;
}
/**
* Return iterator reference next element.
*/
set_iterator_t _set_iterator_next(set_iterator_t it_iter)
{
assert(_GET_SET_CONTAINER_TYPE(it_iter) == _SET_CONTAINER);
assert(_GET_SET_ITERATOR_TYPE(it_iter) == _BIDIRECTIONAL_ITERATOR);
#ifdef CSTL_SET_AVL_TREE
return _avl_tree_iterator_next(it_iter);
#else
return _rb_tree_iterator_next(it_iter);
#endif
}
void _multimap_iterator_next(
const struct _tagmultimap* cpt_multimap, multimap_iterator_t* pt_iterator)
{
assert(cpt_multimap != NULL && pt_iterator != NULL);
assert(
_GET_MULTIMAP_CONTAINER_TYPE(pt_iterator) == _MULTIMAP_CONTAINER &&
_GET_MULTIMAP_ITERATOR_TYPE(pt_iterator) == _BIDIRECTIONAL_ITERATOR &&
_GET_MULTIMAP_CONTAINER(pt_iterator) == cpt_multimap);
#ifdef CSTL_MULTIMAP_AVL_TREE
_avl_tree_iterator_next(_GET_MULTIMAP_AVL_TREE(cpt_multimap), pt_iterator);
#else
_rb_tree_iterator_next(_GET_MULTIMAP_RB_TREE(cpt_multimap), pt_iterator);
#endif
}
/*
* Erase a range of element in an avl tree.
*/
void _avl_tree_erase_range(_avl_tree_t* pt_avl_tree, _avl_tree_iterator_t it_begin, _avl_tree_iterator_t it_end)
{
_avl_tree_iterator_t it_iter;
_avl_tree_iterator_t it_next;
assert(pt_avl_tree != NULL);
assert(_avl_tree_is_inited(pt_avl_tree));
assert(_avl_tree_iterator_belong_to_avl_tree(pt_avl_tree, it_begin));
assert(_avl_tree_iterator_belong_to_avl_tree(pt_avl_tree, it_end));
assert(_avl_tree_iterator_equal(it_begin, it_end) || _avl_tree_iterator_before(it_begin, it_end));
it_iter = it_next = it_begin;
if (!_avl_tree_iterator_equal(it_next, _avl_tree_end(pt_avl_tree))) {
it_next = _avl_tree_iterator_next(it_next);
}
while (!_avl_tree_iterator_equal(it_iter, it_end)) {
_avl_tree_erase_pos(pt_avl_tree, it_iter);
it_iter = it_next;
if (!_avl_tree_iterator_equal(it_next, _avl_tree_end(pt_avl_tree))) {
it_next = _avl_tree_iterator_next(it_next);
}
}
}
/**
* Return an iterator to the first element that is equal to or greater than a specific element.
*/
_avl_tree_iterator_t _avl_tree_lower_bound(const _avl_tree_t* cpt_avl_tree, const void* cpv_value)
{
_avlnode_t* pt_cur = NULL;
_avlnode_t* pt_prev = NULL;
bool_t b_less = false;
bool_t b_greater = false;
_avl_tree_iterator_t it_iter;
assert(cpt_avl_tree != NULL);
assert(cpv_value != NULL);
assert(_avl_tree_is_inited(cpt_avl_tree));
it_iter = _create_avl_tree_iterator();
_AVL_TREE_ITERATOR_TREE_POINTER(it_iter) = (void*)cpt_avl_tree;
if (!_avl_tree_empty(cpt_avl_tree)) {
pt_prev = cpt_avl_tree->_t_avlroot._pt_parent;
b_less = b_greater = _GET_AVL_TREE_TYPE_SIZE(cpt_avl_tree);
_avl_tree_elem_compare_auxiliary(cpt_avl_tree, cpv_value, pt_prev->_pby_data, &b_less);
_avl_tree_elem_compare_auxiliary(cpt_avl_tree, pt_prev->_pby_data, cpv_value, &b_greater);
pt_cur = (b_less || !b_greater) ? pt_prev->_pt_left : pt_prev->_pt_right;
while (pt_cur != NULL) {
pt_prev = pt_cur;
b_less = b_greater = _GET_AVL_TREE_TYPE_SIZE(cpt_avl_tree);
_avl_tree_elem_compare_auxiliary(cpt_avl_tree, cpv_value, pt_prev->_pby_data, &b_less);
_avl_tree_elem_compare_auxiliary(cpt_avl_tree, pt_prev->_pby_data, cpv_value, &b_greater);
pt_cur = (b_less || !b_greater) ? pt_prev->_pt_left : pt_prev->_pt_right;
}
if (b_less || !b_greater) {
assert(pt_prev->_pt_left == NULL);
_AVL_TREE_ITERATOR_COREPOS(it_iter) = (_byte_t*)pt_prev;
assert(_avl_tree_iterator_belong_to_avl_tree(cpt_avl_tree, it_iter));
} else {
assert(pt_prev->_pt_right == NULL);
_AVL_TREE_ITERATOR_COREPOS(it_iter) = (_byte_t*)pt_prev;
it_iter = _avl_tree_iterator_next(it_iter);
}
} else {
it_iter = _avl_tree_end(cpt_avl_tree);
}
return it_iter;
}
/**
* Initialize avl tree container with avl tree.
*/
void _avl_tree_init_copy(_avl_tree_t* pt_dest, const _avl_tree_t* cpt_src)
{
_avl_tree_iterator_t it_iter;
_avl_tree_iterator_t it_begin;
_avl_tree_iterator_t it_end;
assert(pt_dest != NULL);
assert(cpt_src != NULL);
assert(_avl_tree_is_created(pt_dest));
assert(_avl_tree_is_inited(cpt_src));
assert(_avl_tree_same_type(pt_dest, cpt_src));
/* init the avl tree with the src avl tree */
_avl_tree_init(pt_dest, cpt_src->_t_compare);
it_begin = _avl_tree_begin(cpt_src);
it_end = _avl_tree_end(cpt_src);
/* insert all elements of src into dest */
for (it_iter = it_begin;
!_avl_tree_iterator_equal(it_iter, it_end);
it_iter = _avl_tree_iterator_next(it_iter)) {
_avl_tree_insert_equal(pt_dest, _avl_tree_iterator_get_pointer_ignore_cstr(it_iter));
}
}
/**
* Calculate distance between two iterators.
*/
int _avl_tree_iterator_distance(_avl_tree_iterator_t it_first, _avl_tree_iterator_t it_second)
{
_avl_tree_iterator_t it_iter;
int n_distance = 0;
assert(_avl_tree_iterator_belong_to_avl_tree(_AVL_TREE_ITERATOR_TREE(it_first), it_first));
assert(_avl_tree_iterator_belong_to_avl_tree(_AVL_TREE_ITERATOR_TREE(it_second), it_second));
assert(_AVL_TREE_ITERATOR_TREE(it_first) == _AVL_TREE_ITERATOR_TREE(it_second));
if (_avl_tree_iterator_before(it_first, it_second)) {
for (it_iter = it_first; !_avl_tree_iterator_equal(it_iter, it_second); it_iter = _avl_tree_iterator_next(it_iter)) {
n_distance++;
}
return n_distance;
} else if (_avl_tree_iterator_before(it_second, it_first)) {
for (it_iter = it_second; !_avl_tree_iterator_equal(it_iter, it_first); it_iter = _avl_tree_iterator_next(it_iter)) {
n_distance++;
}
return -n_distance;
} else {
return 0;
}
}
