Updating hashmultiset iterator API
This commit is contained in:
Leonardo committed
1 parent
fdfb81d08c
commit
2cacbc5348
4 files changed
+624
-229
No files matched your search
+101
-128
@@ -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 */
|
||||
@@ -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);
|
||||
|
||||
+90
-101
@@ -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;
|
||||
}
|
||||
@@ -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);
|
||||
});
|
||||
});
|
||||
Reference in new issue
Block a user