Removed PUBLIC and PRIVATE, corrected some examples and new test

.travis.yml

@@ -20,3 +20,7 @@ script:
   - ./contains
   - gcc pointertype.c -Wall -Wextra -o pointertype -std=c11
   - ./pointertype
+  - gcc -c ./sep/sep.c -Wall -Wextra -o sep.o -std=c11
+  - gcc -c ./sep/main.c -Wall -Wextra -o main.o -std=c11
+  - gcc sep.o main.o -o sep
+  - ./sep

README.md

@@ -85,12 +85,7 @@ Check out the **Documentation.md** to know exactly what represents the *end* and
 
 When including `macro_collections.h` in your source code you gain access to a macro called `COLLECTION_GENERATE` with the following parameters:
 
-> Note: in future updates, PRIVATE and PUBLIC will no longer exist
-
 * \*__C__ - Container name in uppercase (*LIST*, *LINKEDLIST*, *STACK*, *QUEUE*, *DEQUE*, *HEAP*, *TREESET*, *TREEMAP*, *HASHSET*, *HASHMAP*).
-* \*__P__ - Permission (PRIVATE, PUBLIC). Only matters when header and source are declared in separate files.
-	* *PRIVATE* - Members of a struct are hidden in source file and only accessible through functions.
-	* *PUBLIC* - Members of a struct are visible.
 * \*__PFX__ - Functions prefix or namespace.
 * \*__SNAME__ - Structure name (`typedef struct SNAME##_s SNAME`).
 * __FMOD__ - Function modifier (`static` or empty).

TODO

@@ -1,7 +1,7 @@
 TODO
 
 [ ] Finish Documentation
-[ ] Simplify PUBLIC and PRIVATE
+[X] Remove PUBLIC and PRIVATE
 [ ] Add multiset
 [ ] Add multimap
 [ ] Upgrade heap to a min-max heap
@@ -21,7 +21,7 @@ Before 2.0
     Get Documentation fixed and completed
 
 1.5
-    Remove PUBLIC and PRIVATE
+    OK - Remove PUBLIC and PRIVATE
     Iterator move and move_to
     LinkedList - Insert/Remove/Append/Prepend/Extract
     from_array - Creates a collection with all the elements in a specified array

benchmarks/benchmark.c

@@ -60,16 +60,16 @@ void shuffle(int *array, mt_state_ptr st)
     }
 }
 
-COLLECTION_GENERATE(LIST, PUBLIC, l, list, /* FMOD */, /* K */, int)
-COLLECTION_GENERATE(STACK, PUBLIC, s, stack, /* FMOD */, /* K */, int)
-COLLECTION_GENERATE(QUEUE, PUBLIC, q, queue, /* FMOD */, /* K */, int)
-COLLECTION_GENERATE(DEQUE, PUBLIC, d, deque, /* FMOD */, /* K */, int)
-COLLECTION_GENERATE(LINKEDLIST, PUBLIC, ll, linked, /* FMOD */, /* K */, int)
-COLLECTION_GENERATE(HEAP, PUBLIC, h, heap, /* FMOD */, /* K */, int)
-COLLECTION_GENERATE(TREESET, PUBLIC, ts, tset, /* FMOD */, /* K */, int)
-COLLECTION_GENERATE(TREEMAP, PUBLIC, tm, tmap, /* FMOD */, int, int)
-COLLECTION_GENERATE(HASHSET, PUBLIC, hs, hset, /* FMOD */, /* K */, int)
-COLLECTION_GENERATE(HASHMAP, PUBLIC, hm, hmap, /* FMOD */, int, int)
+COLLECTION_GENERATE(LIST, l, list, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE(STACK, s, stack, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE(QUEUE, q, queue, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE(DEQUE, d, deque, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE(LINKEDLIST, ll, linked, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE(HEAP, h, heap, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE(TREESET, ts, tset, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE(TREEMAP, tm, tmap, /* FMOD */, int, int)
+COLLECTION_GENERATE(HASHSET, hs, hset, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE(HASHMAP, hm, hmap, /* FMOD */, int, int)
 
 #define BENCHMARK(NAME, PFX, sname, initfunc, insertbody, removebody, searchbody)                                \
     void NAME##_io_benchmark(int *array, int *sarray, size_t s)                                                  \

examples/iterators/deque.c

@@ -9,7 +9,6 @@
  */
 #include "deque.h"
 #include <stdio.h>
-#include <stdlib.h>
 
 DEQUE_GENERATE(d, deque, static, int)
 

examples/iterators/hashmap.c

@@ -9,7 +9,6 @@
  */
 #include "hashmap.h"
 #include <stdio.h>
-#include <stdlib.h>
 
 HASHMAP_GENERATE(hm, hmap, static, int, double)
 
@@ -27,7 +26,7 @@ size_t inthash(int t)
 
 int intcmp(int a, int b)
 {
-    return a - b;
+    return (a > b) - (a < b);
 }
 
 int main(int argc, char const *argv[])
@@ -61,14 +60,14 @@ int main(int argc, char const *argv[])
 
     for (hm_iter_to_start(&iter); !hm_iter_end(&iter); hm_iter_next(&iter))
     {
-        printf("M[%2d] = { %2d : %2.2lf }\n", hm_iter_index(&iter), hm_iter_key(&iter), hm_iter_value(&iter));
+        printf("HM[%2d] = { %2d : %2.2lf }\n", hm_iter_index(&iter), hm_iter_key(&iter), hm_iter_value(&iter));
     }
 
     printf("\n");
 
     for (hm_iter_to_end(&iter); !hm_iter_start(&iter); hm_iter_prev(&iter))
     {
-        printf("M[%2d] = { %2d : %2.2lf }\n", hm_iter_index(&iter), hm_iter_key(&iter), hm_iter_value(&iter));
+        printf("HM[%2d] = { %2d : %2.2lf }\n", hm_iter_index(&iter), hm_iter_key(&iter), hm_iter_value(&iter));
     }
 
     hm_free(hm);

examples/iterators/hashset.c

@@ -9,7 +9,6 @@
  */
 #include "hashset.h"
 #include <stdio.h>
-#include <stdlib.h>
 
 HASHSET_GENERATE(hs, hset, static, int)
 
@@ -27,12 +26,12 @@ size_t inthash(int t)
 
 int intcmp(int a, int b)
 {
-    return a - b;
+    return (a > b) - (a < b);
 }
 
 int main(int argc, char const *argv[])
 {
-    // Initialize hash set and add some elements
+    // Initialize hashset and add some elements
     hset *hs = hs_new(10, 0.9, intcmp, inthash);
     for (int i = 0; i < 10; i++)
         hs_insert(hs, i);
@@ -60,14 +59,14 @@ int main(int argc, char const *argv[])
 
     for (hs_iter_to_start(&iter); !hs_iter_end(&iter); hs_iter_next(&iter))
     {
-        printf("S[%2d] = %2d\n", hs_iter_index(&iter), hs_iter_value(&iter));
+        printf("HS[%2d] = %2d\n", hs_iter_index(&iter), hs_iter_value(&iter));
     }
 
     printf("\n");
 
     for (hs_iter_to_end(&iter); !hs_iter_start(&iter); hs_iter_prev(&iter))
     {
-        printf("S[%2d] = %2d\n", hs_iter_index(&iter), hs_iter_value(&iter));
+        printf("HS[%2d] = %2d\n", hs_iter_index(&iter), hs_iter_value(&iter));
     }
 
     hs_free(hs);

examples/iterators/heap.c

@@ -9,11 +9,10 @@
  */
 #include "heap.h"
 #include <stdio.h>
-#include <stdlib.h>
 
 int intcmp(int a, int b)
 {
-    return a - b;
+    return (a > b) - (a < b);
 }
 
 HEAP_GENERATE(h, heap, static, int)

examples/iterators/linkedlist.c

@@ -9,20 +9,19 @@
  */
 #include "linkedlist.h"
 #include <stdio.h>
-#include <stdlib.h>
 
 LINKEDLIST_GENERATE(ll, linkedlist, static, int)
 
 int main(int argc, char const *argv[])
 {
-    // Initialize list and add some elements
-    linkedlist *l = ll_new();
+    // Initialize linkedlist and add some elements
+    linkedlist *ll = ll_new();
     for (int i = 0; i < 10; i++)
-        ll_push_back(l, i);
+        ll_push_back(ll, i);
 
     // Initialize iterator
     linkedlist_iter iter;
-    ll_iter_init(&iter, l);
+    ll_iter_init(&iter, ll);
 
     // Make the iterator go back and forward
     for (int j = 0; j < 4; j++)
@@ -53,7 +52,7 @@ int main(int argc, char const *argv[])
         printf("LL[%2d] = %2d\n", ll_iter_index(&iter), ll_iter_value(&iter));
     }
 
-    ll_free(l);
+    ll_free(ll);
 
     return 0;
 }

examples/iterators/list.c

@@ -9,7 +9,6 @@
  */
 #include "list.h"
 #include <stdio.h>
-#include <stdlib.h>
 
 LIST_GENERATE(l, list, static, int)
 

examples/iterators/queue.c

@@ -7,17 +7,13 @@
  * Leonardo Vencovsky (https://github.com/LeoVen)
  *
  */
-#include <stdio.h>
-#include <stdlib.h>
 #include "queue.h"
+#include <stdio.h>
 
 QUEUE_GENERATE(q, queue, static, int)
 
 int main(int argc, char const *argv[])
 {
-    size_t i;
-    int r;
-
     // Initialize queue and add some elements
     queue *q = q_new(10);
     for (int i = 0; i < 10; i++)
@@ -30,26 +26,30 @@ int main(int argc, char const *argv[])
     // Make the iterator go back and forward
     for (int j = 0; j < 4; j++)
     {
-        while (q_iter_next(&iter, &r, &i))
-            printf("C[%2d] = %2d\n", i, r);
+        while (!q_iter_end(&iter))
+        {
+            printf("C[%2d] = %2d\n", q_iter_index(&iter), q_iter_value(&iter));
+            q_iter_next(&iter);
+        }
         printf("\n");
-        while (q_iter_prev(&iter, &r, &i))
-            printf("C[%2d] = %2d\n", i, r);
+        while (!q_iter_start(&iter))
+        {
+            printf("C[%2d] = %2d\n", q_iter_index(&iter), q_iter_value(&iter));
+            q_iter_prev(&iter);
+        }
         printf("\n\n");
     }
 
-    for (q_iter_tostart(&iter); !q_iter_end(&iter); /**/)
+    for (q_iter_to_start(&iter); !q_iter_end(&iter); q_iter_next(&iter))
     {
-        q_iter_next(&iter, &r, &i);
-        printf("Q[%2d] = %2d\n", i, r);
+        printf("Q[%2d] = %2d\n", q_iter_index(&iter), q_iter_value(&iter));
     }
 
     printf("\n");
 
-    for (q_iter_toend(&iter); !q_iter_start(&iter); /**/)
+    for (q_iter_to_end(&iter); !q_iter_start(&iter); q_iter_prev(&iter))
     {
-        q_iter_prev(&iter, &r, &i);
-        printf("Q[%2d] = %2d\n", i, r);
+        printf("Q[%2d] = %2d\n", q_iter_index(&iter), q_iter_value(&iter));
     }
 
     q_free(q);

examples/iterators/stack.c

@@ -7,17 +7,13 @@
  * Leonardo Vencovsky (https://github.com/LeoVen)
  *
  */
-#include <stdio.h>
-#include <stdlib.h>
 #include "stack.h"
+#include <stdio.h>
 
 STACK_GENERATE(s, stack, static, int)
 
 int main(int argc, char const *argv[])
 {
-    size_t i;
-    int r;
-
     // Initialize stack and add some elements
     stack *s = s_new(10);
     for (int i = 0; i < 10; i++)
@@ -30,26 +26,30 @@ int main(int argc, char const *argv[])
     // Make the iterator go back and forward
     for (int j = 0; j < 4; j++)
     {
-        while (s_iter_next(&iter, &r, &i))
-            printf("C[%2d] = %2d\n", i, r);
+        while (!s_iter_end(&iter))
+        {
+            printf("C[%2d] = %2d\n", s_iter_index(&iter), s_iter_value(&iter));
+            s_iter_next(&iter);
+        }
         printf("\n");
-        while (s_iter_prev(&iter, &r, &i))
-            printf("C[%2d] = %2d\n", i, r);
+        while (!s_iter_start(&iter))
+        {
+            printf("C[%2d] = %2d\n", s_iter_index(&iter), s_iter_value(&iter));
+            s_iter_prev(&iter);
+        }
         printf("\n\n");
     }
 
-    for (s_iter_tostart(&iter); !s_iter_end(&iter); /**/)
+    for (s_iter_to_start(&iter); !s_iter_end(&iter); s_iter_next(&iter))
     {
-        s_iter_next(&iter, &r, &i);
-        printf("S[%2d] = %2d\n", i, r);
+        printf("S[%2d] = %2d\n", s_iter_index(&iter), s_iter_value(&iter));
     }
 
     printf("\n");
 
-    for (s_iter_toend(&iter); !s_iter_start(&iter); /**/)
+    for (s_iter_to_end(&iter); !s_iter_start(&iter); s_iter_prev(&iter))
     {
-        s_iter_prev(&iter, &r, &i);
-        printf("S[%2d] = %2d\n", i, r);
+        printf("S[%2d] = %2d\n", s_iter_index(&iter), s_iter_value(&iter));
     }
 
     s_free(s);

examples/iterators/treemap.c

@@ -7,58 +7,58 @@
  * Leonardo Vencovsky (https://github.com/LeoVen)
  *
  */
-#include <stdio.h>
-#include <stdlib.h>
 #include "treemap.h"
+#include <stdio.h>
 
 int intcmp(int a, int b)
 {
-    return a - b;
+    return (a > b) - (a < b);
 }
 
 TREEMAP_GENERATE(tm, tmap, static, int, double)
 
 int main(int argc, char const *argv[])
 {
-    size_t i;
-    int k;
-    double v, varr[10] = {0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9};
+    double varr[10] = {0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9};
 
     // Initialize treemap and add some element
-    tmap *tm = tm_new(intcmp);
+    tmap *hm = tm_new(intcmp);
     for (int i = 0; i < 10; i++)
-        tm_insert(tm, i, varr[i]);
+        tm_insert(hm, i, varr[i]);
 
     // Initialize iterator
     tmap_iter iter;
-    tm_iter_init(&iter, tm);
+    tm_iter_init(&iter, hm);
 
-    // Make the iterator go back and forward
     for (int j = 0; j < 4; j++)
     {
-        while (tm_iter_next(&iter, &k, &v, &i))
-            printf("S[%2d] = { %2d : %2.2lf }\n", i, k, v);
+        while (!tm_iter_end(&iter))
+        {
+            printf("C[%2d] = { %2d : %2.2lf }\n", tm_iter_index(&iter), tm_iter_key(&iter), tm_iter_value(&iter));
+            tm_iter_next(&iter);
+        }
         printf("\n");
-        while (tm_iter_prev(&iter, &k, &v, &i))
-            printf("S[%2d] = { %2d : %2.2lf }\n", i, k, v);
+        while (!tm_iter_start(&iter))
+        {
+            printf("C[%2d] = { %2d : %2.2lf }\n", tm_iter_index(&iter), tm_iter_key(&iter), tm_iter_value(&iter));
+            tm_iter_prev(&iter);
+        }
         printf("\n\n");
     }
 
-    for (tm_iter_tostart(&iter); !tm_iter_end(&iter); /**/)
+    for (tm_iter_to_start(&iter); !tm_iter_end(&iter); tm_iter_next(&iter))
     {
-        tm_iter_next(&iter, &k, &v, &i);
-        printf("M[%2d] = { %2d : %2.2lf }\n", i, k, v);
+        printf("TM[%2d] = { %2d : %2.2lf }\n", tm_iter_index(&iter), tm_iter_key(&iter), tm_iter_value(&iter));
     }
 
     printf("\n");
 
-    for (tm_iter_toend(&iter); !tm_iter_start(&iter); /**/)
+    for (tm_iter_to_end(&iter); !tm_iter_start(&iter); tm_iter_prev(&iter))
     {
-        tm_iter_prev(&iter, &k, &v, &i);
-        printf("M[%2d] = { %2d : %2.2lf }\n", i, k, v);
+        printf("TM[%2d] = { %2d : %2.2lf }\n", tm_iter_index(&iter), tm_iter_key(&iter), tm_iter_value(&iter));
     }
 
-    tm_free(tm);
+    tm_free(hm);
 
     return 0;
 }

examples/iterators/treeset.c

@@ -7,22 +7,18 @@
  * Leonardo Vencovsky (https://github.com/LeoVen)
  *
  */
-#include <stdio.h>
-#include <stdlib.h>
 #include "treeset.h"
+#include <stdio.h>
 
 int intcmp(int a, int b)
 {
-    return a - b;
+    return (a > b) - (a < b);
 }
 
 TREESET_GENERATE(ts, tset, static, int)
 
 int main(int argc, char const *argv[])
 {
-    size_t i;
-    int r;
-
     // Initialize treeset and add some elements
     tset *ts = ts_new(intcmp);
     for (int i = 0; i < 10; i++)
@@ -35,26 +31,30 @@ int main(int argc, char const *argv[])
     // Make the iterator go back and forward
     for (int j = 0; j < 4; j++)
     {
-        while (ts_iter_next(&iter, &r, &i))
-            printf("C[%2d] = %2d\n", i, r);
+        while (!ts_iter_end(&iter))
+        {
+            printf("C[%2d] = %2d\n", ts_iter_index(&iter), ts_iter_value(&iter));
+            ts_iter_next(&iter);
+        }
         printf("\n");
-        while (ts_iter_prev(&iter, &r, &i))
-            printf("C[%2d] = %2d\n", i, r);
+        while (!ts_iter_start(&iter))
+        {
+            printf("C[%2d] = %2d\n", ts_iter_index(&iter), ts_iter_value(&iter));
+            ts_iter_prev(&iter);
+        }
         printf("\n\n");
     }
 
-    for (ts_iter_tostart(&iter); !ts_iter_end(&iter); /**/)
+    for (ts_iter_to_start(&iter); !ts_iter_end(&iter); ts_iter_next(&iter))
     {
-        ts_iter_next(&iter, &r, &i);
-        printf("S[%2d] = %2d\n", i, r);
+        printf("TS[%2d] = %2d\n", ts_iter_index(&iter), ts_iter_value(&iter));
     }
 
     printf("\n");
 
-    for (ts_iter_toend(&iter); !ts_iter_start(&iter); /**/)
+    for (ts_iter_to_end(&iter); !ts_iter_start(&iter); ts_iter_prev(&iter))
     {
-        ts_iter_prev(&iter, &r, &i);
-        printf("S[%2d] = %2d\n", i, r);
+        printf("TS[%2d] = %2d\n", ts_iter_index(&iter), ts_iter_value(&iter));
     }
 
     ts_free(ts);

examples/others/README.md

@@ -1,5 +1,5 @@
 # Other examples
 
 * book_store - A book store where its books are loaded onto a list from a csv file. The newly added ones go to a queue of featured books where old ones are removed to give place to new ones. You can find a book by looking up its ISBN using a treemap or traversing the treemap and find all ISBNs of a corresponding title.
-* separate_header_source - Example of how to used `PUBLIC` and `PRIVATE` parameters.
-* for_each.c - Using the `FOR_EACH`.
+* separate_header_source - Example of how to compile the header and source separately.
+* for_each.c - Using the `FOR_EACH` macro.

examples/others/book_store/main.c

@@ -9,11 +9,11 @@
 #include "book.c"
 #include "random.c"
 
-COLLECTION_GENERATE(LIST, PUBLIC, l, list, , , book *)
-COLLECTION_GENERATE(LIST, PUBLIC, il, intlist, , , int)
-COLLECTION_GENERATE(QUEUE, PUBLIC, q, queue, , , book *)
-COLLECTION_GENERATE(TREEMAP, PUBLIC, map, map, , int, char *)
-COLLECTION_GENERATE(TREESET, PUBLIC, set, set, , , char *)
+COLLECTION_GENERATE(LIST, l, list, , , book *)
+COLLECTION_GENERATE(LIST, il, intlist, , , int)
+COLLECTION_GENERATE(QUEUE, q, queue, , , book *)
+COLLECTION_GENERATE(TREEMAP, map, map, , int, char *)
+COLLECTION_GENERATE(TREESET, set, set, , , char *)
 
 list *load(void);
 void shuffle(list *l);
@@ -48,7 +48,9 @@ int main(int argc, char const *argv[])
     set *counter = set_new(chrcmp);
 
     // Add everything to its place.
-    FOR_EACH(l, list, book *, books, {
+    FOR_EACH(l, list, books, {
+        book *value = l_iter_value(&iter);
+
         // Keep the last added elements
         if (q_count(shelf) > 7)
         {
@@ -64,7 +66,8 @@ int main(int argc, char const *argv[])
     printf("Library Size: %d\n", map_count(library));
     printf("Unique book titles: %d\n\n", set_count(counter));
     printf("Showcase Books:\n");
-    FOR_EACH(q, queue, book *, shelf, {
+    FOR_EACH(q, queue, shelf, {
+        book *value = q_iter_value(&iter);
         printf("[ %d : %-45s ]\n", value->isbn, value->name);
     })
     printf("\n");
@@ -113,13 +116,16 @@ int main(int argc, char const *argv[])
 
             intlist *search_list = il_new(32);
 
-            FOR_EACH_MAP(map, map, int, char *, library, {
+            FOR_EACH(map, map, library, {
+                int key = map_iter_key(&iter);
+                char *value = map_iter_value(&iter);
+
                 if (chrcmp(buffer, value) == 0)
                     il_push_back(search_list, key);
             })
 
-            FOR_EACH(il, intlist, int, search_list, {
-                printf("[ %d ]\n", value);
+            FOR_EACH(il, intlist, search_list, {
+                printf("[ %d ]\n", il_iter_value(&iter));
             })
 
             il_free(search_list);
@@ -127,9 +133,13 @@ int main(int argc, char const *argv[])
     }
 
     // Free all memory used by struct book
-    FOR_EACH(l, list, book *, books, {
-        free(value->name);
-        free(value);
+    FOR_EACH(l, list, books, {
+        book *b = l_iter_value(&iter);
+
+        if (b)
+            free(b->name);
+
+        free(b);
     })
 
     l_free(books);

examples/others/for_each.c

@@ -4,16 +4,16 @@
 #include "macro_collections.h"
 
 // Create containers to use only in this file
-COLLECTION_GENERATE(LIST, PUBLIC, l, list, static, , int)
-COLLECTION_GENERATE(LINKEDLIST, PUBLIC, ll, llist, static, , int)
-COLLECTION_GENERATE(STACK, PUBLIC, s, stack, static, , int)
-COLLECTION_GENERATE(QUEUE, PUBLIC, q, queue, static, , int)
-COLLECTION_GENERATE(DEQUE, PUBLIC, d, deque, static, , int)
-COLLECTION_GENERATE(TREESET, PUBLIC, ts, tset, static, , int)
+COLLECTION_GENERATE(LIST, l, list, static, , int)
+COLLECTION_GENERATE(LINKEDLIST, ll, llist, static, , int)
+COLLECTION_GENERATE(STACK, s, stack, static, , int)
+COLLECTION_GENERATE(QUEUE, q, queue, static, , int)
+COLLECTION_GENERATE(DEQUE, d, deque, static, , int)
+COLLECTION_GENERATE(TREESET, ts, tset, static, , int)
 
 int intcmp(int a, int b)
 {
-    return a - b;
+    return (a > b) - (a < b);
 }
 
 int main(int argc, char const *argv[])
@@ -58,7 +58,9 @@ int main(int argc, char const *argv[])
     // - value : the elements that changes with each iteration
     // - index : iteration index (first iteration is 0 and last is count - 1)
     // - iter : iterator struct
-    FOR_EACH(l, list, int, l, {
+    FOR_EACH(l, list, l, {
+        int value = l_iter_value(&iter);
+        size_t index = l_iter_index(&iter);
         if (index == 0)
             printf("[ %d, ", value);
         else if (index == iter.target->count - 1)
@@ -67,7 +69,9 @@ int main(int argc, char const *argv[])
             printf("%d, ", value);
     })
 
-    FOR_EACH(s, stack, int, s, {
+    FOR_EACH(s, stack, s, {
+        int value = s_iter_value(&iter);
+        size_t index = s_iter_index(&iter);
         if (index == 0)
             printf("[ %d, ", value);
         else if (index == iter.target->count - 1)
@@ -76,7 +80,9 @@ int main(int argc, char const *argv[])
             printf("%d, ", value);
     })
 
-    FOR_EACH(q, queue, int, q, {
+    FOR_EACH(q, queue, q, {
+        int value = q_iter_value(&iter);
+        size_t index = q_iter_index(&iter);
         if (index == 0)
             printf("[ %d, ", value);
         else if (index == iter.target->count - 1)
@@ -85,7 +91,9 @@ int main(int argc, char const *argv[])
             printf("%d, ", value);
     })
 
-    FOR_EACH(d, deque, int, d, {
+    FOR_EACH(d, deque, d, {
+        int value = d_iter_value(&iter);
+        size_t index = d_iter_index(&iter);
         if (index == 0)
             printf("[ %d, ", value);
         else if (index == iter.target->count - 1)
@@ -94,7 +102,9 @@ int main(int argc, char const *argv[])
             printf("%d, ", value);
     })
 
-    FOR_EACH(ll, llist, int, ll, {
+    FOR_EACH(ll, llist, ll, {
+        int value = ll_iter_value(&iter);
+        size_t index = ll_iter_index(&iter);
         if (index == 0)
             printf("[ %d, ", value);
         else if (index == iter.target->count - 1)
@@ -103,7 +113,9 @@ int main(int argc, char const *argv[])
             printf("%d, ", value);
     })
 
-    FOR_EACH(ts, tset, int, ts, {
+    FOR_EACH(ts, tset, ts, {
+        int value = ts_iter_value(&iter);
+        size_t index = ts_iter_index(&iter);
         if (index == 0)
             printf("[ %d, ", value);
         else if (index == iter.target->count - 1)

examples/others/separate_header_source/containers.c

@@ -1,6 +1,6 @@
 #include "containers.h"
 
-COLLECTION_GENERATE_SOURCE(LIST, PUBLIC, il, int_list, , , int)
-COLLECTION_GENERATE_SOURCE(STACK, PRIVATE, cs, char_stack, , , char)
-COLLECTION_GENERATE_SOURCE(QUEUE, PUBLIC, queue, index_queue, , , size_t)
-COLLECTION_GENERATE_SOURCE(DEQUE, PUBLIC, dq, deque, , , int)
+COLLECTION_GENERATE_SOURCE(LIST, il, int_list, , , int)
+COLLECTION_GENERATE_SOURCE(STACK, cs, char_stack, , , char)
+COLLECTION_GENERATE_SOURCE(QUEUE, queue, index_queue, , , size_t)
+COLLECTION_GENERATE_SOURCE(DEQUE, dq, deque, , , int)

examples/others/separate_header_source/containers.h

@@ -3,7 +3,7 @@
 #include <stdbool.h>
 #include "macro_collections.h"
 
-COLLECTION_GENERATE_HEADER(LIST, PUBLIC, il, int_list, , , int)
-COLLECTION_GENERATE_HEADER(STACK, PRIVATE, cs, char_stack, , , char)
-COLLECTION_GENERATE_HEADER(QUEUE, PUBLIC, queue, index_queue, , , size_t)
-COLLECTION_GENERATE_HEADER(DEQUE, PUBLIC, dq, deque, , , int)
+COLLECTION_GENERATE_HEADER(LIST, il, int_list, , , int)
+COLLECTION_GENERATE_HEADER(STACK, cs, char_stack, , , char)
+COLLECTION_GENERATE_HEADER(QUEUE, queue, index_queue, , , size_t)
+COLLECTION_GENERATE_HEADER(DEQUE, dq, deque, , , int)

examples/others/separate_header_source/main.c

@@ -184,9 +184,8 @@ int main(void)
         il_push_back(integers, i);
 
     int sum = 0;
-    FOR_EACH(il, int_list, int, integers, {
-        printf("%d, ", value);
-        sum += value;
+    FOR_EACH(il, int_list, integers, {
+        sum += il_iter_value(&iter);
     })
 
     printf("\n\nSUM: %d\n", sum);
@@ -255,8 +254,8 @@ int main(void)
 
     int sum3 = 0;
 
-    FOR_EACH(dq, deque, int, d, {
-        sum3 += value;
+    FOR_EACH(dq, deque, d, {
+        sum3 += dq_iter_value(&iter);
     })
 
     printf("Deque sum: %d\n", sum3);

src/deque.h

@@ -20,24 +20,14 @@
 #include <string.h>
 
 #define DEQUE_GENERATE(PFX, SNAME, FMOD, V)    \
-    DEQUE_GENERATE_STRUCT(PFX, SNAME, FMOD, V) \
     DEQUE_GENERATE_HEADER(PFX, SNAME, FMOD, V) \
     DEQUE_GENERATE_SOURCE(PFX, SNAME, FMOD, V)
 
-/* PRIVATE *******************************************************************/
-#define DEQUE_GENERATE_HEADER_PRIVATE(PFX, SNAME, FMOD, K, V) \
+#define DEQUE_WRAPGEN_HEADER(PFX, SNAME, FMOD, K, V) \
     DEQUE_GENERATE_HEADER(PFX, SNAME, FMOD, V)
-#define DEQUE_GENERATE_SOURCE_PRIVATE(PFX, SNAME, FMOD, K, V) \
-    DEQUE_GENERATE_STRUCT(PFX, SNAME, FMOD, V)                \
+
+#define DEQUE_WRAPGEN_SOURCE(PFX, SNAME, FMOD, K, V) \
     DEQUE_GENERATE_SOURCE(PFX, SNAME, FMOD, V)
-/* PUBLIC ********************************************************************/
-#define DEQUE_GENERATE_HEADER_PUBLIC(PFX, SNAME, FMOD, K, V) \
-    DEQUE_GENERATE_STRUCT(PFX, SNAME, FMOD, V)               \
-    DEQUE_GENERATE_HEADER(PFX, SNAME, FMOD, V)
-#define DEQUE_GENERATE_SOURCE_PUBLIC(PFX, SNAME, FMOD, K, V) \
-    DEQUE_GENERATE_SOURCE(PFX, SNAME, FMOD, V)
-/* STRUCT ********************************************************************/
-#define DEQUE_GENERATE_STRUCT(PFX, SNAME, FMOD, V)
 
 /* HEADER ********************************************************************/
 #define DEQUE_GENERATE_HEADER(PFX, SNAME, FMOD, V)                                \

src/hashmap.h

@@ -64,24 +64,14 @@ static const size_t cmc_hashtable_primes[] = {53, 97, 191, 383, 769, 1531,
 #endif /* CMC_HASH_TABLE_SETUP */
 
 #define HASHMAP_GENERATE(PFX, SNAME, FMOD, K, V)    \
-    HASHMAP_GENERATE_STRUCT(PFX, SNAME, FMOD, K, V) \
     HASHMAP_GENERATE_HEADER(PFX, SNAME, FMOD, K, V) \
     HASHMAP_GENERATE_SOURCE(PFX, SNAME, FMOD, K, V)
 
-/* PRIVATE *******************************************************************/
-#define HASHMAP_GENERATE_HEADER_PRIVATE(PFX, SNAME, FMOD, K, V) \
+#define HASHMAP_WRAPGEN_HEADER(PFX, SNAME, FMOD, K, V) \
     HASHMAP_GENERATE_HEADER(PFX, SNAME, FMOD, K, V)
-#define HASHMAP_GENERATE_SOURCE_PRIVATE(PFX, SNAME, FMOD, K, V) \
-    HASHMAP_GENERATE_STRUCT(PFX, SNAME, FMOD, K, V)             \
+
+#define HASHMAP_WRAPGEN_SOURCE(PFX, SNAME, FMOD, K, V) \
     HASHMAP_GENERATE_SOURCE(PFX, SNAME, FMOD, K, V)
-/* PUBLIC ********************************************************************/
-#define HASHMAP_GENERATE_HEADER_PUBLIC(PFX, SNAME, FMOD, K, V) \
-    HASHMAP_GENERATE_STRUCT(PFX, SNAME, FMOD, K, V)            \
-    HASHMAP_GENERATE_HEADER(PFX, SNAME, FMOD, K, V)
-#define HASHMAP_GENERATE_SOURCE_PUBLIC(PFX, SNAME, FMOD, K, V) \
-    HASHMAP_GENERATE_SOURCE(PFX, SNAME, FMOD, K, V)
-/* STRUCT ********************************************************************/
-#define HASHMAP_GENERATE_STRUCT(PFX, SNAME, FMOD, K, V)
 
 /* HEADER ********************************************************************/
 #define HASHMAP_GENERATE_HEADER(PFX, SNAME, FMOD, K, V)                                       \

src/hashset.h

@@ -64,24 +64,14 @@ static const size_t cmc_hashtable_primes[] = {53, 97, 191, 383, 769, 1531,
 #endif /* CMC_HASH_TABLE_SETUP */
 
 #define HASHSET_GENERATE(PFX, SNAME, FMOD, V)    \
-    HASHSET_GENERATE_STRUCT(PFX, SNAME, FMOD, V) \
     HASHSET_GENERATE_HEADER(PFX, SNAME, FMOD, V) \
     HASHSET_GENERATE_SOURCE(PFX, SNAME, FMOD, V)
 
-/* PRIVATE *******************************************************************/
-#define HASHSET_GENERATE_HEADER_PRIVATE(PFX, SNAME, FMOD, K, V) \
+#define HASHSET_WRAPGEN_HEADER(PFX, SNAME, FMOD, K, V) \
     HASHSET_GENERATE_HEADER(PFX, SNAME, FMOD, V)
-#define HASHSET_GENERATE_SOURCE_PRIVATE(PFX, SNAME, FMOD, K, V) \
-    HASHSET_GENERATE_STRUCT(PFX, SNAME, FMOD, V)                \
+
+#define HASHSET_WRAPGEN_SOURCE(PFX, SNAME, FMOD, K, V) \
     HASHSET_GENERATE_SOURCE(PFX, SNAME, FMOD, V)
-/* PUBLIC ********************************************************************/
-#define HASHSET_GENERATE_HEADER_PUBLIC(PFX, SNAME, FMOD, K, V) \
-    HASHSET_GENERATE_STRUCT(PFX, SNAME, FMOD, V)               \
-    HASHSET_GENERATE_HEADER(PFX, SNAME, FMOD, V)
-#define HASHSET_GENERATE_SOURCE_PUBLIC(PFX, SNAME, FMOD, K, V) \
-    HASHSET_GENERATE_SOURCE(PFX, SNAME, FMOD, V)
-/* STRUCT ********************************************************************/
-#define HASHSET_GENERATE_STRUCT(PFX, SNAME, FMOD, V)
 
 /* HEADER ********************************************************************/
 #define HASHSET_GENERATE_HEADER(PFX, SNAME, FMOD, V)                                          \

src/heap.h

@@ -26,24 +26,14 @@ typedef enum HeapOrder
 } HeapOrder;
 
 #define HEAP_GENERATE(PFX, SNAME, FMOD, V)    \
-    HEAP_GENERATE_STRUCT(PFX, SNAME, FMOD, V) \
     HEAP_GENERATE_HEADER(PFX, SNAME, FMOD, V) \
     HEAP_GENERATE_SOURCE(PFX, SNAME, FMOD, V)
 
-/* PRIVATE *******************************************************************/
-#define HEAP_GENERATE_HEADER_PRIVATE(PFX, SNAME, FMOD, K, V) \
+#define HEAP_WRAPGEN_HEADER(PFX, SNAME, FMOD, K, V) \
     HEAP_GENERATE_HEADER(PFX, SNAME, FMOD, V)
-#define HEAP_GENERATE_SOURCE_PRIVATE(PFX, SNAME, FMOD, K, V) \
-    HEAP_GENERATE_STRUCT(PFX, SNAME, FMOD, V)                \
+
+#define HEAP_WRAPGEN_SOURCE(PFX, SNAME, FMOD, K, V) \
     HEAP_GENERATE_SOURCE(PFX, SNAME, FMOD, V)
-/* PUBLIC ********************************************************************/
-#define HEAP_GENERATE_HEADER_PUBLIC(PFX, SNAME, FMOD, K, V) \
-    HEAP_GENERATE_STRUCT(PFX, SNAME, FMOD, V)               \
-    HEAP_GENERATE_HEADER(PFX, SNAME, FMOD, V)
-#define HEAP_GENERATE_SOURCE_PUBLIC(PFX, SNAME, FMOD, K, V) \
-    HEAP_GENERATE_SOURCE(PFX, SNAME, FMOD, V)
-/* STRUCT ********************************************************************/
-#define HEAP_GENERATE_STRUCT(PFX, SNAME, FMOD, V)
 
 /* HEADER ********************************************************************/
 #define HEAP_GENERATE_HEADER(PFX, SNAME, FMOD, V)                           \

src/linkedlist.h

@@ -19,24 +19,14 @@
 #include <stdbool.h>
 
 #define LINKEDLIST_GENERATE(PFX, SNAME, FMOD, V)    \
-    LINKEDLIST_GENERATE_STRUCT(PFX, SNAME, FMOD, V) \
     LINKEDLIST_GENERATE_HEADER(PFX, SNAME, FMOD, V) \
     LINKEDLIST_GENERATE_SOURCE(PFX, SNAME, FMOD, V)
 
-/* PRIVATE *******************************************************************/
-#define LINKEDLIST_GENERATE_HEADER_PRIVATE(PFX, SNAME, FMOD, K, V) \
+#define LINKEDLIST_WRAPGEN_HEADER(PFX, SNAME, FMOD, K, V) \
     LINKEDLIST_GENERATE_HEADER(PFX, SNAME, FMOD, V)
-#define LINKEDLIST_GENERATE_SOURCE_PRIVATE(PFX, SNAME, FMOD, K, V) \
-    LINKEDLIST_GENERATE_STRUCT(PFX, SNAME, FMOD, V)                \
+
+#define LINKEDLIST_WRAPGEN_SOURCE(PFX, SNAME, FMOD, K, V) \
     LINKEDLIST_GENERATE_SOURCE(PFX, SNAME, FMOD, V)
-/* PUBLIC ********************************************************************/
-#define LINKEDLIST_GENERATE_HEADER_PUBLIC(PFX, SNAME, FMOD, K, V) \
-    LINKEDLIST_GENERATE_STRUCT(PFX, SNAME, FMOD, V)               \
-    LINKEDLIST_GENERATE_HEADER(PFX, SNAME, FMOD, V)
-#define LINKEDLIST_GENERATE_SOURCE_PUBLIC(PFX, SNAME, FMOD, K, V) \
-    LINKEDLIST_GENERATE_SOURCE(PFX, SNAME, FMOD, V)
-/* STRUCT ********************************************************************/
-#define LINKEDLIST_GENERATE_STRUCT(PFX, SNAME, FMOD, V)
 
 /* HEADER ********************************************************************/
 #define LINKEDLIST_GENERATE_HEADER(PFX, SNAME, FMOD, V)                              \

src/list.h

@@ -20,24 +20,14 @@
 #include <string.h>
 
 #define LIST_GENERATE(PFX, SNAME, FMOD, V)    \
-    LIST_GENERATE_STRUCT(PFX, SNAME, FMOD, V) \
     LIST_GENERATE_HEADER(PFX, SNAME, FMOD, V) \
     LIST_GENERATE_SOURCE(PFX, SNAME, FMOD, V)
 
-/* PRIVATE *******************************************************************/
-#define LIST_GENERATE_HEADER_PRIVATE(PFX, SNAME, FMOD, K, V) \
+#define LIST_WRAPGEN_HEADER(PFX, SNAME, FMOD, K, V) \
     LIST_GENERATE_HEADER(PFX, SNAME, FMOD, V)
-#define LIST_GENERATE_SOURCE_PRIVATE(PFX, SNAME, FMOD, K, V) \
-    LIST_GENERATE_STRUCT(PFX, SNAME, FMOD, V)                \
+
+#define LIST_WRAPGEN_SOURCE(PFX, SNAME, FMOD, K, V) \
     LIST_GENERATE_SOURCE(PFX, SNAME, FMOD, V)
-/* PUBLIC ********************************************************************/
-#define LIST_GENERATE_HEADER_PUBLIC(PFX, SNAME, FMOD, K, V) \
-    LIST_GENERATE_STRUCT(PFX, SNAME, FMOD, V)               \
-    LIST_GENERATE_HEADER(PFX, SNAME, FMOD, V)
-#define LIST_GENERATE_SOURCE_PUBLIC(PFX, SNAME, FMOD, K, V) \
-    LIST_GENERATE_SOURCE(PFX, SNAME, FMOD, V)
-/* STRUCT ********************************************************************/
-#define LIST_GENERATE_STRUCT(PFX, SNAME, FMOD, V)
 
 /* HEADER ********************************************************************/
 #define LIST_GENERATE_HEADER(PFX, SNAME, FMOD, V)                                                  \

src/macro_collections.h

@@ -14,22 +14,22 @@
 #include <stdlib.h>
 #include <stdbool.h>
 
-#define CONCATH_(C, P) C##_GENERATE_HEADER##_##P
-#define CONCATC_(C, P) C##_GENERATE_SOURCE##_##P
+#define CONCATH_(C) C##_WRAPGEN_HEADER
+#define CONCATC_(C) C##_WRAPGEN_SOURCE
 
-#define CONCATH(C, P) CONCATH_(C, P)
-#define CONCATC(C, P) CONCATC_(C, P)
+#define CONCATH(C) CONCATH_(C)
+#define CONCATC(C) CONCATC_(C)
 
-#define COLLECTION_GENERATE(C, P, PFX, SNAME, FMOD, K, V)    \
-    COLLECTION_GENERATE_HEADER(C, P, PFX, SNAME, FMOD, K, V) \
-    COLLECTION_GENERATE_SOURCE(C, P, PFX, SNAME, FMOD, K, V)
+#define COLLECTION_GENERATE(C, PFX, SNAME, FMOD, K, V)    \
+    COLLECTION_GENERATE_HEADER(C, PFX, SNAME, FMOD, K, V) \
+    COLLECTION_GENERATE_SOURCE(C, PFX, SNAME, FMOD, K, V)
 
-#define COLLECTION_GENERATE_HEADER(C, P, PFX, SNAME, FMOD, K, V) \
-    CONCATH(C, P)                                                \
+#define COLLECTION_GENERATE_HEADER(C, PFX, SNAME, FMOD, K, V) \
+    CONCATH(C)                                                \
     (PFX, SNAME, FMOD, K, V)
 
-#define COLLECTION_GENERATE_SOURCE(C, P, PFX, SNAME, FMOD, K, V) \
-    CONCATC(C, P)                                                \
+#define COLLECTION_GENERATE_SOURCE(C, PFX, SNAME, FMOD, K, V) \
+    CONCATC(C)                                                \
     (PFX, SNAME, FMOD, K, V)
 
 #include "list.h"

src/queue.h

@@ -20,24 +20,14 @@
 #include <string.h>
 
 #define QUEUE_GENERATE(PFX, SNAME, FMOD, V)    \
-    QUEUE_GENERATE_STRUCT(PFX, SNAME, FMOD, V) \
     QUEUE_GENERATE_HEADER(PFX, SNAME, FMOD, V) \
     QUEUE_GENERATE_SOURCE(PFX, SNAME, FMOD, V)
 
-/* PRIVATE *******************************************************************/
-#define QUEUE_GENERATE_HEADER_PRIVATE(PFX, SNAME, FMOD, K, V) \
+#define QUEUE_WRAPGEN_HEADER(PFX, SNAME, FMOD, K, V) \
     QUEUE_GENERATE_HEADER(PFX, SNAME, FMOD, V)
-#define QUEUE_GENERATE_SOURCE_PRIVATE(PFX, SNAME, FMOD, K, V) \
-    QUEUE_GENERATE_STRUCT(PFX, SNAME, FMOD, V)                \
+
+#define QUEUE_WRAPGEN_SOURCE(PFX, SNAME, FMOD, K, V) \
     QUEUE_GENERATE_SOURCE(PFX, SNAME, FMOD, V)
-/* PUBLIC ********************************************************************/
-#define QUEUE_GENERATE_HEADER_PUBLIC(PFX, SNAME, FMOD, K, V) \
-    QUEUE_GENERATE_STRUCT(PFX, SNAME, FMOD, V)               \
-    QUEUE_GENERATE_HEADER(PFX, SNAME, FMOD, V)
-#define QUEUE_GENERATE_SOURCE_PUBLIC(PFX, SNAME, FMOD, K, V) \
-    QUEUE_GENERATE_SOURCE(PFX, SNAME, FMOD, V)
-/* STRUCT ********************************************************************/
-#define QUEUE_GENERATE_STRUCT(PFX, SNAME, FMOD, V)
 
 /* HEADER ********************************************************************/
 #define QUEUE_GENERATE_HEADER(PFX, SNAME, FMOD, V)                                \

src/stack.h

@@ -20,24 +20,14 @@
 #include <string.h>
 
 #define STACK_GENERATE(PFX, SNAME, FMOD, V)    \
-    STACK_GENERATE_STRUCT(PFX, SNAME, FMOD, V) \
     STACK_GENERATE_HEADER(PFX, SNAME, FMOD, V) \
     STACK_GENERATE_SOURCE(PFX, SNAME, FMOD, V)
 
-/* PRIVATE *******************************************************************/
-#define STACK_GENERATE_HEADER_PRIVATE(PFX, SNAME, FMOD, K, V) \
+#define STACK_WRAPGEN_HEADER(PFX, SNAME, FMOD, K, V) \
     STACK_GENERATE_HEADER(PFX, SNAME, FMOD, V)
-#define STACK_GENERATE_SOURCE_PRIVATE(PFX, SNAME, FMOD, K, V) \
-    STACK_GENERATE_STRUCT(PFX, SNAME, FMOD, V)                \
+
+#define STACK_WRAPGEN_SOURCE(PFX, SNAME, FMOD, K, V) \
     STACK_GENERATE_SOURCE(PFX, SNAME, FMOD, V)
-/* PUBLIC ********************************************************************/
-#define STACK_GENERATE_HEADER_PUBLIC(PFX, SNAME, FMOD, K, V) \
-    STACK_GENERATE_STRUCT(PFX, SNAME, FMOD, V)               \
-    STACK_GENERATE_HEADER(PFX, SNAME, FMOD, V)
-#define STACK_GENERATE_SOURCE_PUBLIC(PFX, SNAME, FMOD, K, V) \
-    STACK_GENERATE_SOURCE(PFX, SNAME, FMOD, V)
-/* STRUCT ********************************************************************/
-#define STACK_GENERATE_STRUCT(PFX, SNAME, FMOD, V)
 
 /* HEADER ********************************************************************/
 #define STACK_GENERATE_HEADER(PFX, SNAME, FMOD, V)                                \

src/treemap.h

@@ -19,24 +19,14 @@
 #include <stdbool.h>
 
 #define TREEMAP_GENERATE(PFX, SNAME, FMOD, K, V)    \
-    TREEMAP_GENERATE_STRUCT(PFX, SNAME, FMOD, K, V) \
     TREEMAP_GENERATE_HEADER(PFX, SNAME, FMOD, K, V) \
     TREEMAP_GENERATE_SOURCE(PFX, SNAME, FMOD, K, V)
 
-/* PRIVATE *******************************************************************/
-#define TREEMAP_GENERATE_HEADER_PRIVATE(PFX, SNAME, FMOD, K, V) \
+#define TREEMAP_WRAPGEN_HEADER(PFX, SNAME, FMOD, K, V) \
     TREEMAP_GENERATE_HEADER(PFX, SNAME, FMOD, K, V)
-#define TREEMAP_GENERATE_SOURCE_PRIVATE(PFX, SNAME, FMOD, K, V) \
-    TREEMAP_GENERATE_STRUCT(PFX, SNAME, FMOD, K, V)             \
+
+#define TREEMAP_WRAPGEN_SOURCE(PFX, SNAME, FMOD, K, V) \
     TREEMAP_GENERATE_SOURCE(PFX, SNAME, FMOD, K, V)
-/* PUBLIC ********************************************************************/
-#define TREEMAP_GENERATE_HEADER_PUBLIC(PFX, SNAME, FMOD, K, V) \
-    TREEMAP_GENERATE_STRUCT(PFX, SNAME, FMOD, K, V)            \
-    TREEMAP_GENERATE_HEADER(PFX, SNAME, FMOD, K, V)
-#define TREEMAP_GENERATE_SOURCE_PUBLIC(PFX, SNAME, FMOD, K, V) \
-    TREEMAP_GENERATE_SOURCE(PFX, SNAME, FMOD, K, V)
-/* STRUCT ********************************************************************/
-#define TREEMAP_GENERATE_STRUCT(PFX, SNAME, FMOD, K, V)
 
 /* HEADER ********************************************************************/
 #define TREEMAP_GENERATE_HEADER(PFX, SNAME, FMOD, K, V)                       \

src/treeset.h

@@ -19,24 +19,14 @@
 #include <stdbool.h>
 
 #define TREESET_GENERATE(PFX, SNAME, FMOD, V)    \
-    TREESET_GENERATE_STRUCT(PFX, SNAME, FMOD, V) \
     TREESET_GENERATE_HEADER(PFX, SNAME, FMOD, V) \
     TREESET_GENERATE_SOURCE(PFX, SNAME, FMOD, V)
 
-/* PRIVATE *******************************************************************/
-#define TREESET_GENERATE_HEADER_PRIVATE(PFX, SNAME, FMOD, K, V) \
+#define TREESET_WRAPGEN_HEADER(PFX, SNAME, FMOD, K, V) \
     TREESET_GENERATE_HEADER(PFX, SNAME, FMOD, V)
-#define TREESET_GENERATE_SOURCE_PRIVATE(PFX, SNAME, FMOD, K, V) \
-    TREESET_GENERATE_STRUCT(PFX, SNAME, FMOD, V)                \
+
+#define TREESET_WRAPGEN_SOURCE(PFX, SNAME, FMOD, K, V) \
     TREESET_GENERATE_SOURCE(PFX, SNAME, FMOD, V)
-/* PUBLIC ********************************************************************/
-#define TREESET_GENERATE_HEADER_PUBLIC(PFX, SNAME, FMOD, K, V) \
-    TREESET_GENERATE_STRUCT(PFX, SNAME, FMOD, V)               \
-    TREESET_GENERATE_HEADER(PFX, SNAME, FMOD, V)
-#define TREESET_GENERATE_SOURCE_PUBLIC(PFX, SNAME, FMOD, K, V) \
-    TREESET_GENERATE_SOURCE(PFX, SNAME, FMOD, V)
-/* STRUCT ********************************************************************/
-#define TREESET_GENERATE_STRUCT(PFX, SNAME, FMOD, V)
 
 /* HEADER ********************************************************************/
 #define TREESET_GENERATE_HEADER(PFX, SNAME, FMOD, V)                        \

tests/README.md

@@ -0,0 +1,7 @@
+# Tests
+
+* `sep/main.c`, `sep/sep.c` and `sep/sep.h` - Tests separate header and source compilation;
+* `contains.c` - Tests the `contains` function for all collections;
+* `foreach.c` - Tests the ForEach macros for all collections;
+* `iterators.c` - Tests all collection's iterators;
+* `pointertype.c` - Tests if the source code is compatible with pointer types.

tests/contains.c

@@ -20,16 +20,16 @@ size_t inthash(int t)
     return a;
 }
 
-COLLECTION_GENERATE(LIST, PUBLIC, l, list, /* FMOD */, /* K */, int)
-COLLECTION_GENERATE(STACK, PUBLIC, s, stack, /* FMOD */, /* K */, int)
-COLLECTION_GENERATE(QUEUE, PUBLIC, q, queue, /* FMOD */, /* K */, int)
-COLLECTION_GENERATE(DEQUE, PUBLIC, d, deque, /* FMOD */, /* K */, int)
-COLLECTION_GENERATE(LINKEDLIST, PUBLIC, ll, linked, /* FMOD */, /* K */, int)
-COLLECTION_GENERATE(HEAP, PUBLIC, h, heap, /* FMOD */, /* K */, int)
-COLLECTION_GENERATE(TREESET, PUBLIC, ts, tset, /* FMOD */, /* K */, int)
-COLLECTION_GENERATE(TREEMAP, PUBLIC, tm, tmap, /* FMOD */, int, int)
-COLLECTION_GENERATE(HASHSET, PUBLIC, hs, hset, /* FMOD */, /* K */, int)
-COLLECTION_GENERATE(HASHMAP, PUBLIC, hm, hmap, /* FMOD */, int, int)
+COLLECTION_GENERATE(LIST, l, list, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE(STACK, s, stack, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE(QUEUE, q, queue, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE(DEQUE, d, deque, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE(LINKEDLIST, ll, linked, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE(HEAP, h, heap, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE(TREESET, ts, tset, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE(TREEMAP, tm, tmap, /* FMOD */, int, int)
+COLLECTION_GENERATE(HASHSET, hs, hset, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE(HASHMAP, hm, hmap, /* FMOD */, int, int)
 
 int main(void)
 {

tests/foreach.c

@@ -4,7 +4,7 @@
 
 int intcmp(int a, int b)
 {
-    return a - b;
+    return (a > b) - (a < b);
 }
 
 size_t inthash(int t)
@@ -19,16 +19,16 @@ size_t inthash(int t)
     return a;
 }
 
-COLLECTION_GENERATE(LIST, PUBLIC, l, list, /* FMOD */, /* K */, int)
-COLLECTION_GENERATE(STACK, PUBLIC, s, stack, /* FMOD */, /* K */, int)
-COLLECTION_GENERATE(QUEUE, PUBLIC, q, queue, /* FMOD */, /* K */, int)
-COLLECTION_GENERATE(DEQUE, PUBLIC, d, deque, /* FMOD */, /* K */, int)
-COLLECTION_GENERATE(LINKEDLIST, PUBLIC, ll, linked, /* FMOD */, /* K */, int)
-COLLECTION_GENERATE(HEAP, PUBLIC, h, heap, /* FMOD */, /* K */, int)
-COLLECTION_GENERATE(TREESET, PUBLIC, ts, tset, /* FMOD */, /* K */, int)
-COLLECTION_GENERATE(TREEMAP, PUBLIC, tm, tmap, /* FMOD */, int, int)
-COLLECTION_GENERATE(HASHSET, PUBLIC, hs, hset, /* FMOD */, /* K */, int)
-COLLECTION_GENERATE(HASHMAP, PUBLIC, hm, hmap, /* FMOD */, int, int)
+COLLECTION_GENERATE(LIST, l, list, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE(STACK, s, stack, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE(QUEUE, q, queue, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE(DEQUE, d, deque, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE(LINKEDLIST, ll, linked, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE(HEAP, h, heap, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE(TREESET, ts, tset, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE(TREEMAP, tm, tmap, /* FMOD */, int, int)
+COLLECTION_GENERATE(HASHSET, hs, hset, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE(HASHMAP, hm, hmap, /* FMOD */, int, int)
 
 int main(void)
 {

tests/iterators.c

@@ -4,7 +4,7 @@
 
 int intcmp(int a, int b)
 {
-    return a - b;
+    return (a > b) - (a < b);
 }
 
 size_t inthash(int t)
@@ -19,16 +19,16 @@ size_t inthash(int t)
     return a;
 }
 
-COLLECTION_GENERATE(LIST, PUBLIC, l, list, /* FMOD */, /* K */, int)
-COLLECTION_GENERATE(STACK, PUBLIC, s, stack, /* FMOD */, /* K */, int)
-COLLECTION_GENERATE(QUEUE, PUBLIC, q, queue, /* FMOD */, /* K */, int)
-COLLECTION_GENERATE(DEQUE, PUBLIC, d, deque, /* FMOD */, /* K */, int)
-COLLECTION_GENERATE(LINKEDLIST, PUBLIC, ll, linked, /* FMOD */, /* K */, int)
-COLLECTION_GENERATE(HEAP, PUBLIC, h, heap, /* FMOD */, /* K */, int)
-COLLECTION_GENERATE(TREESET, PUBLIC, ts, tset, /* FMOD */, /* K */, int)
-COLLECTION_GENERATE(TREEMAP, PUBLIC, tm, tmap, /* FMOD */, int, double)
-COLLECTION_GENERATE(HASHSET, PUBLIC, hs, hset, /* FMOD */, /* K */, int)
-COLLECTION_GENERATE(HASHMAP, PUBLIC, hm, hmap, /* FMOD */, int, double)
+COLLECTION_GENERATE(LIST, l, list, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE(STACK, s, stack, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE(QUEUE, q, queue, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE(DEQUE, d, deque, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE(LINKEDLIST, ll, linked, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE(HEAP, h, heap, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE(TREESET, ts, tset, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE(TREEMAP, tm, tmap, /* FMOD */, int, double)
+COLLECTION_GENERATE(HASHSET, hs, hset, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE(HASHMAP, hm, hmap, /* FMOD */, int, double)
 
 #define ITERATOR_TEST(NAME, PFX, sname, initfunc, insertbody, sumbody, validation1, validation2) \
     void NAME##_iterator_test(void)                                                              \

tests/pointertype.c

@@ -8,16 +8,16 @@ typedef struct my_struct_s
     int a, b;
 } my_struct;
 
-COLLECTION_GENERATE(LIST, PUBLIC, l, list, /* FMOD */, /* K */, my_struct *)
-COLLECTION_GENERATE(STACK, PUBLIC, s, stack, /* FMOD */, /* K */, my_struct *)
-COLLECTION_GENERATE(QUEUE, PUBLIC, q, queue, /* FMOD */, /* K */, my_struct *)
-COLLECTION_GENERATE(DEQUE, PUBLIC, d, deque, /* FMOD */, /* K */, my_struct *)
-COLLECTION_GENERATE(LINKEDLIST, PUBLIC, ll, linked, /* FMOD */, /* K */, my_struct *)
-COLLECTION_GENERATE(HEAP, PUBLIC, h, heap, /* FMOD */, /* K */, my_struct *)
-COLLECTION_GENERATE(TREESET, PUBLIC, ts, tset, /* FMOD */, /* K */, my_struct *)
-COLLECTION_GENERATE(TREEMAP, PUBLIC, tm, tmap, /* FMOD */, my_struct *, my_struct *)
-COLLECTION_GENERATE(HASHSET, PUBLIC, hs, hset, /* FMOD */, /* K */, my_struct *)
-COLLECTION_GENERATE(HASHMAP, PUBLIC, hm, hmap, /* FMOD */, my_struct *, my_struct *)
+COLLECTION_GENERATE(LIST, l, list, /* FMOD */, /* K */, my_struct *)
+COLLECTION_GENERATE(STACK, s, stack, /* FMOD */, /* K */, my_struct *)
+COLLECTION_GENERATE(QUEUE, q, queue, /* FMOD */, /* K */, my_struct *)
+COLLECTION_GENERATE(DEQUE, d, deque, /* FMOD */, /* K */, my_struct *)
+COLLECTION_GENERATE(LINKEDLIST, ll, linked, /* FMOD */, /* K */, my_struct *)
+COLLECTION_GENERATE(HEAP, h, heap, /* FMOD */, /* K */, my_struct *)
+COLLECTION_GENERATE(TREESET, ts, tset, /* FMOD */, /* K */, my_struct *)
+COLLECTION_GENERATE(TREEMAP, tm, tmap, /* FMOD */, my_struct *, my_struct *)
+COLLECTION_GENERATE(HASHSET, hs, hset, /* FMOD */, /* K */, my_struct *)
+COLLECTION_GENERATE(HASHMAP, hm, hmap, /* FMOD */, my_struct *, my_struct *)
 
 int main(void)
 {

tests/sep/main.c

@@ -0,0 +1,50 @@
+#include "sep.h"
+#include <stdio.h>
+
+int intcmp(int a, int b)
+{
+    return (a > b) - (a < b);
+}
+
+size_t inthash(int t)
+{
+    size_t a = t;
+    a += ~(a << 15);
+    a ^= (a >> 10);
+    a += (a << 3);
+    a ^= (a >> 6);
+    a += ~(a << 11);
+    a ^= (a >> 16);
+    return a;
+}
+
+int main(void)
+{
+    list *l = l_new(1000);
+    stack *s = s_new(1000);
+    queue *q = q_new(1000);
+    deque *d = d_new(1000);
+    linked *ll = ll_new();
+    heap *h = h_new(1000, MaxHeap, intcmp);
+    tset *ts = ts_new(intcmp);
+    tmap *tm = tm_new(intcmp);
+    hset *hs = hs_new(1000, 0.9, intcmp, inthash);
+    hmap *hm = hm_new(1000, 0.9, intcmp, inthash);
+
+    printf("+--------------------------------------------------+\n");
+    printf("|       Separate Header and Source is Working      |\n");
+    printf("+--------------------------------------------------+\n");
+
+    l_free(l);
+    ll_free(ll);
+    s_free(s);
+    q_free(q);
+    d_free(d);
+    h_free(h);
+    ts_free(ts);
+    tm_free(tm);
+    hs_free(hs);
+    hm_free(hm);
+
+    return 0;
+}

tests/sep/sep.c

@@ -0,0 +1,12 @@
+#include "sep.h"
+
+COLLECTION_GENERATE_SOURCE(LIST, l, list, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE_SOURCE(STACK, s, stack, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE_SOURCE(QUEUE, q, queue, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE_SOURCE(DEQUE, d, deque, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE_SOURCE(LINKEDLIST, ll, linked, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE_SOURCE(HEAP, h, heap, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE_SOURCE(TREESET, ts, tset, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE_SOURCE(TREEMAP, tm, tmap, /* FMOD */, int, int)
+COLLECTION_GENERATE_SOURCE(HASHSET, hs, hset, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE_SOURCE(HASHMAP, hm, hmap, /* FMOD */, int, int)

tests/sep/sep.h

@@ -0,0 +1,12 @@
+#include "../../src/macro_collections.h"
+
+COLLECTION_GENERATE_HEADER(LIST, l, list, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE_HEADER(STACK, s, stack, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE_HEADER(QUEUE, q, queue, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE_HEADER(DEQUE, d, deque, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE_HEADER(LINKEDLIST, ll, linked, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE_HEADER(HEAP, h, heap, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE_HEADER(TREESET, ts, tset, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE_HEADER(TREEMAP, tm, tmap, /* FMOD */, int, int)
+COLLECTION_GENERATE_HEADER(HASHSET, hs, hset, /* FMOD */, /* K */, int)
+COLLECTION_GENERATE_HEADER(HASHMAP, hm, hmap, /* FMOD */, int, int)