/**
* 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);
}
/**
* 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));
}
void test__create_avl_tree_auxiliary__libcstl_builtin(void** state)
{
_avl_tree_t* pt_avl_tree = malloc(sizeof(_avl_tree_t));
assert_true(_create_avl_tree_auxiliary(pt_avl_tree, "vector_t<int>"));
assert_true(_avl_tree_is_created(pt_avl_tree));
_avl_tree_destroy(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));
}
/**
* 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);
}
void test__create_avl_tree_auxiliary__cstr(void** state)
{
_avl_tree_t* pt_avl_tree = malloc(sizeof(_avl_tree_t));
assert_true(_create_avl_tree_auxiliary(pt_avl_tree, "char*"));
assert_true(_avl_tree_is_created(pt_avl_tree));
_avl_tree_destroy(pt_avl_tree);
}
/**
* Initialize avl tree container with specific array and compare function.
*/
void _avl_tree_init_copy_unique_array_ex(_avl_tree_t* pt_dest, const void* cpv_array, size_t t_count, bfun_t t_compare)
{
assert(pt_dest != NULL);
assert(_avl_tree_is_created(pt_dest));
assert(cpv_array != NULL);
_avl_tree_init(pt_dest, t_compare);
_avl_tree_insert_unique_array(pt_dest, cpv_array, t_count);
}
/**
* Initialize avl tree container with specific array.
*/
void _avl_tree_init_copy_equal_array(_avl_tree_t* pt_dest, const void* cpv_array, size_t t_count)
{
assert(pt_dest != NULL);
assert(_avl_tree_is_created(pt_dest));
assert(cpv_array != NULL);
_avl_tree_init(pt_dest, NULL);
_avl_tree_insert_equal_array(pt_dest, cpv_array, t_count);
}
/**
* Initialize avl tree container with specific range and compare function.
*/
void _avl_tree_init_copy_unique_range_ex(_avl_tree_t* pt_dest, iterator_t it_begin, iterator_t it_end, bfun_t t_compare)
{
assert(pt_dest != NULL);
assert(_avl_tree_is_created(pt_dest));
assert(_avl_tree_same_iterator_type(pt_dest, it_begin));
assert(_avl_tree_same_iterator_type(pt_dest, it_end));
assert(iterator_equal(it_begin, it_end) || _iterator_before(it_begin, it_end));
_avl_tree_init(pt_dest, t_compare);
_avl_tree_insert_unique_range(pt_dest, it_begin, it_end);
}
/**
* Initialize avl tree container with specific range.
*/
void _avl_tree_init_copy_equal_range(_avl_tree_t* pt_dest, iterator_t it_begin, iterator_t it_end)
{
assert(pt_dest != NULL);
assert(_avl_tree_is_created(pt_dest));
assert(_avl_tree_same_iterator_type(pt_dest, it_begin));
assert(_avl_tree_same_iterator_type(pt_dest, it_end));
assert(iterator_equal(it_begin, it_end) || _iterator_before(it_begin, it_end));
_avl_tree_init(pt_dest, NULL);
_avl_tree_insert_equal_range(pt_dest, it_begin, it_end);
}
void test__create_avl_tree_auxiliary__user_define(void** state)
{
_avl_tree_t* pt_avl_tree = NULL;
type_register(_test__create_avl_tree_auxiliary__user_define_t, NULL, NULL, NULL, NULL);
pt_avl_tree = malloc(sizeof(_avl_tree_t));
assert_true(_create_avl_tree_auxiliary(pt_avl_tree, "_test__create_avl_tree_auxiliary__user_define_t"));
assert_true(_avl_tree_is_created(pt_avl_tree));
_avl_tree_destroy(pt_avl_tree);
}
/**
* Initialize avl tree container.
*/
void _avl_tree_init(_avl_tree_t* pt_avl_tree, bfun_t t_compare)
{
assert(pt_avl_tree != NULL);
assert(_avl_tree_is_created(pt_avl_tree));
pt_avl_tree->_t_avlroot._pt_left = &pt_avl_tree->_t_avlroot;
pt_avl_tree->_t_avlroot._pt_right = &pt_avl_tree->_t_avlroot;
if (t_compare != NULL) {
pt_avl_tree->_t_compare = t_compare;
} else {
pt_avl_tree->_t_compare = _GET_AVL_TREE_TYPE_LESS_FUNCTION(pt_avl_tree);
}
}
/**
* 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;
}
/**
* 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;
}
/**
* 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));
}
}
