/**
* Calculate distance between two iterators.
*/
int _rb_tree_iterator_distance(_rb_tree_iterator_t it_first, _rb_tree_iterator_t it_second)
{
_rb_tree_iterator_t it_iter;
int n_distance = 0;
assert(_rb_tree_iterator_belong_to_rb_tree(_RB_TREE_ITERATOR_TREE(it_first), it_first));
assert(_rb_tree_iterator_belong_to_rb_tree(_RB_TREE_ITERATOR_TREE(it_second), it_second));
assert(_RB_TREE_ITERATOR_TREE(it_first) == _RB_TREE_ITERATOR_TREE(it_second));
if (_rb_tree_iterator_before(it_first, it_second)) {
for (it_iter = it_first; !_rb_tree_iterator_equal(it_iter, it_second); it_iter = _rb_tree_iterator_next(it_iter)) {
n_distance++;
}
return n_distance;
} else if (_rb_tree_iterator_before(it_second, it_first)) {
for (it_iter = it_second; !_rb_tree_iterator_equal(it_iter, it_first); it_iter = _rb_tree_iterator_next(it_iter)) {
n_distance++;
}
return -n_distance;
} else {
return 0;
}
}
/**
* Test the first iterator is before the second.
*/
bool_t _rb_tree_iterator_before(_rb_tree_iterator_t it_first, _rb_tree_iterator_t it_second)
{
_rb_tree_iterator_t it_iter;
_rb_tree_t* pt_rb_tree = NULL;
assert(_rb_tree_iterator_belong_to_rb_tree(_RB_TREE_ITERATOR_TREE(it_first), it_first));
assert(_rb_tree_iterator_belong_to_rb_tree(_RB_TREE_ITERATOR_TREE(it_second), it_second));
assert(_RB_TREE_ITERATOR_TREE(it_first) == _RB_TREE_ITERATOR_TREE(it_second));
/* first iterator equal to second iterator */
if (_RB_TREE_ITERATOR_COREPOS(it_first) == _RB_TREE_ITERATOR_COREPOS(it_second)) {
return false;
}
/* else travel subtree for search second iterator */
pt_rb_tree = _RB_TREE_ITERATOR_TREE(it_first);
for (it_iter = it_first;
!_rb_tree_iterator_equal(it_iter, _rb_tree_end(pt_rb_tree));
it_iter = _rb_tree_iterator_next(it_iter)) {
if (_rb_tree_iterator_equal(it_iter, it_second)) {
return true;
}
}
return _rb_tree_iterator_equal(it_second, _rb_tree_end(pt_rb_tree)) ? true : false;
}
/**
* Get data value pointer referenced by iterator, but ignore char*.
*/
const void* _rb_tree_iterator_get_pointer_ignore_cstr(_rb_tree_iterator_t it_iter)
{
assert(_rb_tree_iterator_belong_to_rb_tree(_RB_TREE_ITERATOR_TREE(it_iter), it_iter));
assert(!_rb_tree_iterator_equal(it_iter, _rb_tree_end(_RB_TREE_ITERATOR_TREE(it_iter))));
return ((_rbnode_t*)_RB_TREE_ITERATOR_COREPOS(it_iter))->_pby_data;
}
/**
* Return iterator reference next element.
*/
_rb_tree_iterator_t _rb_tree_iterator_next(_rb_tree_iterator_t it_iter)
{
_rbnode_t* pt_next = NULL; /* next pos */
_rbnode_t* pt_cur = (_rbnode_t*)_RB_TREE_ITERATOR_COREPOS(it_iter);
assert(_rb_tree_iterator_belong_to_rb_tree(_RB_TREE_ITERATOR_TREE(it_iter), it_iter));
assert(!_rb_tree_iterator_equal(it_iter, _rb_tree_end(_RB_TREE_ITERATOR_TREE(it_iter))));
if (pt_cur->_pt_right != NULL) {
pt_next = pt_cur->_pt_right;
while (pt_next->_pt_left != NULL) {
pt_next = pt_next->_pt_left;
}
_RB_TREE_ITERATOR_COREPOS(it_iter) = (_byte_t*)pt_next;
} else {
pt_next = pt_cur->_pt_parent;
while (pt_cur == pt_next->_pt_right) {
pt_cur = pt_next;
pt_next = pt_next->_pt_parent;
}
/*
* this is special condition, when the next pos is root's parent.
* when the rb tree has only one node, this condition is came.
*/
if (pt_cur->_pt_right != pt_next) {
_RB_TREE_ITERATOR_COREPOS(it_iter) = (_byte_t*)pt_next;
} else {
_RB_TREE_ITERATOR_COREPOS(it_iter) = (_byte_t*)pt_cur;
}
}
return it_iter;
}
/**
* Return iterator reference previous element.
*/
_rb_tree_iterator_t _rb_tree_iterator_prev(_rb_tree_iterator_t it_iter)
{
_rbnode_t* pt_prev = NULL;
_rbnode_t* pt_cur = (_rbnode_t*)_RB_TREE_ITERATOR_COREPOS(it_iter);
assert(_rb_tree_iterator_belong_to_rb_tree(_RB_TREE_ITERATOR_TREE(it_iter), it_iter));
assert(!_rb_tree_iterator_equal(it_iter, _rb_tree_begin(_RB_TREE_ITERATOR_TREE(it_iter))));
/* previous end */
if(_rb_tree_iterator_equal(it_iter, _rb_tree_end(_RB_TREE_ITERATOR_TREE(it_iter))))
{
_RB_TREE_ITERATOR_COREPOS(it_iter) = (_byte_t*)_RB_TREE_ITERATOR_TREE(it_iter)->_t_rbroot._pt_right;
}
else
{
if(pt_cur->_pt_left != NULL)
{
pt_prev = pt_cur->_pt_left;
while(pt_prev->_pt_right != NULL)
{
pt_prev = pt_prev->_pt_right;
}
_RB_TREE_ITERATOR_COREPOS(it_iter) = (_byte_t*)pt_prev;
}
else
{
pt_prev = pt_cur->_pt_parent;
while(pt_cur == pt_prev->_pt_left)
{
pt_cur = pt_prev;
pt_prev = pt_prev->_pt_parent;
}
/*
* there is no same special condition as next, because the begin
* iterator is the valid iterator
*/
_RB_TREE_ITERATOR_COREPOS(it_iter) = (_byte_t*)pt_prev;
}
}
return it_iter;
}
/**
* Get data value pointer referenced by iterator.
*/
const void* _rb_tree_iterator_get_pointer(_rb_tree_iterator_t it_iter)
{
assert(_rb_tree_iterator_belong_to_rb_tree(_RB_TREE_ITERATOR_TREE(it_iter), it_iter));
assert(!_rb_tree_iterator_equal(it_iter, _rb_tree_end(_RB_TREE_ITERATOR_TREE(it_iter))));
/* char* */
if (strncmp(_GET_RB_TREE_TYPE_BASENAME(_RB_TREE_ITERATOR_TREE(it_iter)), _C_STRING_TYPE, _TYPE_NAME_SIZE) == 0) {
return (char*)string_c_str((string_t*)((_rbnode_t*)_RB_TREE_ITERATOR_COREPOS(it_iter))->_pby_data);
} else {
return ((_rbnode_t*)_RB_TREE_ITERATOR_COREPOS(it_iter))->_pby_data;
}
}
/**
* Test the two set iterator are equal.
*/
bool_t _set_iterator_equal(set_iterator_t it_first, set_iterator_t it_second)
{
assert(_GET_SET_CONTAINER_TYPE(it_first) == _SET_CONTAINER);
assert(_GET_SET_ITERATOR_TYPE(it_first) == _BIDIRECTIONAL_ITERATOR);
assert(_GET_SET_CONTAINER_TYPE(it_second) == _SET_CONTAINER);
assert(_GET_SET_ITERATOR_TYPE(it_second) == _BIDIRECTIONAL_ITERATOR);
#ifdef CSTL_SET_AVL_TREE
return _avl_tree_iterator_equal(it_first, it_second);
#else
return _rb_tree_iterator_equal(it_first, it_second);
#endif
}
void test__rb_tree_iterator_equal__invalid_second(void** state)
{
_rb_tree_t* pt_rb_tree = _create_rb_tree("int");
_rb_tree_iterator_t it_first;
_rb_tree_iterator_t it_second;
_rb_tree_init(pt_rb_tree, NULL);
it_first = _rb_tree_begin(pt_rb_tree);
it_second = _rb_tree_begin(pt_rb_tree);
it_second._t_pos._t_treepos._pby_corepos = NULL;
expect_assert_failure(_rb_tree_iterator_equal(it_first, it_second));
_rb_tree_destroy(pt_rb_tree);
}
void test__rb_tree_iterator_equal__equal(void** state)
{
_rb_tree_t* pt_rb_tree = _create_rb_tree("int");
_rb_tree_iterator_t it_first;
_rb_tree_iterator_t it_second;
int elem = 100;
_rb_tree_init(pt_rb_tree, NULL);
_rb_tree_insert_unique(pt_rb_tree, &elem);
it_first = _rb_tree_begin(pt_rb_tree);
it_second = _rb_tree_begin(pt_rb_tree);
assert_true(_rb_tree_iterator_equal(it_first, it_second));
_rb_tree_destroy(pt_rb_tree);
}
void test__rb_tree_iterator_prev__end(void** state)
{
_rb_tree_t* pt_rb_tree = _create_rb_tree("int");
_rb_tree_iterator_t it_iter;
int elem = 10;
_rb_tree_init(pt_rb_tree, NULL);
_rb_tree_insert_unique(pt_rb_tree, &elem);
it_iter = _rb_tree_end(pt_rb_tree);
it_iter = _rb_tree_iterator_prev(it_iter);
assert_true(_rb_tree_iterator_equal(it_iter, _rb_tree_begin(pt_rb_tree)));
_rb_tree_destroy(pt_rb_tree);
}
/**
* Get data value referenced by iterator.
*/
void _rb_tree_iterator_get_value(_rb_tree_iterator_t it_iter, void* pv_value)
{
assert(pv_value != NULL);
assert(_rb_tree_iterator_belong_to_rb_tree(_RB_TREE_ITERATOR_TREE(it_iter), it_iter));
assert(!_rb_tree_iterator_equal(it_iter, _rb_tree_end(_RB_TREE_ITERATOR_TREE(it_iter))));
/* char* */
if (strncmp(_GET_RB_TREE_TYPE_BASENAME(_RB_TREE_ITERATOR_TREE(it_iter)), _C_STRING_TYPE, _TYPE_NAME_SIZE) == 0) {
*(char**)pv_value = (char*)string_c_str((string_t*)((_rbnode_t*)_RB_TREE_ITERATOR_COREPOS(it_iter))->_pby_data);
} else {
bool_t b_result = _GET_RB_TREE_TYPE_SIZE(_RB_TREE_ITERATOR_TREE(it_iter));
_GET_RB_TREE_TYPE_COPY_FUNCTION(_RB_TREE_ITERATOR_TREE(it_iter))(
pv_value, ((_rbnode_t*)_RB_TREE_ITERATOR_COREPOS(it_iter))->_pby_data, &b_result);
assert(b_result);
}
}
void test__rb_tree_iterator_equal__not_same_rb_tree(void** state)
{
_rb_tree_t* pt_first = _create_rb_tree("int");
_rb_tree_t* pt_second = _create_rb_tree("int");
_rb_tree_iterator_t it_first;
_rb_tree_iterator_t it_second;
_rb_tree_init(pt_first, NULL);
_rb_tree_init(pt_second, NULL);
it_first = _rb_tree_begin(pt_first);
it_second = _rb_tree_begin(pt_second);
expect_assert_failure(_rb_tree_iterator_equal(it_first, it_second));
_rb_tree_destroy(pt_first);
_rb_tree_destroy(pt_second);
}
bool_t _multimap_iterator_equal(
const struct _tagmultimap* cpt_multimap,
const multimap_iterator_t* cpt_iterator,
multimap_iterator_t t_iterator)
{
assert(cpt_multimap != NULL && cpt_iterator != NULL);
assert(
_GET_MULTIMAP_CONTAINER_TYPE(cpt_iterator) == _MULTIMAP_CONTAINER &&
_GET_MULTIMAP_ITERATOR_TYPE(cpt_iterator) == _BIDIRECTIONAL_ITERATOR &&
_GET_MULTIMAP_CONTAINER_TYPE(&t_iterator) == _MULTIMAP_CONTAINER &&
_GET_MULTIMAP_ITERATOR_TYPE(&t_iterator) == _BIDIRECTIONAL_ITERATOR);
assert(
_GET_MULTIMAP_CONTAINER(cpt_iterator) == cpt_multimap &&
_GET_MULTIMAP_CONTAINER(&t_iterator) == cpt_multimap);
#ifdef CSTL_MULTIMAP_AVL_TREE
return _avl_tree_iterator_equal(
_GET_MULTIMAP_AVL_TREE(cpt_multimap), cpt_iterator, t_iterator);
#else
return _rb_tree_iterator_equal(
_GET_MULTIMAP_RB_TREE(cpt_multimap), cpt_iterator, t_iterator);
#endif
}
