/**
 * 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;
}
/**
 * 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 test__rb_tree_iterator_next__end(void** state)
{
    _rb_tree_t* pt_rb_tree = _create_rb_tree("int");
    _rb_tree_iterator_t it_iter;
    _rb_tree_init(pt_rb_tree, NULL);

    it_iter = _rb_tree_end(pt_rb_tree);

    expect_assert_failure(_rb_tree_iterator_next(it_iter));

    _rb_tree_destroy(pt_rb_tree);
}
void test__rb_tree_iterator_next__null_tree(void** state)
{
    _rb_tree_t* pt_rb_tree = _create_rb_tree("int");
    _rb_tree_iterator_t it_iter;
    _rb_tree_init(pt_rb_tree, NULL);

    it_iter = _rb_tree_begin(pt_rb_tree);

    it_iter._t_pos._t_treepos._pt_tree = NULL;
    expect_assert_failure(_rb_tree_iterator_next(it_iter));

    _rb_tree_destroy(pt_rb_tree);
}
Beispiel #5
0
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
}
void test__rb_tree_iterator_next__last(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_begin(pt_rb_tree);

    it_iter = _rb_tree_iterator_next(it_iter);
    assert_true(_rb_tree_iterator_equal(it_iter, _rb_tree_end(pt_rb_tree)));

    _rb_tree_destroy(pt_rb_tree);
}
void test__rb_tree_iterator_before__true(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);
    elem = 2;
    _rb_tree_insert_unique(pt_rb_tree, &elem);
    it_first = _rb_tree_begin(pt_rb_tree);
    it_second = _rb_tree_iterator_next(it_first);
    assert_true(_rb_tree_iterator_before(it_first, it_second));

    _rb_tree_destroy(pt_rb_tree);
}
void test__rb_tree_iterator_next__begin(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);
    elem = 3;
    _rb_tree_insert_unique(pt_rb_tree, &elem);
    it_iter = _rb_tree_begin(pt_rb_tree);
    assert_true(*(int*)_rb_tree_iterator_get_pointer(it_iter) == 3);
    it_iter = _rb_tree_iterator_next(it_iter);
    assert_true(*(int*)_rb_tree_iterator_get_pointer(it_iter) == 10);

    _rb_tree_destroy(pt_rb_tree);
}
/**
 * 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;
    }
}