Reordered declare_CMap/CSet argument list.

Fixed examples.

11 files changed, 74 insertions, 66 deletions

diff --git a/examples/README.md b/examples/README.md
index e98ae59d..4d43a7d2 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -60,7 +60,7 @@ Viking viking_fromVw(VikingVw vw) {
 ```

 With this in place, we use the full declare_CMap() macro to define {Viking -> int} hash map type:

 ```

-declare_CMap(vk, Viking, int, c_emptyDestroy, vikingvw_hash, vikingvw_equals, 

+declare_CMap(vk, Viking, int, c_defaultDestroy, vikingvw_equals, vikingvw_hash, 

                  viking_destroy, VikingVw, viking_getVw, viking_fromVw);

 ```

 CMap_vk uses vikingvw_hash() for hash value calculations, and vikingvw_equals() for equality test. cmap_vk_destroy() will free all memory allocated for Viking keys and the hash table values.

diff --git a/examples/advanced.c b/examples/advanced.c
index bd06c95d..5d0bd2ed 100644
--- a/examples/advanced.c
+++ b/examples/advanced.c
@@ -53,7 +53,7 @@ Viking viking_fromVw(VikingVw vw) {
 
 
 // Using the full declare_CMap() macro to define [Viking -> int] hash map type:
-declare_CMap(vk, Viking, int, c_emptyDestroy, vikingvw_hash, vikingvw_equals, 
+declare_CMap(vk, Viking, int, c_defaultDestroy, vikingvw_equals, vikingvw_hash, 
                  viking_destroy, VikingVw, viking_getVw, viking_fromVw);
 
 // CMap_vk uses vikingvw_hash() for hash value calculations, and vikingvw_equals() for equality test.
diff --git a/examples/benchmark.c b/examples/benchmark.c
index cadb220c..87242ec8 100644
--- a/examples/benchmark.c
+++ b/examples/benchmark.c
@@ -19,7 +19,7 @@ static inline uint32_t fibonacci_hash(const void* data, size_t len) {
     const uint64_t key = *(const uint64_t *) data;

     return (uint32_t) (key * 11400714819323198485llu);

 }

-declare_CMap(ii, int64_t, int64_t, c_emptyDestroy, fibonacci_hash);

+declare_CMap(ii, int64_t, int64_t, c_defaultDestroy, c_defaultEquals, fibonacci_hash);

 

 KHASH_MAP_INIT_INT64(ii, uint64_t)

 

diff --git a/examples/geek2.c b/examples/geek2.c
index 38916243..32c0d03b 100644
--- a/examples/geek2.c
+++ b/examples/geek2.c
@@ -4,18 +4,18 @@
 #include <stc/cstr.h>

 

 declare_CMap_str(ss, CStr, cstr_destroy);

-declare_CSet_str(ss);

+declare_CSet_str();

 

 int main() 

 { 

     // Lets use an explicit type signature (which would

     // be `CMap<String, String>` in this example).

     CMap_ss book_reviews = cmap_init; 

-    CSet_ss set = cset_init;

-    cset_ss_put(&set, "Hello");

-    cset_ss_put(&set, "You");

-    cset_ss_put(&set, "Tube");

-    c_foreach (i, cset_ss, set)

+    CSet_str set = cset_init;

+    cset_str_put(&set, "Hello");

+    cset_str_put(&set, "You");

+    cset_str_put(&set, "Tube");

+    c_foreach (i, cset_str, set)

         printf("%s ", i.item->key.str); puts("");

 

     // Review some books.

diff --git a/examples/geek4.c b/examples/geek4.c
index 243301f9..28c77e9f 100644
--- a/examples/geek4.c
+++ b/examples/geek4.c
@@ -37,13 +37,13 @@ Efficient Approach: For all the words of the first sentence, we can check if it
 #include <stc/cvec.h>

 #include <stc/cstr.h>

 

-declare_CVec_str(s);

+declare_CVec_str();

 declare_CMap_str(sb, bool);

 declare_CVec(sb, CMapEntry_sb, cmapentry_sb_destroy, c_noCompare);

   

 // Function to return the count of common words 

 // in all the sentences 

-int commonWords(CVec_s S) 

+int commonWords(CVec_str S) 

 { 

     int m, n, i, j; 

   

@@ -136,14 +136,14 @@ int commonWords(CVec_s S)
 // Driver code 

 int main() 

 { 

-    CVec_s S = cvec_init; 

-    cvec_s_pushBack(&S, cstr_make("there is a cow")); 

-    cvec_s_pushBack(&S, cstr_make("cow is our mother")); 

-    cvec_s_pushBack(&S, cstr_make("cow gives us milk and milk is sweet")); 

-    cvec_s_pushBack(&S, cstr_make("there is a boy who loves cow")); 

+    CVec_str S = cvec_init; 

+    cvec_str_pushBack(&S, cstr_make("there is a cow")); 

+    cvec_str_pushBack(&S, cstr_make("cow is our mother")); 

+    cvec_str_pushBack(&S, cstr_make("cow gives us milk and milk is sweet")); 

+    cvec_str_pushBack(&S, cstr_make("there is a boy who loves cow")); 

   

     printf("%d\n", commonWords(S)); 

-    cvec_s_destroy(&S);

+    cvec_str_destroy(&S);

     return 0; 

 }

 

diff --git a/examples/heap.c b/examples/heap.c
index f9bc59e3..6fbb346f 100644
--- a/examples/heap.c
+++ b/examples/heap.c
@@ -1,36 +1,36 @@
 #include <stdio.h>

 #include <time.h>

-#include "stc/cvecque.h"

+#include "stc/cvecpq.h"

 #include "stc/crandom.h"

 

 declare_CVec(f, float);

-declare_CVecque(f);

+declare_CVec_priorityQ(f, >);

 

 int main()

 {

-    //float arr[] = {1, 3, 6, 5, 9, 8, -2};

-    float arr[] = {9., 3., 5., 10., 2., 4., 16., 7., 12., 8.};

     uint32_t seed = time(NULL);

     pcg32_random_t pcg = pcg32_seed(seed, 0);

     int N = 30000000, M = 100;

     CVec_f vec = cvec_init;

     clock_t start = clock();

-    for (int i=0; i<N; ++i) cvec_f_pushBack(&vec, pcg32_random(&pcg)); // arr[i]);

-    cvec_f_queueify(&vec);

-    printf("\n\nqueueified: %f\n", (clock() - start) / (float) CLOCKS_PER_SEC);

+    for (int i=0; i<N; ++i)

+        cvec_f_pushBack(&vec, pcg32_random(&pcg));

+    cvec_f_buildPriorityQ(&vec);

+    printf("Built priority queue: %f secs\n", (clock() - start) / (float) CLOCKS_PER_SEC);

 

-    for (int i=0; i<M; ++i) printf("%.0f ", vec.data[i]);

-    puts("\n");

-    for (int i=0; i<M; ++i) printf("%.0f ", cvecque_f_pop(&vec));

+    for (int i=0; i<M; ++i)

+        printf("%.0f ", cvec_f_topPriorityQ(&vec)), cvec_f_popPriorityQ(&vec);

     start = clock();

-    for (int i=M; i<N; ++i) cvecque_f_pop(&vec);

-    printf("\n\npopped: %f\n", (clock() - start) / (float) CLOCKS_PER_SEC);

-    printf("size: %zu\n", cvec_size(vec));

+    for (int i=M; i<N; ++i)

+        cvec_f_popPriorityQ(&vec);

+    printf("\n\npopped PQ: %f secs\n", (clock() - start) / (float) CLOCKS_PER_SEC);

+

     pcg = pcg32_seed(seed, 0);

     start = clock();

-    for (int i=0; i<N; ++i) cvecque_f_push(&vec, pcg32_random(&pcg)); // arr[i]);

-    printf("pushed: %f\n", (clock() - start) / (float) CLOCKS_PER_SEC);

-    for (int i=0; i<M; ++i) printf("%.0f ", vec.data[i]);

-    puts("\n");

-    for (int i=0; i<M; ++i) printf("%.0f ", cvecque_f_pop(&vec));

+    for (int i=0; i<N; ++i)

+        cvec_f_pushPriorityQ(&vec, pcg32_random(&pcg));

+    printf("pushed PQ: %f secs\n", (clock() - start) / (float) CLOCKS_PER_SEC);

+    for (int i=0; i<M; ++i)

+        printf("%.0f ", cvec_f_topPriorityQ(&vec)), cvec_f_popPriorityQ(&vec);

+    puts("");

 }

diff --git a/stc/carray.h b/stc/carray.h
index 63a970b7..4b5ab171 100644
--- a/stc/carray.h
+++ b/stc/carray.h
@@ -75,7 +75,7 @@ static inline size_t _carray3_size(const size_t* zdim) {
 #define declare_CArray(...) c_MACRO_OVERLOAD(declare_CArray, __VA_ARGS__)

 

 #define declare_CArray_2(tag, Value) \

-    declare_CArray_3(tag, Value, c_emptyDestroy)

+    declare_CArray_3(tag, Value, c_defaultDestroy)

 

 

 #define declare_CArray_3(tag, Value, valueDestroy) \

diff --git a/stc/cdefs.h b/stc/cdefs.h
index 0b4d7550..88c160a4 100644
--- a/stc/cdefs.h
+++ b/stc/cdefs.h
@@ -64,11 +64,11 @@
 

 #define c_defaultInitRaw(x)    (x)

 #define c_defaultGetRaw(ptr)   (*(ptr))

-#define c_defaultCompare(x, y) (*(x) == *(y) ? 0 : *(x) < *(y) ? -1 : 1)

+#define c_defaultCompare(x, y) (*(x) < *(y) ? -1 : *(y) < *(x))

 #define c_noCompare(x, y)      (0)

 #define c_defaultEquals(x, y)  (*(x) == *(y))

 #define c_memEquals(x, y)      (memcmp(x, y, sizeof(*(y))) == 0)

-#define c_emptyDestroy(p)      ((void)0)

+#define c_defaultDestroy(p)    ((void)0)

 

 #define c_foreach(it, prefix, container) \

             for (prefix##_iter_t it = prefix##_begin(&container); it.item; it = prefix##_next(it))

diff --git a/stc/clist.h b/stc/clist.h
index ee7960c1..56845d5d 100644
--- a/stc/clist.h
+++ b/stc/clist.h
@@ -59,7 +59,7 @@
 #define declare_CList(...)    c_MACRO_OVERLOAD(declare_CList, __VA_ARGS__)

 

 #define declare_CList_2(tag, Value) \

-                               declare_CList_3(tag, Value, c_emptyDestroy)

+                               declare_CList_3(tag, Value, c_defaultDestroy)

 #define declare_CList_3(tag, Value, valueDestroy) \

                                declare_CList_4(tag, Value, valueDestroy, c_defaultCompare)

 #define declare_CList_4(tag, Value, valueDestroy, valueCompare) \

diff --git a/stc/cmap.h b/stc/cmap.h
index 38f4a640..05fbf547 100644
--- a/stc/cmap.h
+++ b/stc/cmap.h
@@ -69,21 +69,21 @@ enum {chash_HASH = 0x7f, chash_USED = 0x80};
     c_MACRO_OVERLOAD(declare_CMap, __VA_ARGS__)

 

 #define declare_CMap_3(tag, Key, Value) \

-    declare_CMap_4(tag, Key, Value, c_emptyDestroy)

+    declare_CMap_4(tag, Key, Value, c_defaultDestroy)

 

 #define declare_CMap_4(tag, Key, Value, valueDestroy) \

-    declare_CMap_5(tag, Key, Value, valueDestroy, c_defaultHash)

+    declare_CMap_5(tag, Key, Value, valueDestroy, c_defaultEquals)

 

-#define declare_CMap_5(tag, Key, Value, valueDestroy, keyHash) \

-    declare_CMap_6(tag, Key, Value, valueDestroy, keyHash, c_defaultEquals)

+#define declare_CMap_5(tag, Key, Value, valueDestroy, keyEquals) \

+    declare_CMap_6(tag, Key, Value, valueDestroy, keyEquals, c_defaultHash)

 

-#define declare_CMap_6(tag, Key, Value, valueDestroy, keyHash, keyEquals) \

-    declare_CMap_10(tag, Key, Value, valueDestroy, keyHash, keyEquals, \

-                         c_emptyDestroy, Key, c_defaultGetRaw, c_defaultInitRaw)

+#define declare_CMap_6(tag, Key, Value, valueDestroy, keyEquals, keyHash) \

+    declare_CMap_10(tag, Key, Value, valueDestroy, keyEquals, keyHash, \

+                         c_defaultDestroy, Key, c_defaultGetRaw, c_defaultInitRaw)

 

-#define declare_CMap_10(tag, Key, Value, valueDestroy, keyHashRaw, keyEqualsRaw, \

+#define declare_CMap_10(tag, Key, Value, valueDestroy, keyEqualsRaw, keyHashRaw, \

                              keyDestroy, RawKey, keyGetRaw, keyInitRaw) \

-	declare_CHASH(tag, CMap, cmap, Key, Value, valueDestroy, keyHashRaw, keyEqualsRaw, \

+	declare_CHASH(tag, CMap, cmap, Key, Value, valueDestroy, keyEqualsRaw, keyHashRaw, \

                        keyDestroy, RawKey, keyGetRaw, keyInitRaw)

 

 /* CSet: */

@@ -91,21 +91,21 @@ enum {chash_HASH = 0x7f, chash_USED = 0x80};
     c_MACRO_OVERLOAD(declare_CSet, __VA_ARGS__)

 

 #define declare_CSet_2(tag, Key) \

-    declare_CSet_3(tag, Key, c_emptyDestroy)

+    declare_CSet_3(tag, Key, c_defaultEquals)

 

-#define declare_CSet_3(tag, Key, keyDestroy) \

-    declare_CSet_4(tag, Key, keyDestroy, c_defaultHash)

+#define declare_CSet_3(tag, Key, keyEquals) \

+    declare_CSet_4(tag, Key, keyEquals, c_defaultHash)

 

-#define declare_CSet_4(tag, Key, keyDestroy, keyHash) \

-    declare_CSet_5(tag, Key, keyDestroy, keyHash, c_defaultEquals)

+#define declare_CSet_4(tag, Key, keyEquals, keyHash) \

+    declare_CSet_5(tag, Key, keyEquals, keyHash, c_defaultDestroy)

 

-#define declare_CSet_5(tag, Key, keyDestroy, keyHash, keyEquals) \

-    declare_CSet_8(tag, Key, keyDestroy, keyHash, keyEquals, \

+#define declare_CSet_5(tag, Key, keyEquals, keyHash, keyDestroy) \

+    declare_CSet_8(tag, Key, keyEquals, keyHash, keyDestroy, \

                         Key, c_defaultGetRaw, c_defaultInitRaw)

 

-#define declare_CSet_8(tag, Key, keyDestroy, keyHashRaw, keyEqualsRaw, \

+#define declare_CSet_8(tag, Key, keyEqualsRaw, keyHashRaw, keyDestroy, \

                             RawKey, keyGetRaw, keyInitRaw) \

-    declare_CHASH(tag, CSet, cset, Key, void, void, keyHashRaw, keyEqualsRaw, \

+    declare_CHASH(tag, CSet, cset, Key, void, void, keyEqualsRaw, keyHashRaw, \

                        keyDestroy, RawKey, keyGetRaw, keyInitRaw)

 

 /* CSet_str, CMap_str: */

@@ -116,22 +116,22 @@ enum {chash_HASH = 0x7f, chash_USED = 0x80};
     c_MACRO_OVERLOAD(declare_CMap_str, __VA_ARGS__)

 

 #define declare_CMap_str_2(tag, Value) \

-    declare_CHASH_STR(tag, CMap, cmap, Value, c_emptyDestroy)

+    declare_CHASH_STR(tag, CMap, cmap, Value, c_defaultDestroy)

 

 #define declare_CMap_str_3(tag, Value, ValueDestroy) \

     declare_CHASH_STR(tag, CMap, cmap, Value, ValueDestroy)

 

 #define declare_CHASH_STR(tag, CType, ctype, Value, valueDestroy) \

-    declare_CHASH(tag, CType, ctype, CStr, Value, valueDestroy, cstr_hashRaw, \

-                       cstr_equalsRaw, cstr_destroy, const char*, cstr_getRaw, cstr_make)

+    declare_CHASH(tag, CType, ctype, CStr, Value, valueDestroy, cstr_equalsRaw, cstr_hashRaw, \

+                       cstr_destroy, const char*, cstr_getRaw, cstr_make)

 

 #define OPT_1_cset(x)

 #define OPT_2_cset(x, y) x

 #define OPT_1_cmap(x) x

 #define OPT_2_cmap(x, y) x, y

 

-/* CHASH full: use 'void' for Value if <CType, ctype> is <CSet, cset> */

-#define declare_CHASH(tag, CType, ctype, Key, Value, valueDestroy, keyHashRaw, keyEqualsRaw, \

+/* CHASH full: use 'void' for Value if ctype is cset */

+#define declare_CHASH(tag, CType, ctype, Key, Value, valueDestroy, keyEqualsRaw, keyHashRaw, \

                            keyDestroy, RawKey, keyGetRaw, keyInitRaw) \

 typedef struct CType##Entry_##tag { \

     Key key; \

@@ -186,7 +186,7 @@ ctype##_##tag##_begin(CType##_##tag* map); \
 STC_API ctype##_##tag##_iter_t \

 ctype##_##tag##_next(ctype##_##tag##_iter_t it); \

  \

-implement_CHASH(tag, CType, ctype, Key, Value, valueDestroy, keyHashRaw, keyEqualsRaw, \

+implement_CHASH(tag, CType, ctype, Key, Value, valueDestroy, keyEqualsRaw, keyHashRaw, \

                      keyDestroy, RawKey, keyGetRaw, keyInitRaw) \

 typedef Key CType##Key_##tag; \

 typedef Value CType##Value_##tag

@@ -194,7 +194,7 @@ typedef Value CType##Value_##tag
 /* -------------------------- IMPLEMENTATION ------------------------- */

 

 #if !defined(STC_HEADER) || defined(STC_IMPLEMENTATION)

-#define implement_CHASH(tag, CType, ctype, Key, Value, valueDestroy, keyHashRaw, keyEqualsRaw, \

+#define implement_CHASH(tag, CType, ctype, Key, Value, valueDestroy, keyEqualsRaw, keyHashRaw, \

                              keyDestroy, RawKey, keyGetRaw, keyInitRaw) \

  \

 STC_API CType##_##tag \

@@ -369,7 +369,7 @@ ctype##_##tag##_next(ctype##_##tag##_iter_t it) { \
 }

 

 #else

-#define implement_CHASH(tag, CType, ctype, Key, Value, valueDestroy, keyHashRaw, keyEqualsRaw, \

+#define implement_CHASH(tag, CType, ctype, Key, Value, valueDestroy, keyEqualsRaw, keyHashRaw, \

                              keyDestroy, RawKey, keyGetRaw, keyInitRaw)

 #endif

 

diff --git a/stc/cvec.h b/stc/cvec.h
index 80ed051d..8974486a 100644
--- a/stc/cvec.h
+++ b/stc/cvec.h
@@ -34,7 +34,7 @@
 

 #define declare_CVec(...)   c_MACRO_OVERLOAD(declare_CVec, __VA_ARGS__)

 #define declare_CVec_2(tag, Value) \

-                            declare_CVec_3(tag, Value, c_emptyDestroy)

+                            declare_CVec_3(tag, Value, c_defaultDestroy)

 #define declare_CVec_3(tag, Value, valueDestroy) \

                             declare_CVec_4(tag, Value, valueDestroy, c_defaultCompare)

 #define declare_CVec_4(tag, Value, valueDestroy, valueCompare) \

@@ -114,6 +114,14 @@ cvec_##tag##_make(size_t size, Value null) { \
     for (size_t i=0; i<size; ++i) vec.data[i] = null; \

     return vec; \

 } \

+STC_API CVec_##tag \

+cvec_##tag##_from(Value array[], int size) { \

+    CVec_##tag vec = cvec_init; \

+    cvec_##tag##_reserve(&vec, size); \

+    _cvec_size(vec) = size; \

+    for (size_t i=0; i<size; ++i) vec.data[i] = array[i]; \

+    return vec; \

+} \

  \

 STC_API void \

 cvec_##tag##_destroy(CVec_##tag* self) { \