Updating sortedlist iterators

tests/main/main.c

@@ -52,6 +52,7 @@ int main(void)
     cmc_run(Deque, units, tests);
     cmc_run(DequeIter, units, tests);
     cmc_run(HashBidiMap, units, tests);
+    cmc_run(HashBidiMapIter, units, tests);
     cmc_run(HashMap, units, tests);
     cmc_run(HashMapIter, units, tests);
     cmc_run(HashMultiMap, units, tests);

tests/main/src/sortedlist.c

@@ -10,8 +10,6 @@ struct sortedlist
     struct sortedlist_fval *f_val;
     struct cmc_alloc_node *alloc;
     struct cmc_callbacks *callbacks;
-    struct sortedlist_iter (*it_start)(struct sortedlist *);
-    struct sortedlist_iter (*it_end)(struct sortedlist *);
 };
 struct sortedlist_fval
 {
@@ -55,13 +53,12 @@ struct sortedlist *sl_copy_of(struct sortedlist *_list_);
 _Bool sl_equals(struct sortedlist *_list1_, struct sortedlist *_list2_);
 struct cmc_string sl_to_string(struct sortedlist *_list_);
 _Bool sl_print(struct sortedlist *_list_, FILE *fptr);
-struct sortedlist_iter *sl_iter_new(struct sortedlist *target);
-void sl_iter_free(struct sortedlist_iter *iter);
-void sl_iter_init(struct sortedlist_iter *iter, struct sortedlist *target);
-_Bool sl_iter_start(struct sortedlist_iter *iter);
-_Bool sl_iter_end(struct sortedlist_iter *iter);
-void sl_iter_to_start(struct sortedlist_iter *iter);
-void sl_iter_to_end(struct sortedlist_iter *iter);
+struct sortedlist_iter sl_iter_start(struct sortedlist *target);
+struct sortedlist_iter sl_iter_end(struct sortedlist *target);
+_Bool sl_iter_at_start(struct sortedlist_iter *iter);
+_Bool sl_iter_at_end(struct sortedlist_iter *iter);
+_Bool sl_iter_to_start(struct sortedlist_iter *iter);
+_Bool sl_iter_to_end(struct sortedlist_iter *iter);
 _Bool sl_iter_next(struct sortedlist_iter *iter);
 _Bool sl_iter_prev(struct sortedlist_iter *iter);
 _Bool sl_iter_advance(struct sortedlist_iter *iter, size_t steps);
@@ -77,8 +74,6 @@ void sl_impl_sort_quicksort(size_t *array, int (*cmp)(size_t, size_t),
                             size_t low, size_t high);
 void sl_impl_sort_insertion(size_t *array, int (*cmp)(size_t, size_t),
                             size_t low, size_t high);
-static struct sortedlist_iter sl_impl_it_start(struct sortedlist *_list_);
-static struct sortedlist_iter sl_impl_it_end(struct sortedlist *_list_);
 struct sortedlist *sl_new(size_t capacity, struct sortedlist_fval *f_val)
 {
     struct cmc_alloc_node *alloc = &cmc_alloc_node_default;
@@ -102,8 +97,6 @@ struct sortedlist *sl_new(size_t capacity, struct sortedlist_fval *f_val)
     _list_->f_val = f_val;
     _list_->alloc = alloc;
     _list_->callbacks = ((void *)0);
-    _list_->it_start = sl_impl_it_start;
-    _list_->it_end = sl_impl_it_end;
     return _list_;
 }
 struct sortedlist *sl_new_custom(size_t capacity, struct sortedlist_fval *f_val,
@@ -130,8 +123,6 @@ struct sortedlist *sl_new_custom(size_t capacity, struct sortedlist_fval *f_val,
     _list_->f_val = f_val;
     _list_->alloc = alloc;
     _list_->callbacks = callbacks;
-    _list_->it_start = sl_impl_it_start;
-    _list_->it_end = sl_impl_it_end;
     return _list_;
 }
 void sl_clear(struct sortedlist *_list_)
@@ -372,52 +363,57 @@ _Bool sl_print(struct sortedlist *_list_, FILE *fptr)
     }
     return 1;
 }
-struct sortedlist_iter *sl_iter_new(struct sortedlist *target)
-{
-    struct sortedlist_iter *iter =
-        target->alloc->malloc(sizeof(struct sortedlist_iter));
-    if (!iter)
-        return ((void *)0);
-    sl_iter_init(iter, target);
-    return iter;
-}
-void sl_iter_free(struct sortedlist_iter *iter)
-{
-    iter->target->alloc->free(iter);
-}
-void sl_iter_init(struct sortedlist_iter *iter, struct sortedlist *target)
+struct sortedlist_iter sl_iter_start(struct sortedlist *target)
 {
     sl_sort(target);
-    iter->target = target;
-    iter->cursor = 0;
-    iter->start = 1;
-    iter->end = sl_empty(target);
+    struct sortedlist_iter iter;
+    iter.target = target;
+    iter.cursor = 0;
+    iter.start = 1;
+    iter.end = sl_empty(target);
+    return iter;
 }
-_Bool sl_iter_start(struct sortedlist_iter *iter)
+struct sortedlist_iter sl_iter_end(struct sortedlist *target)
+{
+    sl_sort(target);
+    struct sortedlist_iter iter;
+    iter.target = target;
+    iter.cursor = 0;
+    iter.start = sl_empty(target);
+    iter.end = 1;
+    if (!sl_empty(target))
+        iter.cursor = target->count - 1;
+    return iter;
+}
+_Bool sl_iter_at_start(struct sortedlist_iter *iter)
 {
     return sl_empty(iter->target) || iter->start;
 }
-_Bool sl_iter_end(struct sortedlist_iter *iter)
+_Bool sl_iter_at_end(struct sortedlist_iter *iter)
 {
     return sl_empty(iter->target) || iter->end;
 }
-void sl_iter_to_start(struct sortedlist_iter *iter)
+_Bool sl_iter_to_start(struct sortedlist_iter *iter)
 {
     if (!sl_empty(iter->target))
     {
         iter->cursor = 0;
         iter->start = 1;
         iter->end = sl_empty(iter->target);
+        return 1;
     }
+    return 0;
 }
-void sl_iter_to_end(struct sortedlist_iter *iter)
+_Bool sl_iter_to_end(struct sortedlist_iter *iter)
 {
     if (!sl_empty(iter->target))
     {
         iter->start = sl_empty(iter->target);
-        iter->cursor = sl_empty(iter->target) ? 0 : iter->target->count - 1;
+        iter->cursor = iter->target->count - 1;
         iter->end = 1;
+        return 1;
     }
+    return 0;
 }
 _Bool sl_iter_next(struct sortedlist_iter *iter)
 {
@@ -588,17 +584,3 @@ void sl_impl_sort_insertion(size_t *array, int (*cmp)(size_t, size_t),
         array[j] = _tmp_;
     }
 }
-static struct sortedlist_iter sl_impl_it_start(struct sortedlist *_list_)
-{
-    struct sortedlist_iter iter;
-    sl_iter_init(&iter, _list_);
-    sl_iter_to_start(&iter);
-    return iter;
-}
-static struct sortedlist_iter sl_impl_it_end(struct sortedlist *_list_)
-{
-    struct sortedlist_iter iter;
-    sl_iter_init(&iter, _list_);
-    sl_iter_to_end(&iter);
-    return iter;
-}

tests/main/unt/sortedlist.c

@@ -314,7 +314,390 @@ CMC_CREATE_UNIT(SortedList, true, {
 });
 
 CMC_CREATE_UNIT(SortedListIter, true, {
+    CMC_CREATE_TEST(PFX##_iter_start(), {
+        struct sortedlist *sl = sl_new(100, sl_fval);
 
+        cmc_assert_not_equals(ptr, NULL, sl);
+
+        struct sortedlist_iter it = sl_iter_start(sl);
+
+        cmc_assert_equals(ptr, sl, it.target);
+        cmc_assert_equals(size_t, 0, it.cursor);
+        cmc_assert_equals(bool, true, it.start);
+        cmc_assert_equals(bool, true, it.end);
+
+        cmc_assert(sl_iter_at_start(&it));
+        cmc_assert(sl_iter_at_end(&it));
+
+        cmc_assert(sl_insert(sl, 1));
+        cmc_assert(sl_insert(sl, 2));
+
+        it = sl_iter_start(sl);
+
+        cmc_assert_equals(size_t, 0, it.cursor);
+        cmc_assert_equals(bool, false, it.end);
+
+        sl_free(sl);
+    });
+
+    CMC_CREATE_TEST(PFX##_iter_end(), {
+        struct sortedlist *sl = sl_new(100, sl_fval);
+
+        cmc_assert_not_equals(ptr, NULL, sl);
+
+        struct sortedlist_iter it = sl_iter_end(sl);
+
+        cmc_assert_equals(ptr, sl, it.target);
+        cmc_assert_equals(size_t, 0, it.cursor);
+        cmc_assert_equals(bool, true, it.start);
+        cmc_assert_equals(bool, true, it.end);
+
+        cmc_assert(sl_iter_at_start(&it));
+        cmc_assert(sl_iter_at_end(&it));
+
+        cmc_assert(sl_insert(sl, 1));
+        cmc_assert(sl_insert(sl, 2));
+        cmc_assert(sl_insert(sl, 3));
+
+        it = sl_iter_end(sl);
+
+        cmc_assert_equals(size_t, sl->count - 1, it.cursor);
+        cmc_assert_equals(bool, false, it.start);
+
+        sl_free(sl);
+    });
+
+    CMC_CREATE_TEST(PFX##_iter_at_start(), {
+        struct sortedlist *sl = sl_new(100, sl_fval);
+
+        cmc_assert_not_equals(ptr, NULL, sl);
+
+        struct sortedlist_iter it = sl_iter_start(sl);
+
+        // Empty checks
+        cmc_assert(sl_iter_at_start(&it));
+        it = sl_iter_end(sl);
+        cmc_assert(sl_iter_at_start(&it));
+
+        // Non-empty checks
+        cmc_assert(sl_insert(sl, 1));
+        it = sl_iter_end(sl);
+        cmc_assert(!sl_iter_at_start(&it));
+        it = sl_iter_start(sl);
+        cmc_assert(sl_iter_at_start(&it));
+
+        sl_free(sl);
+    });
+
+    CMC_CREATE_TEST(PFX##_iter_at_end(), {
+        struct sortedlist *sl = sl_new(100, sl_fval);
+
+        cmc_assert_not_equals(ptr, NULL, sl);
+
+        struct sortedlist_iter it = sl_iter_start(sl);
+
+        // Empty check
+        cmc_assert(sl_iter_at_end(&it));
+        it = sl_iter_end(sl);
+        cmc_assert(sl_iter_at_end(&it));
+
+        // Non-empty checks
+        cmc_assert(sl_insert(sl, 1));
+        it = sl_iter_end(sl);
+        cmc_assert(sl_iter_at_end(&it));
+        it = sl_iter_start(sl);
+        cmc_assert(!sl_iter_at_end(&it));
+
+        sl_free(sl);
+    });
+
+    CMC_CREATE_TEST(PFX##_iter_to_start(), {
+        struct sortedlist *sl = sl_new(100, sl_fval);
+
+        cmc_assert_not_equals(ptr, NULL, sl);
+
+        struct sortedlist_iter it = sl_iter_start(sl);
+
+        cmc_assert(!sl_iter_to_start(&it));
+
+        for (size_t i = 1; i <= 100; i++)
+            sl_insert(sl, i);
+
+        cmc_assert_equals(size_t, 100, sl->count);
+
+        it = sl_iter_end(sl);
+
+        cmc_assert(!sl_iter_at_start(&it));
+        cmc_assert(sl_iter_at_end(&it));
+
+        cmc_assert_equals(size_t, 100, sl_iter_value(&it));
+
+        cmc_assert(sl_iter_to_start(&it));
+
+        cmc_assert(sl_iter_at_start(&it));
+        cmc_assert(!sl_iter_at_end(&it));
+
+        cmc_assert_equals(size_t, 1, sl_iter_value(&it));
+
+        sl_free(sl);
+    });
+
+    CMC_CREATE_TEST(PFX##_iter_to_end(), {
+        struct sortedlist *sl = sl_new(100, sl_fval);
+
+        cmc_assert_not_equals(ptr, NULL, sl);
+
+        struct sortedlist_iter it = sl_iter_end(sl);
+
+        cmc_assert(!sl_iter_to_end(&it));
+
+        for (size_t i = 1; i <= 100; i++)
+            sl_insert(sl, i);
+
+        it = sl_iter_start(sl);
+
+        cmc_assert(sl_iter_at_start(&it));
+        cmc_assert(!sl_iter_at_end(&it));
+
+        cmc_assert_equals(size_t, 1, sl_iter_value(&it));
+
+        cmc_assert(sl_iter_to_end(&it));
+
+        cmc_assert(!sl_iter_at_start(&it));
+        cmc_assert(sl_iter_at_end(&it));
+
+        cmc_assert_equals(size_t, 100, sl_iter_value(&it));
+
+        sl_free(sl);
+    });
+
+    CMC_CREATE_TEST(PFX##_iter_next(), {
+        struct sortedlist *sl = sl_new(100, sl_fval);
+
+        cmc_assert_not_equals(ptr, NULL, sl);
+
+        struct sortedlist_iter it = sl_iter_start(sl);
+
+        cmc_assert(!sl_iter_next(&it));
+
+        for (size_t i = 1; i <= 1000; i++)
+            sl_insert(sl, i);
+
+        size_t sum = 0;
+        for (it = sl_iter_start(sl); !sl_iter_at_end(&it); sl_iter_next(&it))
+        {
+            sum += sl_iter_value(&it);
+        }
+
+        cmc_assert_equals(size_t, 500500, sum);
+
+        sum = 0;
+
+        sl_iter_to_start(&it);
+        do
+        {
+            sum += sl_iter_value(&it);
+        } while (sl_iter_next(&it));
+
+        cmc_assert_equals(size_t, 500500, sum);
+
+        sl_free(sl);
+    });
+
+    CMC_CREATE_TEST(PFX##_iter_prev(), {
+        struct sortedlist *sl = sl_new(100, sl_fval);
+
+        cmc_assert_not_equals(ptr, NULL, sl);
+
+        struct sortedlist_iter it = sl_iter_end(sl);
+
+        cmc_assert(!sl_iter_prev(&it));
+
+        for (size_t i = 1; i <= 1000; i++)
+            sl_insert(sl, i);
+
+        size_t sum = 0;
+        for (it = sl_iter_end(sl); !sl_iter_at_start(&it); sl_iter_prev(&it))
+        {
+            sum += sl_iter_value(&it);
+        }
+
+        cmc_assert_equals(size_t, 500500, sum);
+
+        sum = 0;
+
+        sl_iter_to_end(&it);
+        do
+        {
+            sum += sl_iter_value(&it);
+        } while (sl_iter_prev(&it));
+
+        cmc_assert_equals(size_t, 500500, sum);
+
+        sl_free(sl);
+    });
+
+    CMC_CREATE_TEST(PFX##_iter_advance(), {
+        struct sortedlist *sl = sl_new(100, sl_fval);
+
+        cmc_assert_not_equals(ptr, NULL, sl);
+
+        struct sortedlist_iter it = sl_iter_start(sl);
+
+        cmc_assert(!sl_iter_advance(&it, 1));
+
+        for (size_t i = 0; i <= 1000; i++)
+            sl_insert(sl, i);
+
+        it = sl_iter_start(sl);
+
+        cmc_assert(!sl_iter_advance(&it, 0));
+        cmc_assert(!sl_iter_advance(&it, sl->count));
+
+        size_t sum = 0;
+        for (it = sl_iter_start(sl);;)
+        {
+            sum += sl_iter_value(&it);
+
+            if (!sl_iter_advance(&it, 2))
+                break;
+        }
+
+        cmc_assert_equals(size_t, 250500, sum);
+
+        sl_iter_to_start(&it);
+        cmc_assert(sl_iter_advance(&it, sl->count - 1));
+
+        sl_free(sl);
+    });
+
+    CMC_CREATE_TEST(PFX##_iter_rewind(), {
+        struct sortedlist *sl = sl_new(100, sl_fval);
+
+        cmc_assert_not_equals(ptr, NULL, sl);
+
+        struct sortedlist_iter it = sl_iter_end(sl);
+
+        cmc_assert(!sl_iter_rewind(&it, 1));
+
+        for (size_t i = 0; i <= 1000; i++)
+            sl_insert(sl, i);
+
+        it = sl_iter_end(sl);
+
+        cmc_assert(!sl_iter_rewind(&it, 0));
+        cmc_assert(!sl_iter_rewind(&it, sl->count));
+
+        size_t sum = 0;
+        for (it = sl_iter_end(sl);;)
+        {
+            sum += sl_iter_value(&it);
+
+            if (!sl_iter_rewind(&it, 2))
+                break;
+        }
+
+        cmc_assert_equals(size_t, 250500, sum);
+
+        sl_iter_to_end(&it);
+        cmc_assert(sl_iter_rewind(&it, sl->count - 1));
+
+        sl_free(sl);
+    });
+
+    CMC_CREATE_TEST(PFX##_iter_go_to(), {
+        struct sortedlist *sl = sl_new(100, sl_fval);
+
+        cmc_assert_not_equals(ptr, NULL, sl);
+
+        struct sortedlist_iter it = sl_iter_end(sl);
+        cmc_assert(!sl_iter_go_to(&it, 0));
+
+        it = sl_iter_start(sl);
+        cmc_assert(!sl_iter_go_to(&it, 0));
+
+        for (size_t i = 0; i <= 1000; i++)
+            sl_insert(sl, i);
+
+        it = sl_iter_start(sl);
+
+        size_t sum = 0;
+        for (size_t i = 0; i < 1001; i++)
+        {
+            sl_iter_go_to(&it, i);
+
+            sum += sl_iter_value(&it);
+        }
+
+        cmc_assert_equals(size_t, 500500, sum);
+
+        sum = 0;
+        for (size_t i = 1001; i > 0; i--)
+        {
+            cmc_assert(sl_iter_go_to(&it, i - 1));
+
+            sum += sl_iter_value(&it);
+        }
+
+        cmc_assert_equals(size_t, 500500, sum);
+
+        sum = 0;
+        for (size_t i = 0; i < 1001; i += 100)
+        {
+            cmc_assert(sl_iter_go_to(&it, i));
+            cmc_assert_equals(size_t, i, sl_iter_index(&it));
+
+            sum += sl_iter_value(&it);
+        }
+
+        cmc_assert_equals(size_t, 5500, sum);
+
+        sl_free(sl);
+    });
+
+    CMC_CREATE_TEST(PFX##_iter_value(), {
+        struct sortedlist *sl = sl_new(100, sl_fval);
+
+        cmc_assert_not_equals(ptr, NULL, sl);
+
+        struct sortedlist_iter it = sl_iter_end(sl);
+
+        cmc_assert_equals(size_t, (size_t){ 0 }, sl_iter_value(&it));
+
+        cmc_assert(sl_insert(sl, 10));
+
+        it = sl_iter_start(sl);
+
+        cmc_assert_equals(size_t, 10, sl_iter_value(&it));
+
+        sl_free(sl);
+    });
+
+    CMC_CREATE_TEST(PFX##_iter_index(), {
+        struct sortedlist *sl = sl_new(100, sl_fval);
+
+        cmc_assert_not_equals(ptr, NULL, sl);
+
+        for (size_t i = 0; i <= 1000; i++)
+            sl_insert(sl, i);
+
+        struct sortedlist_iter it = sl_iter_start(sl);
+
+        for (size_t i = 0; i < 1001; i++)
+        {
+            cmc_assert_equals(size_t, i, sl_iter_index(&it));
+            sl_iter_next(&it);
+        }
+
+        it = sl_iter_end(sl);
+        for (size_t i = 1001; i > 0; i--)
+        {
+            cmc_assert_equals(size_t, i - 1, sl_iter_index(&it));
+            sl_iter_prev(&it);
+        }
+
+        sl_free(sl);
+    });
 });
 
 #ifdef CMC_TEST_MAIN