admin/C-Macro-Collections
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Updating hashset iterator API

Browse Source
This commit is contained in:
Leonardo committed 2020-05-07 00:10:41 -03:00
1 parent adfa5abbc0
commit 303e3b57b8
4 files changed
+594 -203
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/cmc/hashset.h
+97 -118
View File
@@ -85,12 +85,6 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> "
\
/* Custom callback functions */ \
struct cmc_callbacks *callbacks; \
\
/* Function that returns an iterator to the start of the hashset */ \
struct SNAME##_iter (*it_start)(struct SNAME *); \
\
/* Function that returns an iterator to the end of the hashset */ \
struct SNAME##_iter (*it_end)(struct SNAME *); \
}; \
\
struct SNAME##_entry \
@@ -201,17 +195,15 @@ static const char *cmc_string_fmt_hashset = "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); \
@@ -271,8 +263,6 @@ static const char *cmc_string_fmt_hashset = "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_; \
} \
@@ -317,8 +307,6 @@ static const char *cmc_string_fmt_hashset = "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_; \
} \
@@ -480,11 +468,10 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> "
} \
\
V max_value; \
struct SNAME##_iter iter; \
struct SNAME##_iter iter = PFX##_iter_start(_set_); \
\
/* TODO turn 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); \
@@ -515,11 +502,10 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> "
} \
\
V min_value; \
struct SNAME##_iter iter; \
struct SNAME##_iter iter = PFX##_iter_start(_set_); \
\
/* TODO turn 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); \
@@ -620,11 +606,10 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> "
return false; \
} \
\
struct SNAME##_iter iter; \
struct SNAME##_iter iter = PFX##_iter_start(_set_); \
\
/* TODO turn 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 value = PFX##_iter_value(&iter); \
\
@@ -718,12 +703,10 @@ static const char *cmc_string_fmt_hashset = "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_); \
\
/* TODO optimize this loop */ \
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_entry(_set2_, PFX##_iter_value(&iter)) == NULL) \
return false; \
@@ -775,19 +758,16 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> "
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_); \
\
/* TODO turn this into a normal loop and check for errors */ \
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)); \
} \
@@ -816,11 +796,9 @@ static const char *cmc_string_fmt_hashset = "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); \
\
@@ -847,11 +825,9 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> "
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); \
\
@@ -879,13 +855,10 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> "
return NULL; \
} \
\
struct SNAME##_iter iter1, iter2; \
struct SNAME##_iter iter1 = PFX##_iter_start(_set1_); \
struct SNAME##_iter iter2 = PFX##_iter_start(_set2_); \
\
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); \
\
@@ -893,8 +866,7 @@ static const char *cmc_string_fmt_hashset = "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); \
\
@@ -924,12 +896,9 @@ static const char *cmc_string_fmt_hashset = "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); \
\
@@ -973,12 +942,9 @@ static const char *cmc_string_fmt_hashset = "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); \
\
@@ -1010,12 +976,9 @@ static const char *cmc_string_fmt_hashset = "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); \
\
@@ -1026,31 +989,17 @@ static const char *cmc_string_fmt_hashset = "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)) \
{ \
@@ -1058,35 +1007,76 @@ static const char *cmc_string_fmt_hashset = "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)) \
{ \
@@ -1094,10 +1084,14 @@ static const char *cmc_string_fmt_hashset = "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)) \
{ \
@@ -1105,7 +1099,11 @@ static const char *cmc_string_fmt_hashset = "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) \
@@ -1270,25 +1268,6 @@ static const char *cmc_string_fmt_hashset = "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_HASHSET_H */
tests/main/main.c
+1
View File
@@ -59,6 +59,7 @@ int main(void)
cmc_run(HashMultiSet, units, tests);
cmc_run(HashMultiSetIter, units, tests);
cmc_run(HashSet, units, tests);
cmc_run(HashSetIter, units, tests);
cmc_run(Heap, units, tests);
cmc_run(IntervalHeap, units, tests);
cmc_run(LinkedList, units, tests);
tests/main/src/hashset.c
+86 -85
View File
@@ -10,8 +10,6 @@ struct hashset
struct hashset_fval *f_val;
struct cmc_alloc_node *alloc;
struct cmc_callbacks *callbacks;
struct hashset_iter (*it_start)(struct hashset *);
struct hashset_iter (*it_end)(struct hashset *);
};
struct hashset_entry
{
@@ -74,13 +72,12 @@ _Bool hs_is_superset(struct hashset *_set1_, struct hashset *_set2_);
_Bool hs_is_proper_subset(struct hashset *_set1_, struct hashset *_set2_);
_Bool hs_is_proper_superset(struct hashset *_set1_, struct hashset *_set2_);
_Bool hs_is_disjointset(struct hashset *_set1_, struct hashset *_set2_);
struct hashset_iter *hs_iter_new(struct hashset *target);
void hs_iter_free(struct hashset_iter *iter);
void hs_iter_init(struct hashset_iter *iter, struct hashset *target);
_Bool hs_iter_start(struct hashset_iter *iter);
_Bool hs_iter_end(struct hashset_iter *iter);
void hs_iter_to_start(struct hashset_iter *iter);
void hs_iter_to_end(struct hashset_iter *iter);
struct hashset_iter hs_iter_start(struct hashset *target);
struct hashset_iter hs_iter_end(struct hashset *target);
_Bool hs_iter_at_start(struct hashset_iter *iter);
_Bool hs_iter_at_end(struct hashset_iter *iter);
_Bool hs_iter_to_start(struct hashset_iter *iter);
_Bool hs_iter_to_end(struct hashset_iter *iter);
_Bool hs_iter_next(struct hashset_iter *iter);
_Bool hs_iter_prev(struct hashset_iter *iter);
_Bool hs_iter_advance(struct hashset_iter *iter, size_t steps);
@@ -119,8 +116,6 @@ struct hashset *hs_new(size_t capacity, double load, struct hashset_fval *f_val)
_set_->f_val = f_val;
_set_->alloc = alloc;
_set_->callbacks = ((void *)0);
_set_->it_start = hs_impl_it_start;
_set_->it_end = hs_impl_it_end;
return _set_;
}
struct hashset *hs_new_custom(size_t capacity, double load,
@@ -153,8 +148,6 @@ struct hashset *hs_new_custom(size_t capacity, double load,
_set_->f_val = f_val;
_set_->alloc = alloc;
_set_->callbacks = callbacks;
_set_->it_start = hs_impl_it_start;
_set_->it_end = hs_impl_it_end;
return _set_;
}
void hs_clear(struct hashset *_set_)
@@ -283,8 +276,8 @@ _Bool hs_max(struct hashset *_set_, size_t *value)
return 0;
}
size_t max_value;
struct hashset_iter iter;
for (hs_iter_init(&iter, _set_); !hs_iter_end(&iter); hs_iter_next(&iter))
struct hashset_iter iter = hs_iter_start(_set_);
for (; !hs_iter_at_end(&iter); hs_iter_next(&iter))
{
size_t result = hs_iter_value(&iter);
size_t index = hs_iter_index(&iter);
@@ -308,8 +301,8 @@ _Bool hs_min(struct hashset *_set_, size_t *value)
return 0;
}
size_t min_value;
struct hashset_iter iter;
for (hs_iter_init(&iter, _set_); !hs_iter_end(&iter); hs_iter_next(&iter))
struct hashset_iter iter = hs_iter_start(_set_);
for (; !hs_iter_at_end(&iter); hs_iter_next(&iter))
{
size_t result = hs_iter_value(&iter);
size_t index = hs_iter_index(&iter);
@@ -382,8 +375,8 @@ _Bool hs_resize(struct hashset *_set_, size_t capacity)
_set_->flag = cmc_flags.ALLOC;
return 0;
}
struct hashset_iter iter;
for (hs_iter_init(&iter, _set_); !hs_iter_end(&iter); hs_iter_next(&iter))
struct hashset_iter iter = hs_iter_start(_set_);
for (; !hs_iter_at_end(&iter); hs_iter_next(&iter))
{
size_t value = hs_iter_value(&iter);
hs_insert(_new_set_, value);
@@ -451,9 +444,8 @@ _Bool hs_equals(struct hashset *_set1_, struct hashset *_set2_)
return 0;
if (_set1_->count == 0)
return 1;
struct hashset_iter iter;
hs_iter_init(&iter, _set1_);
for (hs_iter_to_start(&iter); !hs_iter_end(&iter); hs_iter_next(&iter))
struct hashset_iter iter = hs_iter_start(_set1_);
for (; !hs_iter_at_end(&iter); hs_iter_next(&iter))
{
if (hs_impl_get_entry(_set2_, hs_iter_value(&iter)) == ((void *)0))
return 0;
@@ -493,14 +485,13 @@ struct hashset *hs_union(struct hashset *_set1_, struct hashset *_set2_)
_set2_->flag = cmc_flags.ALLOC;
return ((void *)0);
}
struct hashset_iter iter1, iter2;
hs_iter_init(&iter1, _set1_);
hs_iter_init(&iter2, _set2_);
for (hs_iter_to_start(&iter1); !hs_iter_end(&iter1); hs_iter_next(&iter1))
struct hashset_iter iter1 = hs_iter_start(_set1_);
struct hashset_iter iter2 = hs_iter_start(_set2_);
for (; !hs_iter_at_end(&iter1); hs_iter_next(&iter1))
{
hs_insert(_set_r_, hs_iter_value(&iter1));
}
for (hs_iter_to_start(&iter2); !hs_iter_end(&iter2); hs_iter_next(&iter2))
for (; !hs_iter_at_end(&iter2); hs_iter_next(&iter2))
{
hs_insert(_set_r_, hs_iter_value(&iter2));
}
@@ -520,9 +511,8 @@ struct hashset *hs_intersection(struct hashset *_set1_, struct hashset *_set2_)
}
struct hashset *_set_A_ = _set1_->count < _set2_->count ? _set1_ : _set2_;
struct hashset *_set_B_ = _set_A_ == _set1_ ? _set2_ : _set1_;
struct hashset_iter iter;
hs_iter_init(&iter, _set_A_);
for (hs_iter_to_start(&iter); !hs_iter_end(&iter); hs_iter_next(&iter))
struct hashset_iter iter = hs_iter_start(_set_A_);
for (; !hs_iter_at_end(&iter); hs_iter_next(&iter))
{
size_t value = hs_iter_value(&iter);
if (hs_impl_get_entry(_set_B_, value) != ((void *)0))
@@ -542,9 +532,8 @@ struct hashset *hs_difference(struct hashset *_set1_, struct hashset *_set2_)
_set2_->flag = cmc_flags.ALLOC;
return ((void *)0);
}
struct hashset_iter iter;
hs_iter_init(&iter, _set1_);
for (hs_iter_to_start(&iter); !hs_iter_end(&iter); hs_iter_next(&iter))
struct hashset_iter iter = hs_iter_start(_set1_);
for (; !hs_iter_at_end(&iter); hs_iter_next(&iter))
{
size_t value = hs_iter_value(&iter);
if (hs_impl_get_entry(_set2_, value) == ((void *)0))
@@ -565,16 +554,15 @@ struct hashset *hs_symmetric_difference(struct hashset *_set1_,
_set2_->flag = cmc_flags.ALLOC;
return ((void *)0);
}
struct hashset_iter iter1, iter2;
hs_iter_init(&iter1, _set1_);
hs_iter_init(&iter2, _set2_);
for (hs_iter_to_start(&iter1); !hs_iter_end(&iter1); hs_iter_next(&iter1))
struct hashset_iter iter1 = hs_iter_start(_set1_);
struct hashset_iter iter2 = hs_iter_start(_set2_);
for (; !hs_iter_at_end(&iter1); hs_iter_next(&iter1))
{
size_t value = hs_iter_value(&iter1);
if (hs_impl_get_entry(_set2_, value) == ((void *)0))
hs_insert(_set_r_, value);
}
for (hs_iter_to_start(&iter2); !hs_iter_end(&iter2); hs_iter_next(&iter2))
for (; !hs_iter_at_end(&iter2); hs_iter_next(&iter2))
{
size_t value = hs_iter_value(&iter2);
if (hs_impl_get_entry(_set1_, value) == ((void *)0))
@@ -591,9 +579,8 @@ _Bool hs_is_subset(struct hashset *_set1_, struct hashset *_set2_)
return 0;
if (hs_empty(_set1_))
return 1;
struct hashset_iter iter;
hs_iter_init(&iter, _set1_);
for (hs_iter_to_start(&iter); !hs_iter_end(&iter); hs_iter_next(&iter))
struct hashset_iter iter = hs_iter_start(_set1_);
for (; !hs_iter_at_end(&iter); hs_iter_next(&iter))
{
size_t value = hs_iter_value(&iter);
if (hs_impl_get_entry(_set2_, value) == ((void *)0))
@@ -618,9 +605,8 @@ _Bool hs_is_proper_subset(struct hashset *_set1_, struct hashset *_set2_)
else
return 0;
}
struct hashset_iter iter;
hs_iter_init(&iter, _set1_);
for (hs_iter_to_start(&iter); !hs_iter_end(&iter); hs_iter_next(&iter))
struct hashset_iter iter = hs_iter_start(_set1_);
for (; !hs_iter_at_end(&iter); hs_iter_next(&iter))
{
size_t value = hs_iter_value(&iter);
if (hs_impl_get_entry(_set2_, value) == ((void *)0))
@@ -638,9 +624,8 @@ _Bool hs_is_disjointset(struct hashset *_set1_, struct hashset *_set2_)
_set2_->flag = cmc_flags.OK;
if (hs_empty(_set1_))
return 1;
struct hashset_iter iter;
hs_iter_init(&iter, _set1_);
for (hs_iter_to_start(&iter); !hs_iter_end(&iter); hs_iter_next(&iter))
struct hashset_iter iter = hs_iter_start(_set1_);
for (; !hs_iter_at_end(&iter); hs_iter_next(&iter))
{
size_t value = hs_iter_value(&iter);
if (hs_impl_get_entry(_set2_, value) != ((void *)0))
@@ -648,55 +633,80 @@ _Bool hs_is_disjointset(struct hashset *_set1_, struct hashset *_set2_)
}
return 1;
}
struct hashset_iter *hs_iter_new(struct hashset *target)
struct hashset_iter hs_iter_start(struct hashset *target)
{
struct hashset_iter *iter =
target->alloc->malloc(sizeof(struct hashset_iter));
if (!iter)
return ((void *)0);
hs_iter_init(iter, target);
return iter;
}
void hs_iter_free(struct hashset_iter *iter)
{
iter->target->alloc->free(iter);
}
void hs_iter_init(struct hashset_iter *iter, struct hashset *target)
{
memset(iter, 0, sizeof(struct hashset_iter));
iter->target = target;
iter->start = 1;
iter->end = hs_empty(target);
struct hashset_iter iter;
iter.target = target;
iter.cursor = 0;
iter.index = 0;
iter.first = 0;
iter.last = 0;
iter.start = 1;
iter.end = hs_empty(target);
if (!hs_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 hs_iter_start(struct hashset_iter *iter)
struct hashset_iter hs_iter_end(struct hashset *target)
{
struct hashset_iter iter;
iter.target = target;
iter.cursor = 0;
iter.index = 0;
iter.first = 0;
iter.last = 0;
iter.start = hs_empty(target);
iter.end = 1;
if (!hs_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 hs_iter_at_start(struct hashset_iter *iter)
{
return hs_empty(iter->target) || iter->start;
}
_Bool hs_iter_end(struct hashset_iter *iter)
_Bool hs_iter_at_end(struct hashset_iter *iter)
{
return hs_empty(iter->target) || iter->end;
}
void hs_iter_to_start(struct hashset_iter *iter)
_Bool hs_iter_to_start(struct hashset_iter *iter)
{
if (!hs_empty(iter->target))
{
@@ -704,9 +714,11 @@ void hs_iter_to_start(struct hashset_iter *iter)
iter->index = 0;
iter->start = 1;
iter->end = hs_empty(iter->target);
return 1;
}
return 0;
}
void hs_iter_to_end(struct hashset_iter *iter)
_Bool hs_iter_to_end(struct hashset_iter *iter)
{
if (!hs_empty(iter->target))
{
@@ -714,7 +726,9 @@ void hs_iter_to_end(struct hashset_iter *iter)
iter->index = iter->target->count - 1;
iter->start = hs_empty(iter->target);
iter->end = 1;
return 1;
}
return 0;
}
_Bool hs_iter_next(struct hashset_iter *iter)
{
@@ -834,16 +848,3 @@ static size_t hs_impl_calculate_size(size_t required)
i++;
return cmc_hashtable_primes[i];
}
static struct hashset_iter hs_impl_it_start(struct hashset *_set_)
{
struct hashset_iter iter;
hs_iter_init(&iter, _set_);
return iter;
}
static struct hashset_iter hs_impl_it_end(struct hashset *_set_)
{
struct hashset_iter iter;
hs_iter_init(&iter, _set_);
hs_iter_to_end(&iter);
return iter;
}
tests/main/unt/hashset.c
+410
View File
@@ -624,3 +624,413 @@ CMC_CREATE_UNIT(HashSet, true, {
total_resize = 0;
});
});
struct hashset_fval *hs_fval_numhash =
&(struct hashset_fval){ .cmp = cmc_size_cmp,
.cpy = NULL,
.str = cmc_size_str,
.free = NULL,
.hash = numhash,
.pri = cmc_size_cmp };
CMC_CREATE_UNIT(HashSetIter, true, {
CMC_CREATE_TEST(PFX##_iter_start(), {
struct hashset *set = hs_new(100, 0.6, hs_fval_numhash);
cmc_assert_not_equals(ptr, NULL, set);
struct hashset_iter it = hs_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(hs_iter_at_start(&it));
cmc_assert(hs_iter_at_end(&it));
cmc_assert(hs_insert(set, 1));
cmc_assert(hs_insert(set, 2));
cmc_assert(hs_insert(set, 3));
it = hs_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);
hs_free(set);
});
CMC_CREATE_TEST(PFX##_iter_end(), {
struct hashset *set = hs_new(100, 0.6, hs_fval_numhash);
cmc_assert_not_equals(ptr, NULL, set);
struct hashset_iter it = hs_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(hs_iter_at_start(&it));
cmc_assert(hs_iter_at_end(&it));
cmc_assert(hs_insert(set, 1));
cmc_assert(hs_insert(set, 2));
cmc_assert(hs_insert(set, 3));
it = hs_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);
hs_free(set);
});
CMC_CREATE_TEST(PFX##_iter_at_start(), {
struct hashset *set = hs_new(100, 0.6, hs_fval);
cmc_assert_not_equals(ptr, NULL, set);
struct hashset_iter it = hs_iter_start(set);
// Empty checks
cmc_assert(hs_iter_at_start(&it));
it = hs_iter_end(set);
cmc_assert(hs_iter_at_start(&it));
// Non-empty checks
cmc_assert(hs_insert(set, 1));
cmc_assert(hs_insert(set, 2));
it = hs_iter_end(set);
cmc_assert(!hs_iter_at_start(&it));
it = hs_iter_start(set);
cmc_assert(hs_iter_at_start(&it));
hs_free(set);
});
CMC_CREATE_TEST(PFX##_iter_at_end(), {
struct hashset *set = hs_new(100, 0.6, hs_fval);
cmc_assert_not_equals(ptr, NULL, set);
struct hashset_iter it = hs_iter_start(set);
// Empty check
cmc_assert(hs_iter_at_end(&it));
it = hs_iter_end(set);
cmc_assert(hs_iter_at_end(&it));
// Non-empty checks
cmc_assert(hs_insert(set, 1));
cmc_assert(hs_insert(set, 2));
it = hs_iter_end(set);
cmc_assert(hs_iter_at_end(&it));
it = hs_iter_start(set);
cmc_assert(!hs_iter_at_end(&it));
hs_free(set);
});
CMC_CREATE_TEST(PFX##_iter_to_start(), {
struct hashset *set = hs_new(100, 0.6, hs_fval_numhash);
cmc_assert_not_equals(ptr, NULL, set);
struct hashset_iter it = hs_iter_start(set);
cmc_assert(!hs_iter_to_start(&it));
for (size_t i = 1; i <= 100; i++)
hs_insert(set, i);
cmc_assert_equals(size_t, 100, set->count);
it = hs_iter_end(set);
cmc_assert(!hs_iter_at_start(&it));
cmc_assert(hs_iter_at_end(&it));
cmc_assert_equals(size_t, 100, hs_iter_value(&it));
cmc_assert(hs_iter_to_start(&it));
cmc_assert(hs_iter_at_start(&it));
cmc_assert(!hs_iter_at_end(&it));
cmc_assert_equals(size_t, 1, hs_iter_value(&it));
hs_free(set);
});
CMC_CREATE_TEST(PFX##_iter_to_end(), {
struct hashset *set = hs_new(100, 0.6, hs_fval_numhash);
cmc_assert_not_equals(ptr, NULL, set);
struct hashset_iter it = hs_iter_end(set);
cmc_assert(!hs_iter_to_end(&it));
for (size_t i = 1; i <= 100; i++)
hs_insert(set, i);
it = hs_iter_start(set);
cmc_assert(hs_iter_at_start(&it));
cmc_assert(!hs_iter_at_end(&it));
cmc_assert_equals(size_t, 1, hs_iter_value(&it));
cmc_assert(hs_iter_to_end(&it));
cmc_assert(!hs_iter_at_start(&it));
cmc_assert(hs_iter_at_end(&it));
cmc_assert_equals(size_t, 100, hs_iter_value(&it));
hs_free(set);
});
CMC_CREATE_TEST(PFX##_iter_next(), {
struct hashset *set = hs_new(100, 0.6, hs_fval);
cmc_assert_not_equals(ptr, NULL, set);
struct hashset_iter it = hs_iter_start(set);
cmc_assert(!hs_iter_next(&it));
for (size_t i = 1; i <= 1000; i++)
hs_insert(set, i);
size_t sum = 0;
for (it = hs_iter_start(set); !hs_iter_at_end(&it); hs_iter_next(&it))
{
sum += hs_iter_value(&it);
}
cmc_assert_equals(size_t, 500500, sum);
sum = 0;
hs_iter_to_start(&it);
do
{
sum += hs_iter_value(&it);
} while (hs_iter_next(&it));
cmc_assert_equals(size_t, 500500, sum);
hs_free(set);
});
CMC_CREATE_TEST(PFX##_iter_prev(), {
struct hashset *set = hs_new(100, 0.6, hs_fval);
cmc_assert_not_equals(ptr, NULL, set);
struct hashset_iter it = hs_iter_end(set);
cmc_assert(!hs_iter_prev(&it));
for (size_t i = 1; i <= 1000; i++)
hs_insert(set, i);
size_t sum = 0;
for (it = hs_iter_end(set); !hs_iter_at_start(&it); hs_iter_prev(&it))
{
sum += hs_iter_value(&it);
}
cmc_assert_equals(size_t, 500500, sum);
sum = 0;
hs_iter_to_end(&it);
do
{
sum += hs_iter_value(&it);
} while (hs_iter_prev(&it));
cmc_assert_equals(size_t, 500500, sum);
hs_free(set);
});
CMC_CREATE_TEST(PFX##_iter_advance(), {
struct hashset *set = hs_new(100, 0.6, hs_fval_numhash);
cmc_assert_not_equals(ptr, NULL, set);
struct hashset_iter it = hs_iter_start(set);
cmc_assert(!hs_iter_advance(&it, 1));
for (size_t i = 0; i <= 1000; i++)
hs_insert(set, i);
it = hs_iter_start(set);
cmc_assert(!hs_iter_advance(&it, 0));
cmc_assert(!hs_iter_advance(&it, set->count));
size_t sum = 0;
for (it = hs_iter_start(set);;)
{
sum += hs_iter_value(&it);
if (!hs_iter_advance(&it, 2))
break;
}
cmc_assert_equals(size_t, 250500, sum);
hs_iter_to_start(&it);
cmc_assert(hs_iter_advance(&it, set->count - 1));
hs_free(set);
});
CMC_CREATE_TEST(PFX##_iter_rewind(), {
struct hashset *set = hs_new(100, 0.6, hs_fval_numhash);
cmc_assert_not_equals(ptr, NULL, set);
struct hashset_iter it = hs_iter_end(set);
cmc_assert(!hs_iter_rewind(&it, 1));
for (size_t i = 0; i <= 1000; i++)
hs_insert(set, i);
it = hs_iter_end(set);
cmc_assert(!hs_iter_rewind(&it, 0));
cmc_assert(!hs_iter_rewind(&it, set->count));
size_t sum = 0;
for (it = hs_iter_end(set);;)
{
sum += hs_iter_value(&it);
if (!hs_iter_rewind(&it, 2))
break;
}
cmc_assert_equals(size_t, 250500, sum);
hs_iter_to_end(&it);
cmc_assert(hs_iter_rewind(&it, set->count - 1));
hs_free(set);
});
CMC_CREATE_TEST(PFX##_iter_go_to(), {
struct hashset *set = hs_new(100, 0.6, hs_fval_numhash);
cmc_assert_not_equals(ptr, NULL, set);
struct hashset_iter it = hs_iter_end(set);
cmc_assert(!hs_iter_go_to(&it, 0));
it = hs_iter_start(set);
cmc_assert(!hs_iter_go_to(&it, 0));
for (size_t i = 0; i <= 1000; i++)
hs_insert(set, i);
it = hs_iter_start(set);
size_t sum = 0;
for (size_t i = 0; i < 1001; i++)
{
hs_iter_go_to(&it, i);
sum += hs_iter_value(&it);
}
cmc_assert_equals(size_t, 500500, sum);
sum = 0;
for (size_t i = 1001; i > 0; i--)
{
cmc_assert(hs_iter_go_to(&it, i - 1));
sum += hs_iter_value(&it);
}
cmc_assert_equals(size_t, 500500, sum);
sum = 0;
for (size_t i = 0; i < 1001; i += 100)
{
cmc_assert(hs_iter_go_to(&it, i));
cmc_assert_equals(size_t, i, hs_iter_index(&it));
sum += hs_iter_value(&it);
}
cmc_assert_equals(size_t, 5500, sum);
hs_free(set);
});
CMC_CREATE_TEST(PFX##_iter_value(), {
struct hashset *set = hs_new(100, 0.6, hs_fval);
cmc_assert_not_equals(ptr, NULL, set);
struct hashset_iter it = hs_iter_end(set);
cmc_assert_equals(size_t, (size_t){ 0 }, hs_iter_value(&it));
cmc_assert(hs_insert(set, 10));
it = hs_iter_start(set);
cmc_assert_equals(size_t, 10, hs_iter_value(&it));
hs_free(set);
});
CMC_CREATE_TEST(PFX##_iter_index(), {
struct hashset *set = hs_new(100, 0.6, hs_fval);
cmc_assert_not_equals(ptr, NULL, set);
for (size_t i = 0; i <= 1000; i++)
hs_insert(set, i);
struct hashset_iter it = hs_iter_start(set);
for (size_t i = 0; i < 1001; i++)
{
cmc_assert_equals(size_t, i, hs_iter_index(&it));
hs_iter_next(&it);
}
it = hs_iter_end(set);
for (size_t i = 1001; i > 0; i--)
{
cmc_assert_equals(size_t, i - 1, hs_iter_index(&it));
hs_iter_prev(&it);
}
hs_free(set);
});
});