/**
* 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));
}
}
}
/**
* Swap the datas of first avl_tree and second avl_tree.
*/
void _avl_tree_swap(_avl_tree_t* pt_first, _avl_tree_t* pt_second)
{
_avl_tree_t t_temp;
assert(pt_first != NULL);
assert(pt_second != NULL);
assert(_avl_tree_is_inited(pt_first));
assert(_avl_tree_is_inited(pt_second));
assert(_avl_tree_same_type_ex(pt_first, pt_second));
if (_avl_tree_equal(pt_first, pt_second)) {
return;
}
t_temp = *pt_first;
*pt_first = *pt_second;
*pt_second = t_temp;
if (_avl_tree_empty(pt_first)) {
pt_first->_t_avlroot._pt_left = &pt_first->_t_avlroot;
pt_first->_t_avlroot._pt_right = &pt_first->_t_avlroot;
} else {
pt_first->_t_avlroot._pt_parent->_pt_parent = &pt_first->_t_avlroot;
}
if (_avl_tree_empty(pt_second)) {
pt_second->_t_avlroot._pt_left = &pt_second->_t_avlroot;
pt_second->_t_avlroot._pt_right = &pt_second->_t_avlroot;
} else {
pt_second->_t_avlroot._pt_parent->_pt_parent = &pt_second->_t_avlroot;
}
}
/**
* Test the type and compare function that saved in the avl tree container is same.
*/
bool_t _avl_tree_same_type_ex(const _avl_tree_t* cpt_first, const _avl_tree_t* cpt_second)
{
assert(cpt_first != NULL);
assert(cpt_second != NULL);
assert(_avl_tree_is_inited(cpt_first) || _avl_tree_is_created(cpt_first));
assert(_avl_tree_is_inited(cpt_second) || _avl_tree_is_created(cpt_second));
if (cpt_first == cpt_second) {
return true;
}
return (cpt_first->_t_compare == cpt_second->_t_compare) && _avl_tree_same_type(cpt_first, cpt_second);
}
/**
* 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 type that saved in the avl tree container is same.
*/
bool_t _avl_tree_same_type(const _avl_tree_t* cpt_first, const _avl_tree_t* cpt_second)
{
assert(cpt_first != NULL);
assert(cpt_second != NULL);
assert(_avl_tree_is_inited(cpt_first) || _avl_tree_is_created(cpt_first));
assert(_avl_tree_is_inited(cpt_second) || _avl_tree_is_created(cpt_second));
if (cpt_first == cpt_second) {
return true;
}
return (cpt_first->_t_typeinfo._t_style == cpt_second->_t_typeinfo._t_style) &&
(cpt_first->_t_typeinfo._pt_type == cpt_second->_t_typeinfo._pt_type) &&
_type_is_same(_GET_AVL_TREE_TYPE_NAME(cpt_first), _GET_AVL_TREE_TYPE_NAME(cpt_second));
}
/**
* Return the compare function of key.
*/
bfun_t _avl_tree_key_comp(const _avl_tree_t* cpt_avl_tree)
{
assert(cpt_avl_tree != NULL);
assert(_avl_tree_is_inited(cpt_avl_tree));
return cpt_avl_tree->_t_compare;
}
/**
* Travel subtree for find the value in preorder.
*/
_avlnode_t* _avl_tree_find_value(const _avl_tree_t* cpt_avl_tree, const _avlnode_t* cpt_root, const void* cpv_value)
{
bool_t b_result = false;
assert(cpt_avl_tree != NULL);
assert(cpv_value != NULL);
assert(_avl_tree_is_inited(cpt_avl_tree));
if (cpt_root == NULL) {
return NULL;
}
b_result = _GET_AVL_TREE_TYPE_SIZE(cpt_avl_tree);
_avl_tree_elem_compare_auxiliary(cpt_avl_tree, cpv_value, cpt_root->_pby_data, &b_result);
if (b_result) {
return _avl_tree_find_value(cpt_avl_tree, cpt_root->_pt_left, cpv_value);
}
b_result = _GET_AVL_TREE_TYPE_SIZE(cpt_avl_tree);
_avl_tree_elem_compare_auxiliary(cpt_avl_tree, cpt_root->_pby_data, cpv_value, &b_result);
if (b_result) {
return _avl_tree_find_value(cpt_avl_tree, cpt_root->_pt_right, cpv_value);
} else {
return (_avlnode_t*)cpt_root;
}
}
/**
* Get the maximum number of elements int the avl tree.
*/
size_t _avl_tree_max_size(const _avl_tree_t* cpt_avl_tree)
{
assert(cpt_avl_tree != NULL);
assert(_avl_tree_is_inited(cpt_avl_tree));
return (size_t)(-1) / _GET_AVL_TREE_TYPE_SIZE(cpt_avl_tree);
}
/**
* Get the number of elements int the avl tree.
*/
size_t _avl_tree_size(const _avl_tree_t* cpt_avl_tree)
{
assert(cpt_avl_tree != NULL);
assert(_avl_tree_is_inited(cpt_avl_tree));
return cpt_avl_tree->_t_nodecount;
}
/**
* Test if a avl tree is empty.
*/
bool_t _avl_tree_empty(const _avl_tree_t* cpt_avl_tree)
{
assert(cpt_avl_tree != NULL);
assert(_avl_tree_is_inited(cpt_avl_tree));
return cpt_avl_tree->_t_nodecount == 0 ? true : false;
}
/**
* Destroy avl tree.
*/
void _avl_tree_destroy(_avl_tree_t* pt_avl_tree)
{
assert(pt_avl_tree != NULL);
assert(_avl_tree_is_inited(pt_avl_tree) || _avl_tree_is_created(pt_avl_tree));
_avl_tree_destroy_auxiliary(pt_avl_tree);
free(pt_avl_tree);
}
/**
* Test the type that saved in the avl tree container and referenced by it_iter are same.
*/
bool_t _avl_tree_same_iterator_type(const _avl_tree_t* cpt_avl_tree, iterator_t it_iter)
{
assert(cpt_avl_tree != NULL);
assert(_avl_tree_is_inited(cpt_avl_tree) || _avl_tree_is_created(cpt_avl_tree));
assert(_iterator_is_valid(it_iter));
return _type_is_same_ex(&cpt_avl_tree->_t_typeinfo, _iterator_get_typeinfo(it_iter));
}
/**
* Insert the value into subtree.
*/
_avl_tree_insert_result_t _avl_tree_insert_avlnode(
const _avl_tree_t* cpt_avl_tree, _avlnode_t* pt_root, const void* cpv_value)
{
_avl_tree_insert_result_t t_insert_result;
bool_t b_result = false;
assert(cpt_avl_tree != NULL);
assert(cpv_value != NULL);
assert(_avl_tree_is_inited(cpt_avl_tree));
/* if root is NULL then allocate memory */
if(pt_root == NULL)
{
pt_root = _alloc_allocate(
(_alloc_t*)&cpt_avl_tree->_t_allocator, _AVL_TREE_NODE_SIZE(_GET_AVL_TREE_TYPE_SIZE(cpt_avl_tree)), 1);
assert(pt_root != NULL);
_avl_tree_init_elem_auxiliary((_avl_tree_t*)cpt_avl_tree, pt_root);
pt_root->_pt_left = pt_root->_pt_right = NULL;
pt_root->_un_height = 0;
t_insert_result._pt_adjust = pt_root;
t_insert_result._pt_new = pt_root;
b_result = _GET_AVL_TREE_TYPE_SIZE(cpt_avl_tree);
_GET_AVL_TREE_TYPE_COPY_FUNCTION(cpt_avl_tree)(pt_root->_pby_data, cpv_value, &b_result);
assert(b_result);
return t_insert_result;
}
/* compare the value and current node */
/* if value < current node then insert into left subtree */
b_result = _GET_AVL_TREE_TYPE_SIZE(cpt_avl_tree);
_avl_tree_elem_compare_auxiliary(cpt_avl_tree, cpv_value, pt_root->_pby_data, &b_result);
if(b_result)
{
t_insert_result = _avl_tree_insert_avlnode(cpt_avl_tree, pt_root->_pt_left, cpv_value);
pt_root->_pt_left = t_insert_result._pt_adjust;
pt_root->_pt_left->_pt_parent = pt_root;
pt_root = _avl_tree_rebalance(pt_root);
t_insert_result._pt_adjust = pt_root;
return t_insert_result;
}
/* else insert into right subtree */
else
{
t_insert_result = _avl_tree_insert_avlnode(cpt_avl_tree, pt_root->_pt_right, cpv_value);
pt_root->_pt_right = t_insert_result._pt_adjust;
pt_root->_pt_right->_pt_parent = pt_root;
pt_root = _avl_tree_rebalance(pt_root);
t_insert_result._pt_adjust = pt_root;
return t_insert_result;
}
}
/**
* 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 the number of specific elements in an avl tree
*/
size_t _avl_tree_count(const _avl_tree_t* cpt_avl_tree, const void* cpv_value)
{
range_t r_range;
assert(cpt_avl_tree != NULL);
assert(cpv_value != NULL);
assert(_avl_tree_is_inited(cpt_avl_tree));
r_range = _avl_tree_equal_range(cpt_avl_tree, cpv_value);
return abs(_avl_tree_iterator_distance(r_range.it_begin, r_range.it_end));
}
/**
* Return an iterator that addresses the location succeeding the last element in the avl tree.
*/
_avl_tree_iterator_t _avl_tree_end(const _avl_tree_t* cpt_avl_tree)
{
_avl_tree_iterator_t it_end = _create_avl_tree_iterator();
assert(cpt_avl_tree != NULL);
assert(_avl_tree_is_inited(cpt_avl_tree));
_AVL_TREE_ITERATOR_TREE_POINTER(it_end) = (void*)cpt_avl_tree;
_AVL_TREE_ITERATOR_COREPOS(it_end) = (_byte_t*)&cpt_avl_tree->_t_avlroot;
return it_end;
}
/**
* Return an iterator that addresses the first element in the avl tree.
*/
_avl_tree_iterator_t _avl_tree_begin(const _avl_tree_t* cpt_avl_tree)
{
_avl_tree_iterator_t it_begin = _create_avl_tree_iterator();
assert(cpt_avl_tree != NULL);
assert(_avl_tree_is_inited(cpt_avl_tree));
_AVL_TREE_ITERATOR_TREE_POINTER(it_begin) = (void*)cpt_avl_tree;
_AVL_TREE_ITERATOR_COREPOS(it_begin) = (_byte_t*)cpt_avl_tree->_t_avlroot._pt_left;
return it_begin;
}
/**
* Erases all the elements of a avl tree.
*/
void _avl_tree_clear(_avl_tree_t* pt_avl_tree)
{
assert(pt_avl_tree != NULL);
assert(_avl_tree_is_inited(pt_avl_tree));
/* destroy all elements */
pt_avl_tree->_t_avlroot._pt_parent = _avl_tree_destroy_subtree(pt_avl_tree, pt_avl_tree->_t_avlroot._pt_parent);
assert(pt_avl_tree->_t_avlroot._pt_parent == NULL);
pt_avl_tree->_t_avlroot._pt_left = &pt_avl_tree->_t_avlroot;
pt_avl_tree->_t_avlroot._pt_right = &pt_avl_tree->_t_avlroot;
pt_avl_tree->_t_nodecount = 0;
}
/**
* Return an iterator range that is equal to a specific element.
*/
range_t _avl_tree_equal_range(const _avl_tree_t* cpt_avl_tree, const void* cpv_value)
{
range_t r_range;
assert(cpt_avl_tree != NULL);
assert(cpv_value != NULL);
assert(_avl_tree_is_inited(cpt_avl_tree));
r_range.it_begin = _avl_tree_lower_bound(cpt_avl_tree, cpv_value);
r_range.it_end = _avl_tree_upper_bound(cpt_avl_tree, cpv_value);
return r_range;
}
/**
* 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));
}
}
/**
* Test iterator referenced data is within the avl tree.
*/
bool_t _avl_tree_iterator_belong_to_avl_tree(const _avl_tree_t* cpt_avl_tree, _avl_tree_iterator_t it_iter)
{
assert(cpt_avl_tree != NULL);
assert(_avl_tree_is_inited(cpt_avl_tree));
assert(_AVL_TREE_ITERATOR_COREPOS(it_iter) != NULL);
assert(_AVL_TREE_ITERATOR_TREE(it_iter) == cpt_avl_tree);
/* if iterator is end */
if (_AVL_TREE_ITERATOR_COREPOS(it_iter) == (_byte_t*)&cpt_avl_tree->_t_avlroot) {
return true;
} else {
/* travel avl tree for search the pointer */
return _avl_tree_avlnode_belong_to_avl_tree(
cpt_avl_tree->_t_avlroot._pt_parent, (_avlnode_t*)_AVL_TREE_ITERATOR_COREPOS(it_iter));
}
}
/**
* Element compare function auxiliary
*/
void _avl_tree_elem_compare_auxiliary(
const _avl_tree_t* cpt_avl_tree, const void* cpv_first, const void* cpv_second, void* pv_output)
{
assert(cpt_avl_tree != NULL);
assert(cpv_first != NULL);
assert(cpv_second != NULL);
assert(pv_output != NULL);
assert(_avl_tree_is_inited(cpt_avl_tree));
if (strncmp(_GET_AVL_TREE_TYPE_BASENAME(cpt_avl_tree), _C_STRING_TYPE, _TYPE_NAME_SIZE) == 0 &&
cpt_avl_tree->_t_compare != _GET_AVL_TREE_TYPE_LESS_FUNCTION(cpt_avl_tree)) {
cpt_avl_tree->_t_compare(string_c_str((string_t*)cpv_first), string_c_str((string_t*)cpv_second), pv_output);
} else {
cpt_avl_tree->_t_compare(cpv_first, cpv_second, pv_output);
}
}
/**
* 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;
}
/**
* Destroy avl tree container auxiliary function.
*/
void _avl_tree_destroy_auxiliary(_avl_tree_t* pt_avl_tree)
{
assert(pt_avl_tree != NULL);
assert(_avl_tree_is_inited(pt_avl_tree) || _avl_tree_is_created(pt_avl_tree));
/* destroy all elements */
pt_avl_tree->_t_avlroot._pt_parent = _avl_tree_destroy_subtree(pt_avl_tree, pt_avl_tree->_t_avlroot._pt_parent);
assert(pt_avl_tree->_t_avlroot._pt_parent == NULL);
pt_avl_tree->_t_avlroot._pt_left = &pt_avl_tree->_t_avlroot;
pt_avl_tree->_t_avlroot._pt_right = &pt_avl_tree->_t_avlroot;
/* destroy allocator */
_alloc_destroy(&pt_avl_tree->_t_allocator);
pt_avl_tree->_t_nodecount = 0;
pt_avl_tree->_t_compare = NULL;
}
/**
* Find specific element.
*/
_avl_tree_iterator_t _avl_tree_find(const _avl_tree_t* cpt_avl_tree, const void* cpv_value)
{
_avl_tree_iterator_t it_iter;
assert(cpt_avl_tree != NULL);
assert(cpv_value != NULL);
assert(_avl_tree_is_inited(cpt_avl_tree));
_AVL_TREE_ITERATOR_TREE_POINTER(it_iter) = (void*)cpt_avl_tree;
_AVL_TREE_ITERATOR_COREPOS(it_iter) = (_byte_t*)_avl_tree_find_value(
cpt_avl_tree, cpt_avl_tree->_t_avlroot._pt_parent, cpv_value);
if (_AVL_TREE_ITERATOR_COREPOS(it_iter) == NULL) {
_AVL_TREE_ITERATOR_COREPOS(it_iter) = (_byte_t*)&cpt_avl_tree->_t_avlroot;
}
return it_iter;
}
/**
* Initialize element auxiliary function
*/
void _avl_tree_init_elem_auxiliary(_avl_tree_t* pt_avl_tree, _avlnode_t* pt_node)
{
assert(pt_avl_tree != NULL);
assert(pt_node != NULL);
assert(_avl_tree_is_inited(pt_avl_tree) || _avl_tree_is_created(pt_avl_tree));
/* initialize new elements */
if (_GET_AVL_TREE_TYPE_STYLE(pt_avl_tree) == _TYPE_CSTL_BUILTIN) {
/* get element type name */
char s_elemtypename[_TYPE_NAME_SIZE + 1];
_type_get_elem_typename(_GET_AVL_TREE_TYPE_NAME(pt_avl_tree), s_elemtypename);
_GET_AVL_TREE_TYPE_INIT_FUNCTION(pt_avl_tree)(pt_node->_pby_data, s_elemtypename);
} else {
bool_t b_result = _GET_AVL_TREE_TYPE_SIZE(pt_avl_tree);
_GET_AVL_TREE_TYPE_INIT_FUNCTION(pt_avl_tree)(pt_node->_pby_data, &b_result);
assert(b_result);
}
}
/**
* Destroy the subtree with postorder traverse.
*/
_avlnode_t* _avl_tree_destroy_subtree(_avl_tree_t* pt_avl_tree, _avlnode_t* pt_root)
{
bool_t b_result = false;
assert(pt_avl_tree != NULL);
assert(_avl_tree_is_inited(pt_avl_tree) || _avl_tree_is_created(pt_avl_tree));
if (pt_root != NULL) {
pt_root->_pt_left = _avl_tree_destroy_subtree(pt_avl_tree, pt_root->_pt_left);
pt_root->_pt_right = _avl_tree_destroy_subtree(pt_avl_tree, pt_root->_pt_right);
assert(pt_root->_pt_left == NULL && pt_root->_pt_right == NULL);
b_result = _GET_AVL_TREE_TYPE_SIZE(pt_avl_tree);
_GET_AVL_TREE_TYPE_DESTROY_FUNCTION(pt_avl_tree)(pt_root->_pby_data, &b_result);
assert(b_result);
_alloc_deallocate(&pt_avl_tree->_t_allocator, pt_root,_AVL_TREE_NODE_SIZE(_GET_AVL_TREE_TYPE_SIZE(pt_avl_tree)), 1);
}
return NULL;
}
/**
* Inserts an unique element into a avl tree.
*/
_avl_tree_iterator_t _avl_tree_insert_unique(_avl_tree_t* pt_avl_tree, const void* cpv_value)
{
assert(pt_avl_tree != NULL);
assert(cpv_value != NULL);
assert(_avl_tree_is_inited(pt_avl_tree));
/* if the avl tree is empty */
if (_avl_tree_empty(pt_avl_tree)) {
return _avl_tree_insert_equal(pt_avl_tree, cpv_value);
} else {
/* find value in avl tree */
_avl_tree_iterator_t it_iter = _avl_tree_find(pt_avl_tree, cpv_value);
/* if the value is exist */
if (!_avl_tree_iterator_equal(it_iter, _avl_tree_end(pt_avl_tree))) {
return _avl_tree_end(pt_avl_tree);
} else {
/* insert value into avl tree */
return _avl_tree_insert_equal(pt_avl_tree, cpv_value);
}
}
}
/**
* Inserts an element into a avl tree.
*/
_avl_tree_iterator_t _avl_tree_insert_equal(_avl_tree_t* pt_avl_tree, const void* cpv_value)
{
_avl_tree_insert_result_t t_result;
_avl_tree_iterator_t it_iter = _create_avl_tree_iterator();
assert(pt_avl_tree != NULL);
assert(cpv_value != NULL);
assert(_avl_tree_is_inited(pt_avl_tree));
t_result = _avl_tree_insert_avlnode(pt_avl_tree, pt_avl_tree->_t_avlroot._pt_parent, cpv_value);
assert(t_result._pt_adjust != NULL && t_result._pt_new != NULL);
pt_avl_tree->_t_avlroot._pt_parent = t_result._pt_adjust;
pt_avl_tree->_t_avlroot._pt_parent->_pt_parent = &pt_avl_tree->_t_avlroot;
pt_avl_tree->_t_avlroot._pt_left = _avl_tree_get_min_avlnode(pt_avl_tree->_t_avlroot._pt_parent);
pt_avl_tree->_t_avlroot._pt_right = _avl_tree_get_max_avlnode(pt_avl_tree->_t_avlroot._pt_parent);
pt_avl_tree->_t_nodecount++;
_AVL_TREE_ITERATOR_TREE_POINTER(it_iter) = pt_avl_tree;
_AVL_TREE_ITERATOR_COREPOS(it_iter) = (_byte_t*)t_result._pt_new;
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));
}
}
