diff --git a/src/cmc/treeset.h b/src/cmc/treeset.h index 3bd0389..2c2a103 100644 --- a/src/cmc/treeset.h +++ b/src/cmc/treeset.h @@ -72,12 +72,6 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " \ /* Custom callback functions */ \ struct cmc_callbacks *callbacks; \ - \ - /* Function that returns an iterator to the start of the treeset */ \ - struct SNAME##_iter (*it_start)(struct SNAME *); \ - \ - /* Function that returns an iterator to the end of the treeset */ \ - struct SNAME##_iter (*it_end)(struct SNAME *); \ }; \ \ /* Treeset Node */ \ @@ -189,17 +183,15 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " bool PFX##_is_disjointset(struct SNAME *_set1_, struct SNAME *_set2_); \ \ /* Iterator Functions */ \ - /* Iterator Allocation and Deallocation */ \ - struct SNAME##_iter *PFX##_iter_new(struct SNAME *target); \ - void PFX##_iter_free(struct SNAME##_iter *iter); \ /* Iterator Initialization */ \ - void PFX##_iter_init(struct SNAME##_iter *iter, struct SNAME *target); \ + struct SNAME##_iter PFX##_iter_start(struct SNAME *target); \ + struct SNAME##_iter PFX##_iter_end(struct SNAME *target); \ /* Iterator State */ \ - bool PFX##_iter_start(struct SNAME##_iter *iter); \ - bool PFX##_iter_end(struct SNAME##_iter *iter); \ + bool PFX##_iter_at_start(struct SNAME##_iter *iter); \ + bool PFX##_iter_at_end(struct SNAME##_iter *iter); \ /* Iterator Movement */ \ - void PFX##_iter_to_start(struct SNAME##_iter *iter); \ - void PFX##_iter_to_end(struct SNAME##_iter *iter); \ + bool PFX##_iter_to_start(struct SNAME##_iter *iter); \ + bool PFX##_iter_to_end(struct SNAME##_iter *iter); \ bool PFX##_iter_next(struct SNAME##_iter *iter); \ bool PFX##_iter_prev(struct SNAME##_iter *iter); \ bool PFX##_iter_advance(struct SNAME##_iter *iter, size_t steps); \ @@ -235,8 +227,6 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " static void PFX##_impl_rotate_left(struct SNAME##_node **Z); \ static void PFX##_impl_rebalance(struct SNAME *_set_, \ struct SNAME##_node *node); \ - static struct SNAME##_iter PFX##_impl_it_start(struct SNAME *_set_); \ - static struct SNAME##_iter PFX##_impl_it_end(struct SNAME *_set_); \ \ struct SNAME *PFX##_new(struct SNAME##_fval *f_val) \ { \ @@ -256,8 +246,6 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " _set_->f_val = f_val; \ _set_->alloc = alloc; \ _set_->callbacks = NULL; \ - _set_->it_start = PFX##_impl_it_start; \ - _set_->it_end = PFX##_impl_it_end; \ \ return _set_; \ } \ @@ -283,8 +271,6 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " _set_->f_val = f_val; \ _set_->alloc = alloc; \ _set_->callbacks = callbacks; \ - _set_->it_start = PFX##_impl_it_start; \ - _set_->it_end = PFX##_impl_it_end; \ \ return _set_; \ } \ @@ -662,13 +648,11 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " return NULL; \ } \ \ - struct SNAME##_iter iter; \ - PFX##_iter_init(&iter, _set_); \ - \ if (!PFX##_empty(_set_)) \ { \ - for (PFX##_iter_to_start(&iter); !PFX##_iter_end(&iter); \ - PFX##_iter_next(&iter)) \ + struct SNAME##_iter iter = PFX##_iter_start(_set_); \ + \ + for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ { \ if (_set_->f_val->cpy) \ PFX##_insert(result, \ @@ -691,11 +675,9 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " if (_set1_->count != _set2_->count) \ return false; \ \ - struct SNAME##_iter iter; \ - PFX##_iter_init(&iter, _set1_); \ + struct SNAME##_iter iter = PFX##_iter_start(_set1_); \ \ - for (PFX##_iter_to_start(&iter); !PFX##_iter_end(&iter); \ - PFX##_iter_next(&iter)) \ + for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ { \ if (PFX##_impl_get_node(_set2_, PFX##_iter_value(&iter)) == NULL) \ return false; \ @@ -765,18 +747,15 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " if (!_set_r_) \ return NULL; \ \ - struct SNAME##_iter iter1, iter2; \ - PFX##_iter_init(&iter1, _set1_); \ - PFX##_iter_init(&iter2, _set2_); \ + struct SNAME##_iter iter1 = PFX##_iter_start(_set1_); \ + struct SNAME##_iter iter2 = PFX##_iter_start(_set2_); \ \ - for (PFX##_iter_to_start(&iter1); !PFX##_iter_end(&iter1); \ - PFX##_iter_next(&iter1)) \ + for (; !PFX##_iter_at_end(&iter1); PFX##_iter_next(&iter1)) \ { \ PFX##_insert(_set_r_, PFX##_iter_value(&iter1)); \ } \ \ - for (PFX##_iter_to_start(&iter2); !PFX##_iter_end(&iter2); \ - PFX##_iter_next(&iter2)) \ + for (; !PFX##_iter_at_end(&iter2); PFX##_iter_next(&iter2)) \ { \ PFX##_insert(_set_r_, PFX##_iter_value(&iter2)); \ } \ @@ -793,15 +772,14 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " if (!_set_r_) \ return NULL; \ \ + /** TODO Should this compare count or capacity? */ \ struct SNAME *_set_A_ = \ _set1_->count < _set2_->count ? _set1_ : _set2_; \ struct SNAME *_set_B_ = _set_A_ == _set1_ ? _set2_ : _set1_; \ \ - struct SNAME##_iter iter; \ - PFX##_iter_init(&iter, _set_A_); \ + struct SNAME##_iter iter = PFX##_iter_start(_set_A_); \ \ - for (PFX##_iter_to_start(&iter); !PFX##_iter_end(&iter); \ - PFX##_iter_next(&iter)) \ + for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ { \ V value = PFX##_iter_value(&iter); \ \ @@ -820,11 +798,9 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " if (!_set_r_) \ return NULL; \ \ - struct SNAME##_iter iter; \ - PFX##_iter_init(&iter, _set1_); \ + struct SNAME##_iter iter = PFX##_iter_start(_set1_); \ \ - for (PFX##_iter_to_start(&iter); !PFX##_iter_end(&iter); \ - PFX##_iter_next(&iter)) \ + for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ { \ V value = PFX##_iter_value(&iter); \ \ @@ -844,12 +820,10 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " if (!_set_r_) \ return NULL; \ \ - struct SNAME##_iter iter1, iter2; \ - PFX##_iter_init(&iter1, _set1_); \ - PFX##_iter_init(&iter2, _set2_); \ + struct SNAME##_iter iter1 = PFX##_iter_start(_set1_); \ + struct SNAME##_iter iter2 = PFX##_iter_start(_set2_); \ \ - for (PFX##_iter_to_start(&iter1); !PFX##_iter_end(&iter1); \ - PFX##_iter_next(&iter1)) \ + for (; !PFX##_iter_at_end(&iter1); PFX##_iter_next(&iter1)) \ { \ V value = PFX##_iter_value(&iter1); \ \ @@ -857,8 +831,7 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " PFX##_insert(_set_r_, value); \ } \ \ - for (PFX##_iter_to_start(&iter2); !PFX##_iter_end(&iter2); \ - PFX##_iter_next(&iter2)) \ + for (; !PFX##_iter_at_end(&iter2); PFX##_iter_next(&iter2)) \ { \ V value = PFX##_iter_value(&iter2); \ \ @@ -883,12 +856,9 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " if (PFX##_empty(_set1_)) \ return true; \ \ - struct SNAME##_iter iter; \ + struct SNAME##_iter iter = PFX##_iter_start(_set1_); \ \ - PFX##_iter_init(&iter, _set1_); \ - \ - for (PFX##_iter_to_start(&iter); !PFX##_iter_end(&iter); \ - PFX##_iter_next(&iter)) \ + for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ { \ V value = PFX##_iter_value(&iter); \ \ @@ -929,12 +899,9 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " return false; \ } \ \ - struct SNAME##_iter iter; \ + struct SNAME##_iter iter = PFX##_iter_start(_set1_); \ \ - PFX##_iter_init(&iter, _set1_); \ - \ - for (PFX##_iter_to_start(&iter); !PFX##_iter_end(&iter); \ - PFX##_iter_next(&iter)) \ + for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ { \ V value = PFX##_iter_value(&iter); \ \ @@ -963,12 +930,9 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " if (PFX##_empty(_set1_)) \ return true; \ \ - struct SNAME##_iter iter; \ + struct SNAME##_iter iter = PFX##_iter_start(_set1_); \ \ - PFX##_iter_init(&iter, _set1_); \ - \ - for (PFX##_iter_to_start(&iter); !PFX##_iter_end(&iter); \ - PFX##_iter_next(&iter)) \ + for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ { \ V value = PFX##_iter_value(&iter); \ \ @@ -979,58 +943,73 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " return true; \ } \ \ - struct SNAME##_iter *PFX##_iter_new(struct SNAME *target) \ + struct SNAME##_iter PFX##_iter_start(struct SNAME *target) \ { \ - struct SNAME##_iter *iter = \ - target->alloc->malloc(sizeof(struct SNAME##_iter)); \ + struct SNAME##_iter iter; \ \ - if (!iter) \ - return NULL; \ + iter.target = target; \ + iter.cursor = target->root; \ + iter.first = NULL; \ + iter.last = NULL; \ + iter.index = 0; \ + iter.start = true; \ + iter.end = PFX##_empty(target); \ \ - PFX##_iter_init(iter, target); \ + if (!PFX##_empty(target)) \ + { \ + while (iter.cursor->left != NULL) \ + iter.cursor = iter.cursor->left; \ + \ + iter.first = iter.cursor; \ + \ + iter.last = target->root; \ + while (iter.last->right != NULL) \ + iter.last = iter.last->right; \ + } \ \ return iter; \ } \ \ - void PFX##_iter_free(struct SNAME##_iter *iter) \ + struct SNAME##_iter PFX##_iter_end(struct SNAME *target) \ { \ - iter->target->alloc->free(iter); \ - } \ + struct SNAME##_iter iter; \ \ - void PFX##_iter_init(struct SNAME##_iter *iter, struct SNAME *target) \ - { \ - memset(iter, 0, sizeof(struct SNAME##_iter)); \ - \ - iter->target = target; \ - iter->start = true; \ - iter->end = PFX##_empty(target); \ - \ - iter->cursor = target->root; \ + iter.target = target; \ + iter.cursor = target->root; \ + iter.first = NULL; \ + iter.last = NULL; \ + iter.index = 0; \ + iter.start = PFX##_empty(target); \ + iter.end = true; \ \ if (!PFX##_empty(target)) \ { \ - while (iter->cursor->left != NULL) \ - iter->cursor = iter->cursor->left; \ + while (iter.cursor->right != NULL) \ + iter.cursor = iter.cursor->right; \ \ - iter->first = iter->cursor; \ + iter.last = iter.cursor; \ \ - iter->last = target->root; \ - while (iter->last->right != NULL) \ - iter->last = iter->last->right; \ + iter.first = target->root; \ + while (iter.first->left != NULL) \ + iter.first = iter.first->left; \ + \ + iter.index = target->count - 1; \ } \ + \ + return iter; \ } \ \ - bool PFX##_iter_start(struct SNAME##_iter *iter) \ + bool PFX##_iter_at_start(struct SNAME##_iter *iter) \ { \ return PFX##_empty(iter->target) || iter->start; \ } \ \ - bool PFX##_iter_end(struct SNAME##_iter *iter) \ + bool PFX##_iter_at_end(struct SNAME##_iter *iter) \ { \ return PFX##_empty(iter->target) || iter->end; \ } \ \ - void PFX##_iter_to_start(struct SNAME##_iter *iter) \ + bool PFX##_iter_to_start(struct SNAME##_iter *iter) \ { \ if (!PFX##_empty(iter->target)) \ { \ @@ -1038,10 +1017,14 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " iter->start = true; \ iter->end = PFX##_empty(iter->target); \ iter->cursor = iter->first; \ + \ + return true; \ } \ + \ + return false; \ } \ \ - void PFX##_iter_to_end(struct SNAME##_iter *iter) \ + bool PFX##_iter_to_end(struct SNAME##_iter *iter) \ { \ if (!PFX##_empty(iter->target)) \ { \ @@ -1049,7 +1032,11 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " iter->start = PFX##_empty(iter->target); \ iter->end = true; \ iter->cursor = iter->last; \ + \ + return true; \ } \ + \ + return false; \ } \ \ bool PFX##_iter_next(struct SNAME##_iter *iter) \ @@ -1060,7 +1047,7 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " if (iter->cursor == iter->last) \ { \ iter->end = true; \ - return true; \ + return false; \ } \ \ iter->start = PFX##_empty(iter->target); \ @@ -1100,8 +1087,7 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " if (iter->cursor == iter->first) \ { \ iter->start = true; \ - \ - return true; \ + return false; \ } \ \ iter->end = PFX##_empty(iter->target); \ @@ -1148,8 +1134,6 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " if (steps == 0 || iter->index + steps >= iter->target->count) \ return false; \ \ - iter->index += steps; \ - \ for (size_t i = 0; i < steps; i++) \ PFX##_iter_next(iter); \ \ @@ -1171,8 +1155,6 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " if (steps == 0 || iter->index < steps) \ return false; \ \ - iter->index -= steps; \ - \ for (size_t i = 0; i < steps; i++) \ PFX##_iter_prev(iter); \ \ @@ -1363,25 +1345,6 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " \ scan = scan->parent; \ } \ - } \ - \ - static struct SNAME##_iter PFX##_impl_it_start(struct SNAME *_set_) \ - { \ - struct SNAME##_iter iter; \ - \ - PFX##_iter_init(&iter, _set_); \ - \ - return iter; \ - } \ - \ - static struct SNAME##_iter PFX##_impl_it_end(struct SNAME *_set_) \ - { \ - struct SNAME##_iter iter; \ - \ - PFX##_iter_init(&iter, _set_); \ - PFX##_iter_to_end(&iter); \ - \ - return iter; \ } #endif /* CMC_TREESET_H */ diff --git a/tests/main/src/treeset.c b/tests/main/src/treeset.c index 1d60900..3738567 100644 --- a/tests/main/src/treeset.c +++ b/tests/main/src/treeset.c @@ -8,8 +8,6 @@ struct treeset struct treeset_fval *f_val; struct cmc_alloc_node *alloc; struct cmc_callbacks *callbacks; - struct treeset_iter (*it_start)(struct treeset *); - struct treeset_iter (*it_end)(struct treeset *); }; struct treeset_node { @@ -68,13 +66,12 @@ _Bool ts_is_superset(struct treeset *_set1_, struct treeset *_set2_); _Bool ts_is_proper_subset(struct treeset *_set1_, struct treeset *_set2_); _Bool ts_is_proper_superset(struct treeset *_set1_, struct treeset *_set2_); _Bool ts_is_disjointset(struct treeset *_set1_, struct treeset *_set2_); -struct treeset_iter *ts_iter_new(struct treeset *target); -void ts_iter_free(struct treeset_iter *iter); -void ts_iter_init(struct treeset_iter *iter, struct treeset *target); -_Bool ts_iter_start(struct treeset_iter *iter); -_Bool ts_iter_end(struct treeset_iter *iter); -void ts_iter_to_start(struct treeset_iter *iter); -void ts_iter_to_end(struct treeset_iter *iter); +struct treeset_iter ts_iter_start(struct treeset *target); +struct treeset_iter ts_iter_end(struct treeset *target); +_Bool ts_iter_at_start(struct treeset_iter *iter); +_Bool ts_iter_at_end(struct treeset_iter *iter); +_Bool ts_iter_to_start(struct treeset_iter *iter); +_Bool ts_iter_to_end(struct treeset_iter *iter); _Bool ts_iter_next(struct treeset_iter *iter); _Bool ts_iter_prev(struct treeset_iter *iter); _Bool ts_iter_advance(struct treeset_iter *iter, size_t steps); @@ -97,8 +94,6 @@ static unsigned char ts_impl_hupdate(struct treeset_node *node); static void ts_impl_rotate_right(struct treeset_node **Z); static void ts_impl_rotate_left(struct treeset_node **Z); static void ts_impl_rebalance(struct treeset *_set_, struct treeset_node *node); -static struct treeset_iter ts_impl_it_start(struct treeset *_set_); -static struct treeset_iter ts_impl_it_end(struct treeset *_set_); struct treeset *ts_new(struct treeset_fval *f_val) { if (!f_val) @@ -113,8 +108,6 @@ struct treeset *ts_new(struct treeset_fval *f_val) _set_->f_val = f_val; _set_->alloc = alloc; _set_->callbacks = ((void *)0); - _set_->it_start = ts_impl_it_start; - _set_->it_end = ts_impl_it_end; return _set_; } struct treeset *ts_new_custom(struct treeset_fval *f_val, @@ -134,8 +127,6 @@ struct treeset *ts_new_custom(struct treeset_fval *f_val, _set_->f_val = f_val; _set_->alloc = alloc; _set_->callbacks = callbacks; - _set_->it_start = ts_impl_it_start; - _set_->it_end = ts_impl_it_end; return _set_; } void ts_clear(struct treeset *_set_) @@ -435,11 +426,10 @@ struct treeset *ts_copy_of(struct treeset *_set_) _set_->flag = cmc_flags.ERROR; return ((void *)0); } - struct treeset_iter iter; - ts_iter_init(&iter, _set_); if (!ts_empty(_set_)) { - for (ts_iter_to_start(&iter); !ts_iter_end(&iter); ts_iter_next(&iter)) + struct treeset_iter iter = ts_iter_start(_set_); + for (; !ts_iter_at_end(&iter); ts_iter_next(&iter)) { if (_set_->f_val->cpy) ts_insert(result, _set_->f_val->cpy(ts_iter_value(&iter))); @@ -456,9 +446,8 @@ _Bool ts_equals(struct treeset *_set1_, struct treeset *_set2_) _set2_->flag = cmc_flags.OK; if (_set1_->count != _set2_->count) return 0; - struct treeset_iter iter; - ts_iter_init(&iter, _set1_); - for (ts_iter_to_start(&iter); !ts_iter_end(&iter); ts_iter_next(&iter)) + struct treeset_iter iter = ts_iter_start(_set1_); + for (; !ts_iter_at_end(&iter); ts_iter_next(&iter)) { if (ts_impl_get_node(_set2_, ts_iter_value(&iter)) == ((void *)0)) return 0; @@ -512,14 +501,13 @@ struct treeset *ts_union(struct treeset *_set1_, struct treeset *_set2_) ts_new_custom(_set1_->f_val, _set1_->alloc, _set1_->callbacks); if (!_set_r_) return ((void *)0); - struct treeset_iter iter1, iter2; - ts_iter_init(&iter1, _set1_); - ts_iter_init(&iter2, _set2_); - for (ts_iter_to_start(&iter1); !ts_iter_end(&iter1); ts_iter_next(&iter1)) + struct treeset_iter iter1 = ts_iter_start(_set1_); + struct treeset_iter iter2 = ts_iter_start(_set2_); + for (; !ts_iter_at_end(&iter1); ts_iter_next(&iter1)) { ts_insert(_set_r_, ts_iter_value(&iter1)); } - for (ts_iter_to_start(&iter2); !ts_iter_end(&iter2); ts_iter_next(&iter2)) + for (; !ts_iter_at_end(&iter2); ts_iter_next(&iter2)) { ts_insert(_set_r_, ts_iter_value(&iter2)); } @@ -533,9 +521,8 @@ struct treeset *ts_intersection(struct treeset *_set1_, struct treeset *_set2_) return ((void *)0); struct treeset *_set_A_ = _set1_->count < _set2_->count ? _set1_ : _set2_; struct treeset *_set_B_ = _set_A_ == _set1_ ? _set2_ : _set1_; - struct treeset_iter iter; - ts_iter_init(&iter, _set_A_); - for (ts_iter_to_start(&iter); !ts_iter_end(&iter); ts_iter_next(&iter)) + struct treeset_iter iter = ts_iter_start(_set_A_); + for (; !ts_iter_at_end(&iter); ts_iter_next(&iter)) { size_t value = ts_iter_value(&iter); if (ts_impl_get_node(_set_B_, value) != ((void *)0)) @@ -549,9 +536,8 @@ struct treeset *ts_difference(struct treeset *_set1_, struct treeset *_set2_) ts_new_custom(_set1_->f_val, _set1_->alloc, _set1_->callbacks); if (!_set_r_) return ((void *)0); - struct treeset_iter iter; - ts_iter_init(&iter, _set1_); - for (ts_iter_to_start(&iter); !ts_iter_end(&iter); ts_iter_next(&iter)) + struct treeset_iter iter = ts_iter_start(_set1_); + for (; !ts_iter_at_end(&iter); ts_iter_next(&iter)) { size_t value = ts_iter_value(&iter); if (ts_impl_get_node(_set2_, value) == ((void *)0)) @@ -566,16 +552,15 @@ struct treeset *ts_symmetric_difference(struct treeset *_set1_, ts_new_custom(_set1_->f_val, _set1_->alloc, _set1_->callbacks); if (!_set_r_) return ((void *)0); - struct treeset_iter iter1, iter2; - ts_iter_init(&iter1, _set1_); - ts_iter_init(&iter2, _set2_); - for (ts_iter_to_start(&iter1); !ts_iter_end(&iter1); ts_iter_next(&iter1)) + struct treeset_iter iter1 = ts_iter_start(_set1_); + struct treeset_iter iter2 = ts_iter_start(_set2_); + for (; !ts_iter_at_end(&iter1); ts_iter_next(&iter1)) { size_t value = ts_iter_value(&iter1); if (ts_impl_get_node(_set2_, value) == ((void *)0)) ts_insert(_set_r_, value); } - for (ts_iter_to_start(&iter2); !ts_iter_end(&iter2); ts_iter_next(&iter2)) + for (; !ts_iter_at_end(&iter2); ts_iter_next(&iter2)) { size_t value = ts_iter_value(&iter2); if (ts_impl_get_node(_set1_, value) == ((void *)0)) @@ -589,9 +574,8 @@ _Bool ts_is_subset(struct treeset *_set1_, struct treeset *_set2_) return 0; if (ts_empty(_set1_)) return 1; - struct treeset_iter iter; - ts_iter_init(&iter, _set1_); - for (ts_iter_to_start(&iter); !ts_iter_end(&iter); ts_iter_next(&iter)) + struct treeset_iter iter = ts_iter_start(_set1_); + for (; !ts_iter_at_end(&iter); ts_iter_next(&iter)) { size_t value = ts_iter_value(&iter); if (ts_impl_get_node(_set2_, value) == ((void *)0)) @@ -614,9 +598,8 @@ _Bool ts_is_proper_subset(struct treeset *_set1_, struct treeset *_set2_) else return 0; } - struct treeset_iter iter; - ts_iter_init(&iter, _set1_); - for (ts_iter_to_start(&iter); !ts_iter_end(&iter); ts_iter_next(&iter)) + struct treeset_iter iter = ts_iter_start(_set1_); + for (; !ts_iter_at_end(&iter); ts_iter_next(&iter)) { size_t value = ts_iter_value(&iter); if (ts_impl_get_node(_set2_, value) == ((void *)0)) @@ -632,9 +615,8 @@ _Bool ts_is_disjointset(struct treeset *_set1_, struct treeset *_set2_) { if (ts_empty(_set1_)) return 1; - struct treeset_iter iter; - ts_iter_init(&iter, _set1_); - for (ts_iter_to_start(&iter); !ts_iter_end(&iter); ts_iter_next(&iter)) + struct treeset_iter iter = ts_iter_start(_set1_); + for (; !ts_iter_at_end(&iter); ts_iter_next(&iter)) { size_t value = ts_iter_value(&iter); if (ts_impl_get_node(_set2_, value) != ((void *)0)) @@ -642,45 +624,58 @@ _Bool ts_is_disjointset(struct treeset *_set1_, struct treeset *_set2_) } return 1; } -struct treeset_iter *ts_iter_new(struct treeset *target) +struct treeset_iter ts_iter_start(struct treeset *target) { - struct treeset_iter *iter = - target->alloc->malloc(sizeof(struct treeset_iter)); - if (!iter) - return ((void *)0); - ts_iter_init(iter, target); - return iter; -} -void ts_iter_free(struct treeset_iter *iter) -{ - iter->target->alloc->free(iter); -} -void ts_iter_init(struct treeset_iter *iter, struct treeset *target) -{ - memset(iter, 0, sizeof(struct treeset_iter)); - iter->target = target; - iter->start = 1; - iter->end = ts_empty(target); - iter->cursor = target->root; + struct treeset_iter iter; + iter.target = target; + iter.cursor = target->root; + iter.first = ((void *)0); + iter.last = ((void *)0); + iter.index = 0; + iter.start = 1; + iter.end = ts_empty(target); if (!ts_empty(target)) { - while (iter->cursor->left != ((void *)0)) - iter->cursor = iter->cursor->left; - iter->first = iter->cursor; - iter->last = target->root; - while (iter->last->right != ((void *)0)) - iter->last = iter->last->right; + while (iter.cursor->left != ((void *)0)) + iter.cursor = iter.cursor->left; + iter.first = iter.cursor; + iter.last = target->root; + while (iter.last->right != ((void *)0)) + iter.last = iter.last->right; } + return iter; } -_Bool ts_iter_start(struct treeset_iter *iter) +struct treeset_iter ts_iter_end(struct treeset *target) +{ + struct treeset_iter iter; + iter.target = target; + iter.cursor = target->root; + iter.first = ((void *)0); + iter.last = ((void *)0); + iter.index = 0; + iter.start = ts_empty(target); + iter.end = 1; + if (!ts_empty(target)) + { + while (iter.cursor->right != ((void *)0)) + iter.cursor = iter.cursor->right; + iter.last = iter.cursor; + iter.first = target->root; + while (iter.first->left != ((void *)0)) + iter.first = iter.first->left; + iter.index = target->count - 1; + } + return iter; +} +_Bool ts_iter_at_start(struct treeset_iter *iter) { return ts_empty(iter->target) || iter->start; } -_Bool ts_iter_end(struct treeset_iter *iter) +_Bool ts_iter_at_end(struct treeset_iter *iter) { return ts_empty(iter->target) || iter->end; } -void ts_iter_to_start(struct treeset_iter *iter) +_Bool ts_iter_to_start(struct treeset_iter *iter) { if (!ts_empty(iter->target)) { @@ -688,9 +683,11 @@ void ts_iter_to_start(struct treeset_iter *iter) iter->start = 1; iter->end = ts_empty(iter->target); iter->cursor = iter->first; + return 1; } + return 0; } -void ts_iter_to_end(struct treeset_iter *iter) +_Bool ts_iter_to_end(struct treeset_iter *iter) { if (!ts_empty(iter->target)) { @@ -698,7 +695,9 @@ void ts_iter_to_end(struct treeset_iter *iter) iter->start = ts_empty(iter->target); iter->end = 1; iter->cursor = iter->last; + return 1; } + return 0; } _Bool ts_iter_next(struct treeset_iter *iter) { @@ -707,7 +706,7 @@ _Bool ts_iter_next(struct treeset_iter *iter) if (iter->cursor == iter->last) { iter->end = 1; - return 1; + return 0; } iter->start = ts_empty(iter->target); if (iter->cursor->right != ((void *)0)) @@ -736,7 +735,7 @@ _Bool ts_iter_prev(struct treeset_iter *iter) if (iter->cursor == iter->first) { iter->start = 1; - return 1; + return 0; } iter->end = ts_empty(iter->target); if (iter->cursor->left != ((void *)0)) @@ -769,7 +768,6 @@ _Bool ts_iter_advance(struct treeset_iter *iter, size_t steps) } if (steps == 0 || iter->index + steps >= iter->target->count) return 0; - iter->index += steps; for (size_t i = 0; i < steps; i++) ts_iter_next(iter); return 1; @@ -785,7 +783,6 @@ _Bool ts_iter_rewind(struct treeset_iter *iter, size_t steps) } if (steps == 0 || iter->index < steps) return 0; - iter->index -= steps; for (size_t i = 0; i < steps; i++) ts_iter_prev(iter); return 1; @@ -928,16 +925,3 @@ static void ts_impl_rebalance(struct treeset *_set_, struct treeset_node *node) scan = scan->parent; } } -static struct treeset_iter ts_impl_it_start(struct treeset *_set_) -{ - struct treeset_iter iter; - ts_iter_init(&iter, _set_); - return iter; -} -static struct treeset_iter ts_impl_it_end(struct treeset *_set_) -{ - struct treeset_iter iter; - ts_iter_init(&iter, _set_); - ts_iter_to_end(&iter); - return iter; -} diff --git a/tests/main/unt/treeset.c b/tests/main/unt/treeset.c index c2a4d49..8c35990 100644 --- a/tests/main/unt/treeset.c +++ b/tests/main/unt/treeset.c @@ -166,7 +166,407 @@ CMC_CREATE_UNIT(TreeSet, true, { }); CMC_CREATE_UNIT(TreeSetIter, true, { + CMC_CREATE_TEST(PFX##_iter_start(), { + struct treeset *set = ts_new(ts_fval); + cmc_assert_not_equals(ptr, NULL, set); + + struct treeset_iter it = ts_iter_start(set); + + cmc_assert_equals(ptr, set, it.target); + cmc_assert_equals(ptr, NULL, it.cursor); + cmc_assert_equals(ptr, NULL, it.first); + cmc_assert_equals(ptr, NULL, it.last); + cmc_assert_equals(size_t, 0, it.index); + cmc_assert_equals(bool, true, it.start); + cmc_assert_equals(bool, true, it.end); + + cmc_assert(ts_iter_at_start(&it)); + cmc_assert(ts_iter_at_end(&it)); + + cmc_assert(ts_insert(set, 1)); + cmc_assert(ts_insert(set, 2)); + cmc_assert(ts_insert(set, 3)); + + it = ts_iter_start(set); + + cmc_assert_equals(size_t, 0, it.index); + + cmc_assert_equals(size_t, 1, it.cursor->value); + cmc_assert_equals(size_t, 1, it.first->value); + cmc_assert_equals(size_t, 3, it.last->value); + cmc_assert_equals(bool, false, it.end); + + ts_free(set); + }); + + CMC_CREATE_TEST(PFX##_iter_end(), { + struct treeset *set = ts_new(ts_fval); + + cmc_assert_not_equals(ptr, NULL, set); + + struct treeset_iter it = ts_iter_end(set); + + cmc_assert_equals(ptr, set, it.target); + cmc_assert_equals(ptr, NULL, it.cursor); + cmc_assert_equals(ptr, NULL, it.first); + cmc_assert_equals(ptr, NULL, it.last); + cmc_assert_equals(size_t, 0, it.index); + cmc_assert_equals(bool, true, it.start); + cmc_assert_equals(bool, true, it.end); + + cmc_assert(ts_iter_at_start(&it)); + cmc_assert(ts_iter_at_end(&it)); + + cmc_assert(ts_insert(set, 1)); + cmc_assert(ts_insert(set, 2)); + cmc_assert(ts_insert(set, 3)); + + it = ts_iter_end(set); + + cmc_assert_equals(size_t, set->count - 1, it.index); + + cmc_assert_equals(size_t, 3, it.cursor->value); + cmc_assert_equals(size_t, 1, it.first->value); + cmc_assert_equals(size_t, 3, it.last->value); + cmc_assert_equals(bool, false, it.start); + + ts_free(set); + }); + + CMC_CREATE_TEST(PFX##_iter_at_start(), { + struct treeset *set = ts_new(ts_fval); + + cmc_assert_not_equals(ptr, NULL, set); + + struct treeset_iter it = ts_iter_start(set); + + // Empty checks + cmc_assert(ts_iter_at_start(&it)); + it = ts_iter_end(set); + cmc_assert(ts_iter_at_start(&it)); + + // Non-empty checks + cmc_assert(ts_insert(set, 1)); + cmc_assert(ts_insert(set, 2)); + it = ts_iter_end(set); + cmc_assert(!ts_iter_at_start(&it)); + it = ts_iter_start(set); + cmc_assert(ts_iter_at_start(&it)); + + ts_free(set); + }); + + CMC_CREATE_TEST(PFX##_iter_at_end(), { + struct treeset *set = ts_new(ts_fval); + + cmc_assert_not_equals(ptr, NULL, set); + + struct treeset_iter it = ts_iter_start(set); + + // Empty check + cmc_assert(ts_iter_at_end(&it)); + it = ts_iter_end(set); + cmc_assert(ts_iter_at_end(&it)); + + // Non-empty checks + cmc_assert(ts_insert(set, 1)); + cmc_assert(ts_insert(set, 2)); + it = ts_iter_end(set); + cmc_assert(ts_iter_at_end(&it)); + it = ts_iter_start(set); + cmc_assert(!ts_iter_at_end(&it)); + + ts_free(set); + }); + + CMC_CREATE_TEST(PFX##_iter_to_start(), { + struct treeset *set = ts_new(ts_fval); + + cmc_assert_not_equals(ptr, NULL, set); + + struct treeset_iter it = ts_iter_start(set); + + cmc_assert(!ts_iter_to_start(&it)); + + for (size_t i = 1; i <= 100; i++) + ts_insert(set, i); + + cmc_assert_equals(size_t, 100, set->count); + + it = ts_iter_end(set); + + cmc_assert(!ts_iter_at_start(&it)); + cmc_assert(ts_iter_at_end(&it)); + + cmc_assert_equals(size_t, 100, ts_iter_value(&it)); + + cmc_assert(ts_iter_to_start(&it)); + + cmc_assert(ts_iter_at_start(&it)); + cmc_assert(!ts_iter_at_end(&it)); + + cmc_assert_equals(size_t, 1, ts_iter_value(&it)); + + ts_free(set); + }); + + CMC_CREATE_TEST(PFX##_iter_to_end(), { + struct treeset *set = ts_new(ts_fval); + + cmc_assert_not_equals(ptr, NULL, set); + + struct treeset_iter it = ts_iter_end(set); + + cmc_assert(!ts_iter_to_end(&it)); + + for (size_t i = 1; i <= 100; i++) + ts_insert(set, i); + + it = ts_iter_start(set); + + cmc_assert(ts_iter_at_start(&it)); + cmc_assert(!ts_iter_at_end(&it)); + + cmc_assert_equals(size_t, 1, ts_iter_value(&it)); + + cmc_assert(ts_iter_to_end(&it)); + + cmc_assert(!ts_iter_at_start(&it)); + cmc_assert(ts_iter_at_end(&it)); + + cmc_assert_equals(size_t, 100, ts_iter_value(&it)); + + ts_free(set); + }); + + CMC_CREATE_TEST(PFX##_iter_next(), { + struct treeset *set = ts_new(ts_fval); + + cmc_assert_not_equals(ptr, NULL, set); + + struct treeset_iter it = ts_iter_start(set); + + cmc_assert(!ts_iter_next(&it)); + + for (size_t i = 1; i <= 1000; i++) + ts_insert(set, i); + + size_t sum = 0; + for (it = ts_iter_start(set); !ts_iter_at_end(&it); ts_iter_next(&it)) + { + sum += ts_iter_value(&it); + } + + cmc_assert_equals(size_t, 500500, sum); + + sum = 0; + + ts_iter_to_start(&it); + do + { + sum += ts_iter_value(&it); + } while (ts_iter_next(&it)); + + cmc_assert_equals(size_t, 500500, sum); + + ts_free(set); + }); + + CMC_CREATE_TEST(PFX##_iter_prev(), { + struct treeset *set = ts_new(ts_fval); + + cmc_assert_not_equals(ptr, NULL, set); + + struct treeset_iter it = ts_iter_end(set); + + cmc_assert(!ts_iter_prev(&it)); + + for (size_t i = 1; i <= 1000; i++) + ts_insert(set, i); + + size_t sum = 0; + for (it = ts_iter_end(set); !ts_iter_at_start(&it); ts_iter_prev(&it)) + { + sum += ts_iter_value(&it); + } + + cmc_assert_equals(size_t, 500500, sum); + + sum = 0; + + ts_iter_to_end(&it); + do + { + sum += ts_iter_value(&it); + } while (ts_iter_prev(&it)); + + cmc_assert_equals(size_t, 500500, sum); + + ts_free(set); + }); + + CMC_CREATE_TEST(PFX##_iter_advance(), { + struct treeset *set = ts_new(ts_fval); + + cmc_assert_not_equals(ptr, NULL, set); + + struct treeset_iter it = ts_iter_start(set); + + cmc_assert(!ts_iter_advance(&it, 1)); + + for (size_t i = 0; i <= 1000; i++) + ts_insert(set, i); + + it = ts_iter_start(set); + + cmc_assert(!ts_iter_advance(&it, 0)); + cmc_assert(!ts_iter_advance(&it, set->count)); + + size_t sum = 0; + for (it = ts_iter_start(set);;) + { + sum += ts_iter_value(&it); + + if (!ts_iter_advance(&it, 2)) + break; + } + + cmc_assert_equals(size_t, 250500, sum); + + ts_iter_to_start(&it); + cmc_assert(ts_iter_advance(&it, set->count - 1)); + + ts_free(set); + }); + + CMC_CREATE_TEST(PFX##_iter_rewind(), { + struct treeset *set = ts_new(ts_fval); + + cmc_assert_not_equals(ptr, NULL, set); + + struct treeset_iter it = ts_iter_end(set); + + cmc_assert(!ts_iter_rewind(&it, 1)); + + for (size_t i = 0; i <= 1000; i++) + ts_insert(set, i); + + it = ts_iter_end(set); + + cmc_assert(!ts_iter_rewind(&it, 0)); + cmc_assert(!ts_iter_rewind(&it, set->count)); + + size_t sum = 0; + for (it = ts_iter_end(set);;) + { + sum += ts_iter_value(&it); + + if (!ts_iter_rewind(&it, 2)) + break; + } + + cmc_assert_equals(size_t, 250500, sum); + + ts_iter_to_end(&it); + cmc_assert(ts_iter_rewind(&it, set->count - 1)); + + ts_free(set); + }); + + CMC_CREATE_TEST(PFX##_iter_go_to(), { + struct treeset *set = ts_new(ts_fval); + + cmc_assert_not_equals(ptr, NULL, set); + + struct treeset_iter it = ts_iter_end(set); + cmc_assert(!ts_iter_go_to(&it, 0)); + + it = ts_iter_start(set); + cmc_assert(!ts_iter_go_to(&it, 0)); + + for (size_t i = 0; i <= 1000; i++) + ts_insert(set, i); + + it = ts_iter_start(set); + + size_t sum = 0; + for (size_t i = 0; i < 1001; i++) + { + ts_iter_go_to(&it, i); + + sum += ts_iter_value(&it); + } + + cmc_assert_equals(size_t, 500500, sum); + + sum = 0; + for (size_t i = 1001; i > 0; i--) + { + cmc_assert(ts_iter_go_to(&it, i - 1)); + + sum += ts_iter_value(&it); + } + + cmc_assert_equals(size_t, 500500, sum); + + sum = 0; + for (size_t i = 0; i < 1001; i += 100) + { + cmc_assert(ts_iter_go_to(&it, i)); + cmc_assert_equals(size_t, i, ts_iter_index(&it)); + + sum += ts_iter_value(&it); + } + + cmc_assert_equals(size_t, 5500, sum); + + ts_free(set); + }); + + CMC_CREATE_TEST(PFX##_iter_value(), { + struct treeset *set = ts_new(ts_fval); + + cmc_assert_not_equals(ptr, NULL, set); + + struct treeset_iter it = ts_iter_end(set); + + cmc_assert_equals(size_t, (size_t){ 0 }, ts_iter_value(&it)); + + cmc_assert(ts_insert(set, 10)); + + it = ts_iter_start(set); + + cmc_assert_equals(size_t, 10, ts_iter_value(&it)); + + ts_free(set); + }); + + CMC_CREATE_TEST(PFX##_iter_index(), { + struct treeset *set = ts_new(ts_fval); + + cmc_assert_not_equals(ptr, NULL, set); + + for (size_t i = 0; i <= 1000; i++) + ts_insert(set, i); + + struct treeset_iter it = ts_iter_start(set); + + for (size_t i = 0; i < 1001; i++) + { + cmc_assert_equals(size_t, i, ts_iter_index(&it)); + ts_iter_next(&it); + } + + it = ts_iter_end(set); + for (size_t i = 1001; i > 0; i--) + { + cmc_assert_equals(size_t, i - 1, ts_iter_index(&it)); + ts_iter_prev(&it); + } + + ts_free(set); + }); }); #ifdef CMC_TEST_MAIN