diff --git a/src/cmc/hashmultiset.h b/src/cmc/hashmultiset.h index 6344058..af34c17 100644 --- a/src/cmc/hashmultiset.h +++ b/src/cmc/hashmultiset.h @@ -96,12 +96,6 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " \ /* Custom callback functions */ \ struct cmc_callbacks *callbacks; \ - \ - /* Returns an iterator to the start of the hashmultiset */ \ - struct SNAME##_iter (*it_start)(struct SNAME *); \ - \ - /* Returns an iterator to the end of the hashmultiset */ \ - struct SNAME##_iter (*it_end)(struct SNAME *); \ }; \ \ struct SNAME##_entry \ @@ -221,17 +215,15 @@ static const char *cmc_string_fmt_hashmultiset = "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); \ @@ -254,8 +246,6 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " static struct SNAME##_entry *PFX##_impl_get_entry(struct SNAME *_set_, \ V value); \ static size_t PFX##_impl_calculate_size(size_t required); \ - 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(size_t capacity, double load, \ struct SNAME##_fval *f_val) \ @@ -296,8 +286,6 @@ static const char *cmc_string_fmt_hashmultiset = "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_; \ } \ @@ -343,8 +331,6 @@ static const char *cmc_string_fmt_hashmultiset = "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_; \ } \ @@ -588,11 +574,10 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " } \ \ V max_val; \ - struct SNAME##_iter iter; \ + struct SNAME##_iter iter = PFX##_iter_start(_set_); \ \ /* TODO transform this into a normal loop */ \ - for (PFX##_iter_init(&iter, _set_); !PFX##_iter_end(&iter); \ - PFX##_iter_next(&iter)) \ + for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ { \ V result = PFX##_iter_value(&iter); \ size_t index = PFX##_iter_index(&iter); \ @@ -623,11 +608,10 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " } \ \ V min_val; \ - struct SNAME##_iter iter; \ + struct SNAME##_iter iter = PFX##_iter_start(_set_); \ \ /* TODO transform this into a normal loop */ \ - for (PFX##_iter_init(&iter, _set_); !PFX##_iter_end(&iter); \ - PFX##_iter_next(&iter)) \ + for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ { \ V result = PFX##_iter_value(&iter); \ size_t index = PFX##_iter_index(&iter); \ @@ -748,11 +732,10 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return false; \ } \ \ - struct SNAME##_iter iter; \ + struct SNAME##_iter iter = PFX##_iter_start(_set_); \ \ /* TODO transform this into a normal loop */ \ - for (PFX##_iter_init(&iter, _set_); !PFX##_iter_end(&iter); \ - PFX##_iter_next(&iter)) \ + for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ { \ PFX##_insert_many(_new_set_, PFX##_iter_value(&iter), \ PFX##_iter_multiplicity(&iter)); \ @@ -848,11 +831,9 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " if (_set1_->count == 0) \ return true; \ \ - 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)) \ { \ struct SNAME##_entry *entry = \ PFX##_impl_get_entry(_set2_, PFX##_iter_value(&iter)); \ @@ -906,12 +887,10 @@ static const char *cmc_string_fmt_hashmultiset = "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); \ \ @@ -922,8 +901,7 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " PFX##_update(_set_r_, value, max_); \ } \ \ - 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); \ \ @@ -954,11 +932,9 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " _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); \ \ @@ -984,11 +960,9 @@ static const char *cmc_string_fmt_hashmultiset = "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); \ \ @@ -1014,19 +988,16 @@ static const char *cmc_string_fmt_hashmultiset = "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_many(_set_r_, PFX##_iter_value(&iter1), \ PFX##_iter_multiplicity(&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_many(_set_r_, PFX##_iter_value(&iter2), \ PFX##_iter_multiplicity(&iter2)); \ @@ -1047,14 +1018,10 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " \ if (!_set_r_) \ return NULL; \ + struct SNAME##_iter iter1 = PFX##_iter_start(_set1_); \ + struct SNAME##_iter iter2 = PFX##_iter_start(_set2_); \ \ - struct SNAME##_iter iter1, iter2; \ - \ - PFX##_iter_init(&iter1, _set1_); \ - PFX##_iter_init(&iter2, _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); \ \ @@ -1070,8 +1037,7 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " } \ } \ \ - 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); \ \ @@ -1100,12 +1066,9 @@ static const char *cmc_string_fmt_hashmultiset = "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); \ \ @@ -1137,12 +1100,9 @@ static const char *cmc_string_fmt_hashmultiset = "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); \ \ @@ -1166,12 +1126,9 @@ static const char *cmc_string_fmt_hashmultiset = "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); \ \ @@ -1182,31 +1139,17 @@ static const char *cmc_string_fmt_hashmultiset = "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; \ - \ - PFX##_iter_init(iter, target); \ - \ - return iter; \ - } \ - \ - void PFX##_iter_free(struct SNAME##_iter *iter) \ - { \ - iter->target->alloc->free(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.target = target; \ + iter.cursor = 0; \ + iter.index = 0; \ + iter.first = 0; \ + iter.last = 0; \ + iter.start = true; \ + iter.end = PFX##_empty(target); \ \ if (!PFX##_empty(target)) \ { \ @@ -1214,35 +1157,76 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " { \ if (target->buffer[i].state == CMC_ES_FILLED) \ { \ - iter->first = i; \ + iter.first = i; \ break; \ } \ } \ \ - iter->cursor = iter->first; \ + iter.cursor = iter.first; \ \ for (size_t i = target->capacity; i > 0; i--) \ { \ if (target->buffer[i - 1].state == CMC_ES_FILLED) \ { \ - iter->last = i - 1; \ + iter.last = i - 1; \ break; \ } \ } \ } \ + \ + return iter; \ } \ \ - bool PFX##_iter_start(struct SNAME##_iter *iter) \ + struct SNAME##_iter PFX##_iter_end(struct SNAME *target) \ + { \ + struct SNAME##_iter iter; \ + \ + iter.target = target; \ + iter.cursor = 0; \ + iter.index = 0; \ + iter.first = 0; \ + iter.last = 0; \ + iter.start = PFX##_empty(target); \ + iter.end = true; \ + \ + if (!PFX##_empty(target)) \ + { \ + for (size_t i = 0; i < target->capacity; i++) \ + { \ + if (target->buffer[i].state == CMC_ES_FILLED) \ + { \ + iter.first = i; \ + break; \ + } \ + } \ + \ + for (size_t i = target->capacity; i > 0; i--) \ + { \ + if (target->buffer[i - 1].state == CMC_ES_FILLED) \ + { \ + iter.last = i - 1; \ + break; \ + } \ + } \ + \ + iter.cursor = iter.last; \ + iter.index = target->count - 1; \ + } \ + \ + return 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)) \ { \ @@ -1250,10 +1234,14 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " iter->index = 0; \ iter->start = true; \ iter->end = PFX##_empty(iter->target); \ + \ + 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)) \ { \ @@ -1261,7 +1249,11 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " iter->index = iter->target->count - 1; \ iter->start = PFX##_empty(iter->target); \ iter->end = true; \ + \ + return true; \ } \ + \ + return false; \ } \ \ bool PFX##_iter_next(struct SNAME##_iter *iter) \ @@ -1521,25 +1513,6 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " i++; \ \ return cmc_hashtable_primes[i]; \ - } \ - \ - 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_HASHMULTISET_H */ diff --git a/tests/main/main.c b/tests/main/main.c index bdfd234..f72ebca 100644 --- a/tests/main/main.c +++ b/tests/main/main.c @@ -57,6 +57,7 @@ int main(void) cmc_run(HashMultiMap, units, tests); cmc_run(HashMultiMapIter, units, tests); cmc_run(HashMultiSet, units, tests); + cmc_run(HashMultiSetIter, units, tests); cmc_run(HashSet, units, tests); cmc_run(Heap, units, tests); cmc_run(IntervalHeap, units, tests); diff --git a/tests/main/src/hashmultiset.c b/tests/main/src/hashmultiset.c index dc709c8..a8e2616 100644 --- a/tests/main/src/hashmultiset.c +++ b/tests/main/src/hashmultiset.c @@ -11,8 +11,6 @@ struct hashmultiset struct hashmultiset_fval *f_val; struct cmc_alloc_node *alloc; struct cmc_callbacks *callbacks; - struct hashmultiset_iter (*it_start)(struct hashmultiset *); - struct hashmultiset_iter (*it_end)(struct hashmultiset *); }; struct hashmultiset_entry { @@ -89,13 +87,12 @@ _Bool hms_is_proper_superset(struct hashmultiset *_set1_, struct hashmultiset *_set2_); _Bool hms_is_disjointset(struct hashmultiset *_set1_, struct hashmultiset *_set2_); -struct hashmultiset_iter *hms_iter_new(struct hashmultiset *target); -void hms_iter_free(struct hashmultiset_iter *iter); -void hms_iter_init(struct hashmultiset_iter *iter, struct hashmultiset *target); -_Bool hms_iter_start(struct hashmultiset_iter *iter); -_Bool hms_iter_end(struct hashmultiset_iter *iter); -void hms_iter_to_start(struct hashmultiset_iter *iter); -void hms_iter_to_end(struct hashmultiset_iter *iter); +struct hashmultiset_iter hms_iter_start(struct hashmultiset *target); +struct hashmultiset_iter hms_iter_end(struct hashmultiset *target); +_Bool hms_iter_at_start(struct hashmultiset_iter *iter); +_Bool hms_iter_at_end(struct hashmultiset_iter *iter); +_Bool hms_iter_to_start(struct hashmultiset_iter *iter); +_Bool hms_iter_to_end(struct hashmultiset_iter *iter); _Bool hms_iter_next(struct hashmultiset_iter *iter); _Bool hms_iter_prev(struct hashmultiset_iter *iter); _Bool hms_iter_advance(struct hashmultiset_iter *iter, size_t steps); @@ -112,8 +109,6 @@ hms_impl_insert_and_return(struct hashmultiset *_set_, size_t value, static struct hashmultiset_entry *hms_impl_get_entry(struct hashmultiset *_set_, size_t value); static size_t hms_impl_calculate_size(size_t required); -static struct hashmultiset_iter hms_impl_it_start(struct hashmultiset *_set_); -static struct hashmultiset_iter hms_impl_it_end(struct hashmultiset *_set_); struct hashmultiset *hms_new(size_t capacity, double load, struct hashmultiset_fval *f_val) { @@ -143,8 +138,6 @@ struct hashmultiset *hms_new(size_t capacity, double load, _set_->f_val = f_val; _set_->alloc = alloc; _set_->callbacks = ((void *)0); - _set_->it_start = hms_impl_it_start; - _set_->it_end = hms_impl_it_end; return _set_; } struct hashmultiset *hms_new_custom(size_t capacity, double load, @@ -179,8 +172,6 @@ struct hashmultiset *hms_new_custom(size_t capacity, double load, _set_->f_val = f_val; _set_->alloc = alloc; _set_->callbacks = callbacks; - _set_->it_start = hms_impl_it_start; - _set_->it_end = hms_impl_it_end; return _set_; } void hms_clear(struct hashmultiset *_set_) @@ -361,9 +352,8 @@ _Bool hms_max(struct hashmultiset *_set_, size_t *value) return 0; } size_t max_val; - struct hashmultiset_iter iter; - for (hms_iter_init(&iter, _set_); !hms_iter_end(&iter); - hms_iter_next(&iter)) + struct hashmultiset_iter iter = hms_iter_start(_set_); + for (; !hms_iter_at_end(&iter); hms_iter_next(&iter)) { size_t result = hms_iter_value(&iter); size_t index = hms_iter_index(&iter); @@ -387,9 +377,8 @@ _Bool hms_min(struct hashmultiset *_set_, size_t *value) return 0; } size_t min_val; - struct hashmultiset_iter iter; - for (hms_iter_init(&iter, _set_); !hms_iter_end(&iter); - hms_iter_next(&iter)) + struct hashmultiset_iter iter = hms_iter_start(_set_); + for (; !hms_iter_at_end(&iter); hms_iter_next(&iter)) { size_t result = hms_iter_value(&iter); size_t index = hms_iter_index(&iter); @@ -476,9 +465,8 @@ _Bool hms_resize(struct hashmultiset *_set_, size_t capacity) _set_->flag = cmc_flags.ERROR; return 0; } - struct hashmultiset_iter iter; - for (hms_iter_init(&iter, _set_); !hms_iter_end(&iter); - hms_iter_next(&iter)) + struct hashmultiset_iter iter = hms_iter_start(_set_); + for (; !hms_iter_at_end(&iter); hms_iter_next(&iter)) { hms_insert_many(_new_set_, hms_iter_value(&iter), hms_iter_multiplicity(&iter)); @@ -550,9 +538,8 @@ _Bool hms_equals(struct hashmultiset *_set1_, struct hashmultiset *_set2_) return 0; if (_set1_->count == 0) return 1; - struct hashmultiset_iter iter; - hms_iter_init(&iter, _set1_); - for (hms_iter_to_start(&iter); !hms_iter_end(&iter); hms_iter_next(&iter)) + struct hashmultiset_iter iter = hms_iter_start(_set1_); + for (; !hms_iter_at_end(&iter); hms_iter_next(&iter)) { struct hashmultiset_entry *entry = hms_impl_get_entry(_set2_, hms_iter_value(&iter)); @@ -594,11 +581,9 @@ struct hashmultiset *hms_union(struct hashmultiset *_set1_, _set1_->alloc, ((void *)0)); if (!_set_r_) return ((void *)0); - struct hashmultiset_iter iter1, iter2; - hms_iter_init(&iter1, _set1_); - hms_iter_init(&iter2, _set2_); - for (hms_iter_to_start(&iter1); !hms_iter_end(&iter1); - hms_iter_next(&iter1)) + struct hashmultiset_iter iter1 = hms_iter_start(_set1_); + struct hashmultiset_iter iter2 = hms_iter_start(_set2_); + for (; !hms_iter_at_end(&iter1); hms_iter_next(&iter1)) { size_t value = hms_iter_value(&iter1); size_t m1 = hms_iter_multiplicity(&iter1); @@ -606,8 +591,7 @@ struct hashmultiset *hms_union(struct hashmultiset *_set1_, size_t max_ = m1 > m2 ? m1 : m2; hms_update(_set_r_, value, max_); } - for (hms_iter_to_start(&iter2); !hms_iter_end(&iter2); - hms_iter_next(&iter2)) + for (; !hms_iter_at_end(&iter2); hms_iter_next(&iter2)) { size_t value = hms_iter_value(&iter2); size_t m1 = hms_impl_multiplicity_of(_set1_, value); @@ -629,9 +613,8 @@ struct hashmultiset *hms_intersection(struct hashmultiset *_set1_, struct hashmultiset *_set_A_ = _set1_->count < _set2_->count ? _set1_ : _set2_; struct hashmultiset *_set_B_ = _set_A_ == _set1_ ? _set2_ : _set1_; - struct hashmultiset_iter iter; - hms_iter_init(&iter, _set_A_); - for (hms_iter_to_start(&iter); !hms_iter_end(&iter); hms_iter_next(&iter)) + struct hashmultiset_iter iter = hms_iter_start(_set_A_); + for (; !hms_iter_at_end(&iter); hms_iter_next(&iter)) { size_t value = hms_iter_value(&iter); size_t m1 = hms_iter_multiplicity(&iter); @@ -650,9 +633,8 @@ struct hashmultiset *hms_difference(struct hashmultiset *_set1_, _set1_->alloc, ((void *)0)); if (!_set_r_) return ((void *)0); - struct hashmultiset_iter iter; - hms_iter_init(&iter, _set1_); - for (hms_iter_to_start(&iter); !hms_iter_end(&iter); hms_iter_next(&iter)) + struct hashmultiset_iter iter = hms_iter_start(_set1_); + for (; !hms_iter_at_end(&iter); hms_iter_next(&iter)) { size_t value = hms_iter_value(&iter); size_t m1 = hms_iter_multiplicity(&iter); @@ -671,17 +653,14 @@ struct hashmultiset *hms_summation(struct hashmultiset *_set1_, _set1_->alloc, ((void *)0)); if (!_set_r_) return ((void *)0); - struct hashmultiset_iter iter1, iter2; - hms_iter_init(&iter1, _set1_); - hms_iter_init(&iter2, _set2_); - for (hms_iter_to_start(&iter1); !hms_iter_end(&iter1); - hms_iter_next(&iter1)) + struct hashmultiset_iter iter1 = hms_iter_start(_set1_); + struct hashmultiset_iter iter2 = hms_iter_start(_set2_); + for (; !hms_iter_at_end(&iter1); hms_iter_next(&iter1)) { hms_insert_many(_set_r_, hms_iter_value(&iter1), hms_iter_multiplicity(&iter1)); } - for (hms_iter_to_start(&iter2); !hms_iter_end(&iter2); - hms_iter_next(&iter2)) + for (; !hms_iter_at_end(&iter2); hms_iter_next(&iter2)) { hms_insert_many(_set_r_, hms_iter_value(&iter2), hms_iter_multiplicity(&iter2)); @@ -697,11 +676,9 @@ struct hashmultiset *hms_symmetric_difference(struct hashmultiset *_set1_, _set1_->alloc, ((void *)0)); if (!_set_r_) return ((void *)0); - struct hashmultiset_iter iter1, iter2; - hms_iter_init(&iter1, _set1_); - hms_iter_init(&iter2, _set2_); - for (hms_iter_to_start(&iter1); !hms_iter_end(&iter1); - hms_iter_next(&iter1)) + struct hashmultiset_iter iter1 = hms_iter_start(_set1_); + struct hashmultiset_iter iter2 = hms_iter_start(_set2_); + for (; !hms_iter_at_end(&iter1); hms_iter_next(&iter1)) { size_t value = hms_iter_value(&iter1); size_t m1 = hms_iter_multiplicity(&iter1); @@ -714,8 +691,7 @@ struct hashmultiset *hms_symmetric_difference(struct hashmultiset *_set1_, hms_update(_set_r_, value, m2 - m1); } } - for (hms_iter_to_start(&iter2); !hms_iter_end(&iter2); - hms_iter_next(&iter2)) + for (; !hms_iter_at_end(&iter2); hms_iter_next(&iter2)) { size_t value = hms_iter_value(&iter2); size_t m1 = hms_impl_multiplicity_of(_set1_, value); @@ -737,9 +713,8 @@ _Bool hms_is_subset(struct hashmultiset *_set1_, struct hashmultiset *_set2_) return 0; if (hms_empty(_set1_)) return 1; - struct hashmultiset_iter iter; - hms_iter_init(&iter, _set1_); - for (hms_iter_to_start(&iter); !hms_iter_end(&iter); hms_iter_next(&iter)) + struct hashmultiset_iter iter = hms_iter_start(_set1_); + for (; !hms_iter_at_end(&iter); hms_iter_next(&iter)) { size_t value = hms_iter_value(&iter); size_t m1 = hms_iter_multiplicity(&iter); @@ -765,9 +740,8 @@ _Bool hms_is_proper_subset(struct hashmultiset *_set1_, else return 0; } - struct hashmultiset_iter iter; - hms_iter_init(&iter, _set1_); - for (hms_iter_to_start(&iter); !hms_iter_end(&iter); hms_iter_next(&iter)) + struct hashmultiset_iter iter = hms_iter_start(_set1_); + for (; !hms_iter_at_end(&iter); hms_iter_next(&iter)) { size_t value = hms_iter_value(&iter); size_t m1 = hms_iter_multiplicity(&iter); @@ -787,9 +761,8 @@ _Bool hms_is_disjointset(struct hashmultiset *_set1_, { if (hms_empty(_set1_)) return 1; - struct hashmultiset_iter iter; - hms_iter_init(&iter, _set1_); - for (hms_iter_to_start(&iter); !hms_iter_end(&iter); hms_iter_next(&iter)) + struct hashmultiset_iter iter = hms_iter_start(_set1_); + for (; !hms_iter_at_end(&iter); hms_iter_next(&iter)) { size_t value = hms_iter_value(&iter); if (hms_impl_get_entry(_set2_, value) != ((void *)0)) @@ -797,55 +770,80 @@ _Bool hms_is_disjointset(struct hashmultiset *_set1_, } return 1; } -struct hashmultiset_iter *hms_iter_new(struct hashmultiset *target) +struct hashmultiset_iter hms_iter_start(struct hashmultiset *target) { - struct hashmultiset_iter *iter = - target->alloc->malloc(sizeof(struct hashmultiset_iter)); - if (!iter) - return ((void *)0); - hms_iter_init(iter, target); - return iter; -} -void hms_iter_free(struct hashmultiset_iter *iter) -{ - iter->target->alloc->free(iter); -} -void hms_iter_init(struct hashmultiset_iter *iter, struct hashmultiset *target) -{ - memset(iter, 0, sizeof(struct hashmultiset_iter)); - iter->target = target; - iter->start = 1; - iter->end = hms_empty(target); + struct hashmultiset_iter iter; + iter.target = target; + iter.cursor = 0; + iter.index = 0; + iter.first = 0; + iter.last = 0; + iter.start = 1; + iter.end = hms_empty(target); if (!hms_empty(target)) { for (size_t i = 0; i < target->capacity; i++) { if (target->buffer[i].state == CMC_ES_FILLED) { - iter->first = i; + iter.first = i; break; } } - iter->cursor = iter->first; + iter.cursor = iter.first; for (size_t i = target->capacity; i > 0; i--) { if (target->buffer[i - 1].state == CMC_ES_FILLED) { - iter->last = i - 1; + iter.last = i - 1; break; } } } + return iter; } -_Bool hms_iter_start(struct hashmultiset_iter *iter) +struct hashmultiset_iter hms_iter_end(struct hashmultiset *target) +{ + struct hashmultiset_iter iter; + iter.target = target; + iter.cursor = 0; + iter.index = 0; + iter.first = 0; + iter.last = 0; + iter.start = hms_empty(target); + iter.end = 1; + if (!hms_empty(target)) + { + for (size_t i = 0; i < target->capacity; i++) + { + if (target->buffer[i].state == CMC_ES_FILLED) + { + iter.first = i; + break; + } + } + for (size_t i = target->capacity; i > 0; i--) + { + if (target->buffer[i - 1].state == CMC_ES_FILLED) + { + iter.last = i - 1; + break; + } + } + iter.cursor = iter.last; + iter.index = target->count - 1; + } + return iter; +} +_Bool hms_iter_at_start(struct hashmultiset_iter *iter) { return hms_empty(iter->target) || iter->start; } -_Bool hms_iter_end(struct hashmultiset_iter *iter) +_Bool hms_iter_at_end(struct hashmultiset_iter *iter) { return hms_empty(iter->target) || iter->end; } -void hms_iter_to_start(struct hashmultiset_iter *iter) +_Bool hms_iter_to_start(struct hashmultiset_iter *iter) { if (!hms_empty(iter->target)) { @@ -853,9 +851,11 @@ void hms_iter_to_start(struct hashmultiset_iter *iter) iter->index = 0; iter->start = 1; iter->end = hms_empty(iter->target); + return 1; } + return 0; } -void hms_iter_to_end(struct hashmultiset_iter *iter) +_Bool hms_iter_to_end(struct hashmultiset_iter *iter) { if (!hms_empty(iter->target)) { @@ -863,7 +863,9 @@ void hms_iter_to_end(struct hashmultiset_iter *iter) iter->index = iter->target->count - 1; iter->start = hms_empty(iter->target); iter->end = 1; + return 1; } + return 0; } _Bool hms_iter_next(struct hashmultiset_iter *iter) { @@ -1054,16 +1056,3 @@ static size_t hms_impl_calculate_size(size_t required) i++; return cmc_hashtable_primes[i]; } -static struct hashmultiset_iter hms_impl_it_start(struct hashmultiset *_set_) -{ - struct hashmultiset_iter iter; - hms_iter_init(&iter, _set_); - return iter; -} -static struct hashmultiset_iter hms_impl_it_end(struct hashmultiset *_set_) -{ - struct hashmultiset_iter iter; - hms_iter_init(&iter, _set_); - hms_iter_to_end(&iter); - return iter; -} diff --git a/tests/main/unt/hashmultiset.c b/tests/main/unt/hashmultiset.c index 18a6efc..8af4519 100644 --- a/tests/main/unt/hashmultiset.c +++ b/tests/main/unt/hashmultiset.c @@ -424,3 +424,435 @@ CMC_CREATE_UNIT(HashMultiSet, true, { total_resize = 0; }); }); + +struct hashmultiset_fval *hms_fval_numhash = + &(struct hashmultiset_fval){ .cmp = cmc_size_cmp, + .cpy = NULL, + .str = cmc_size_str, + .free = NULL, + .hash = numhash, + .pri = cmc_size_cmp }; + +CMC_CREATE_UNIT(HashMultiSetIter, true, { + CMC_CREATE_TEST(PFX##_iter_start(), { + struct hashmultiset *set = hms_new(100, 0.6, hms_fval_numhash); + + cmc_assert_not_equals(ptr, NULL, set); + + struct hashmultiset_iter it = hms_iter_start(set); + + cmc_assert_equals(ptr, set, it.target); + cmc_assert_equals(size_t, 0, it.cursor); + cmc_assert_equals(size_t, 0, it.index); + cmc_assert_equals(size_t, 0, it.first); + cmc_assert_equals(size_t, 0, it.last); + cmc_assert_equals(bool, true, it.start); + cmc_assert_equals(bool, true, it.end); + + cmc_assert(hms_iter_at_start(&it)); + cmc_assert(hms_iter_at_end(&it)); + + cmc_assert(hms_insert(set, 1)); + cmc_assert(hms_insert(set, 2)); + cmc_assert(hms_insert(set, 3)); + + it = hms_iter_start(set); + + cmc_assert_equals(size_t, 0, it.index); + + cmc_assert_equals(size_t, 1, it.cursor); + cmc_assert_equals(size_t, 1, it.first); + cmc_assert_equals(size_t, 3, it.last); + + hms_free(set); + }); + + CMC_CREATE_TEST(PFX##_iter_end(), { + struct hashmultiset *set = hms_new(100, 0.6, hms_fval_numhash); + + cmc_assert_not_equals(ptr, NULL, set); + + struct hashmultiset_iter it = hms_iter_end(set); + + cmc_assert_equals(ptr, set, it.target); + cmc_assert_equals(size_t, 0, it.cursor); + cmc_assert_equals(size_t, 0, it.index); + cmc_assert_equals(size_t, 0, it.first); + cmc_assert_equals(size_t, 0, it.last); + cmc_assert_equals(bool, true, it.start); + cmc_assert_equals(bool, true, it.end); + + cmc_assert(hms_iter_at_start(&it)); + cmc_assert(hms_iter_at_end(&it)); + + cmc_assert(hms_insert(set, 1)); + cmc_assert(hms_insert(set, 2)); + cmc_assert(hms_insert(set, 3)); + + it = hms_iter_end(set); + + cmc_assert_equals(size_t, set->count - 1, it.index); + + cmc_assert_equals(size_t, 3, it.cursor); + cmc_assert_equals(size_t, 1, it.first); + cmc_assert_equals(size_t, 3, it.last); + + hms_free(set); + }); + + CMC_CREATE_TEST(PFX##_iter_at_start(), { + struct hashmultiset *set = hms_new(100, 0.6, hms_fval); + + cmc_assert_not_equals(ptr, NULL, set); + + struct hashmultiset_iter it = hms_iter_start(set); + + // Empty checks + cmc_assert(hms_iter_at_start(&it)); + it = hms_iter_end(set); + cmc_assert(hms_iter_at_start(&it)); + + // Non-empty checks + cmc_assert(hms_insert(set, 1)); + cmc_assert(hms_insert(set, 2)); + it = hms_iter_end(set); + cmc_assert(!hms_iter_at_start(&it)); + it = hms_iter_start(set); + cmc_assert(hms_iter_at_start(&it)); + + hms_free(set); + }); + + CMC_CREATE_TEST(PFX##_iter_at_end(), { + struct hashmultiset *set = hms_new(100, 0.6, hms_fval); + + cmc_assert_not_equals(ptr, NULL, set); + + struct hashmultiset_iter it = hms_iter_start(set); + + // Empty check + cmc_assert(hms_iter_at_end(&it)); + it = hms_iter_end(set); + cmc_assert(hms_iter_at_end(&it)); + + // Non-empty checks + cmc_assert(hms_insert(set, 1)); + cmc_assert(hms_insert(set, 2)); + it = hms_iter_end(set); + cmc_assert(hms_iter_at_end(&it)); + it = hms_iter_start(set); + cmc_assert(!hms_iter_at_end(&it)); + + hms_free(set); + }); + + CMC_CREATE_TEST(PFX##_iter_to_start(), { + struct hashmultiset *set = hms_new(100, 0.6, hms_fval_numhash); + + cmc_assert_not_equals(ptr, NULL, set); + + struct hashmultiset_iter it = hms_iter_start(set); + + cmc_assert(!hms_iter_to_start(&it)); + + for (size_t i = 1; i <= 100; i++) + hms_insert(set, i); + + cmc_assert_equals(size_t, 100, set->count); + + it = hms_iter_end(set); + + cmc_assert(!hms_iter_at_start(&it)); + cmc_assert(hms_iter_at_end(&it)); + + cmc_assert_equals(size_t, 100, hms_iter_value(&it)); + + cmc_assert(hms_iter_to_start(&it)); + + cmc_assert(hms_iter_at_start(&it)); + cmc_assert(!hms_iter_at_end(&it)); + + cmc_assert_equals(size_t, 1, hms_iter_value(&it)); + + hms_free(set); + }); + + CMC_CREATE_TEST(PFX##_iter_to_end(), { + struct hashmultiset *set = hms_new(100, 0.6, hms_fval_numhash); + + cmc_assert_not_equals(ptr, NULL, set); + + struct hashmultiset_iter it = hms_iter_end(set); + + cmc_assert(!hms_iter_to_end(&it)); + + for (size_t i = 1; i <= 100; i++) + hms_insert(set, i); + + it = hms_iter_start(set); + + cmc_assert(hms_iter_at_start(&it)); + cmc_assert(!hms_iter_at_end(&it)); + + cmc_assert_equals(size_t, 1, hms_iter_value(&it)); + + cmc_assert(hms_iter_to_end(&it)); + + cmc_assert(!hms_iter_at_start(&it)); + cmc_assert(hms_iter_at_end(&it)); + + cmc_assert_equals(size_t, 100, hms_iter_value(&it)); + + hms_free(set); + }); + + CMC_CREATE_TEST(PFX##_iter_next(), { + struct hashmultiset *set = hms_new(100, 0.6, hms_fval); + + cmc_assert_not_equals(ptr, NULL, set); + + struct hashmultiset_iter it = hms_iter_start(set); + + cmc_assert(!hms_iter_next(&it)); + + for (size_t i = 1; i <= 1000; i++) + hms_insert(set, i); + + size_t sum = 0; + for (it = hms_iter_start(set); !hms_iter_at_end(&it); + hms_iter_next(&it)) + { + sum += hms_iter_value(&it); + } + + cmc_assert_equals(size_t, 500500, sum); + + sum = 0; + + hms_iter_to_start(&it); + do + { + sum += hms_iter_value(&it); + } while (hms_iter_next(&it)); + + cmc_assert_equals(size_t, 500500, sum); + + hms_free(set); + }); + + CMC_CREATE_TEST(PFX##_iter_prev(), { + struct hashmultiset *set = hms_new(100, 0.6, hms_fval); + + cmc_assert_not_equals(ptr, NULL, set); + + struct hashmultiset_iter it = hms_iter_end(set); + + cmc_assert(!hms_iter_prev(&it)); + + for (size_t i = 1; i <= 1000; i++) + hms_insert(set, i); + + size_t sum = 0; + for (it = hms_iter_end(set); !hms_iter_at_start(&it); + hms_iter_prev(&it)) + { + sum += hms_iter_value(&it); + } + + cmc_assert_equals(size_t, 500500, sum); + + sum = 0; + + hms_iter_to_end(&it); + do + { + sum += hms_iter_value(&it); + } while (hms_iter_prev(&it)); + + cmc_assert_equals(size_t, 500500, sum); + + hms_free(set); + }); + + CMC_CREATE_TEST(PFX##_iter_advance(), { + struct hashmultiset *set = hms_new(100, 0.6, hms_fval_numhash); + + cmc_assert_not_equals(ptr, NULL, set); + + struct hashmultiset_iter it = hms_iter_start(set); + + cmc_assert(!hms_iter_advance(&it, 1)); + + for (size_t i = 0; i <= 1000; i++) + hms_insert(set, i); + + it = hms_iter_start(set); + + cmc_assert(!hms_iter_advance(&it, 0)); + cmc_assert(!hms_iter_advance(&it, set->count)); + + size_t sum = 0; + for (it = hms_iter_start(set);;) + { + sum += hms_iter_value(&it); + + if (!hms_iter_advance(&it, 2)) + break; + } + + cmc_assert_equals(size_t, 250500, sum); + + hms_iter_to_start(&it); + cmc_assert(hms_iter_advance(&it, set->count - 1)); + + hms_free(set); + }); + + CMC_CREATE_TEST(PFX##_iter_rewind(), { + struct hashmultiset *set = hms_new(100, 0.6, hms_fval_numhash); + + cmc_assert_not_equals(ptr, NULL, set); + + struct hashmultiset_iter it = hms_iter_end(set); + + cmc_assert(!hms_iter_rewind(&it, 1)); + + for (size_t i = 0; i <= 1000; i++) + hms_insert(set, i); + + it = hms_iter_end(set); + + cmc_assert(!hms_iter_rewind(&it, 0)); + cmc_assert(!hms_iter_rewind(&it, set->count)); + + size_t sum = 0; + for (it = hms_iter_end(set);;) + { + sum += hms_iter_value(&it); + + if (!hms_iter_rewind(&it, 2)) + break; + } + + cmc_assert_equals(size_t, 250500, sum); + + hms_iter_to_end(&it); + cmc_assert(hms_iter_rewind(&it, set->count - 1)); + + hms_free(set); + }); + + CMC_CREATE_TEST(PFX##_iter_go_to(), { + struct hashmultiset *set = hms_new(100, 0.6, hms_fval_numhash); + + cmc_assert_not_equals(ptr, NULL, set); + + struct hashmultiset_iter it = hms_iter_end(set); + cmc_assert(!hms_iter_go_to(&it, 0)); + + it = hms_iter_start(set); + cmc_assert(!hms_iter_go_to(&it, 0)); + + for (size_t i = 0; i <= 1000; i++) + hms_insert(set, i); + + it = hms_iter_start(set); + + size_t sum = 0; + for (size_t i = 0; i < 1001; i++) + { + hms_iter_go_to(&it, i); + + sum += hms_iter_value(&it); + } + + cmc_assert_equals(size_t, 500500, sum); + + sum = 0; + for (size_t i = 1001; i > 0; i--) + { + cmc_assert(hms_iter_go_to(&it, i - 1)); + + sum += hms_iter_value(&it); + } + + cmc_assert_equals(size_t, 500500, sum); + + sum = 0; + for (size_t i = 0; i < 1001; i += 100) + { + cmc_assert(hms_iter_go_to(&it, i)); + cmc_assert_equals(size_t, i, hms_iter_index(&it)); + + sum += hms_iter_value(&it); + } + + cmc_assert_equals(size_t, 5500, sum); + + hms_free(set); + }); + + CMC_CREATE_TEST(PFX##_iter_value(), { + struct hashmultiset *set = hms_new(100, 0.6, hms_fval); + + cmc_assert_not_equals(ptr, NULL, set); + + struct hashmultiset_iter it = hms_iter_end(set); + + cmc_assert_equals(size_t, (size_t){ 0 }, hms_iter_value(&it)); + + cmc_assert(hms_insert(set, 10)); + + it = hms_iter_start(set); + + cmc_assert_equals(size_t, 10, hms_iter_value(&it)); + + hms_free(set); + }); + + CMC_CREATE_TEST(PFX##_iter_multiplicity(), { + struct hashmultiset *set = hms_new(100, 0.6, hms_fval); + + cmc_assert_not_equals(ptr, NULL, set); + + struct hashmultiset_iter it = hms_iter_end(set); + + cmc_assert_equals(size_t, (size_t){ 0 }, hms_iter_multiplicity(&it)); + + cmc_assert(hms_insert_many(set, 10, 5)); + + it = hms_iter_start(set); + cmc_assert_equals(size_t, 5, hms_iter_multiplicity(&it)); + + it = hms_iter_end(set); + cmc_assert_equals(size_t, 5, hms_iter_multiplicity(&it)); + + hms_free(set); + }); + + CMC_CREATE_TEST(PFX##_iter_index(), { + struct hashmultiset *set = hms_new(100, 0.6, hms_fval); + + cmc_assert_not_equals(ptr, NULL, set); + + for (size_t i = 0; i <= 1000; i++) + hms_insert(set, i); + + struct hashmultiset_iter it = hms_iter_start(set); + + for (size_t i = 0; i < 1001; i++) + { + cmc_assert_equals(size_t, i, hms_iter_index(&it)); + hms_iter_next(&it); + } + + it = hms_iter_end(set); + for (size_t i = 1001; i > 0; i--) + { + cmc_assert_equals(size_t, i - 1, hms_iter_index(&it)); + hms_iter_prev(&it); + } + + hms_free(set); + }); +});