Refactored. Added cmap_find and cmap_insert pair of functions. Renamed types.

5 files changed, 117 insertions, 97 deletions

diff --git a/benchmark.c b/benchmark.c
index 81107a19..d304e711 100644
--- a/benchmark.c
+++ b/benchmark.c
@@ -1,9 +1,10 @@
-#include <stdlib.h>

+//#include <stdlib.h>

 #include <stdio.h>

 #include <time.h>

 

 #include "stc/cstring.h"

 #include "stc/cmap.h"

+#include "stc/crandom.h"

 #include "others/khash.h"

 #ifdef __cplusplus

 #include <unordered_map>

@@ -14,13 +15,17 @@
 // Visual Studio: compile with -TP to force C++:  cl -TP -EHsc -O2 benchmark.c

 

 declare_CMap(ii, int64_t, int64_t, c_noDestroy, c_lowbias32Hash);

-declare_CMap(ix, short, short); // sizeof(CMapEntry_ix) = 6 bytes only!

 

 KHASH_MAP_INIT_INT64(ii, uint64_t)

 

 const size_t seed = 123; // time(NULL);

 const double maxLoadFactor = 0.77;

-#define RAND(N) ((rand() << ((N) - 15)) ^ rand()) // N=16-30

+#define SEED(s) sfc64_t rng = sfc64_seed(s)

+#define RAND(N) (sfc64_rand(&rng) & ((1 << N) - 1))

+

+//#define SEED(s) mt19937_t rng = mt19937_seed(s)

+//#define RAND(N) (mt19937_rand(&rng) & ((1 << N) - 1))

+

 

 #define CMAP_SETUP(tag, Key, Value) CMap_##tag map = cmap_init; \

                                     cmap_##tag##_setMaxLoadFactor(&map, maxLoadFactor)

@@ -81,21 +86,22 @@ int rr = RR;
 { \

     M##_SETUP(tag, int64_t, int64_t); \

     uint64_t checksum = 0, erased = 0; \

-    srand(seed); \

+    SEED(seed); \

     clock_t difference, before = clock(); \

     for (size_t i = 0; i < N1; ++i) { \

         checksum += ++ M##_PUT(tag, RAND(rr), i); \

         erased += M##_ERASE(tag, RAND(rr)); \

     } \

     difference = clock() - before; \

-    printf(#M "(" #tag "): sz: %llu, bucks: %llu, time: %.02f, sum: %llu, erase: %llu\n", M##_SIZE(tag), M##_BUCKETS(tag), (float) difference / CLOCKS_PER_SEC, checksum, erased); \

+    printf(#M "(" #tag "): sz: %llu, bucks: %llu, time: %.02f, sum: %llu, erase: %llu\n", \

+           M##_SIZE(tag), M##_BUCKETS(tag), (float) difference / CLOCKS_PER_SEC, checksum, erased); \

     M##_CLEAR(tag); \

 }

 

 #define MAP_TEST2(M, tag) \

 { \

     M##_SETUP(tag, int64_t, int64_t); \

-    srand(seed); \

+    SEED(seed); \

     size_t erased = 0; \

     clock_t difference, before = clock(); \

     for (size_t i = 0; i < N2; ++i) \

@@ -103,7 +109,8 @@ int rr = RR;
     for (size_t i = 0; i < N2; ++i) \

         erased += M##_ERASE(tag, i*17); \

     difference = clock() - before; \

-    printf(#M "(" #tag "): sz: %llu, bucks: %llu, time: %.02f, erase %llu\n", M##_SIZE(tag), M##_BUCKETS(tag), (float) difference / CLOCKS_PER_SEC, erased); \

+    printf(#M "(" #tag "): sz: %llu, bucks: %llu, time: %.02f, erase %llu\n", \

+           M##_SIZE(tag), M##_BUCKETS(tag), (float) difference / CLOCKS_PER_SEC, erased); \

     M##_CLEAR(tag); \

 }

 

diff --git a/demos.c b/demos.c
index c4052eb8..5e7a8dec 100644
--- a/demos.c
+++ b/demos.c
@@ -100,7 +100,7 @@ void mapdemo1()
     cmap_ii_put(&nums, 8, 64);
     cmap_ii_put(&nums, 11, 121);
 
-    printf("%d\n", cmap_ii_get(nums, 8)->value);
+    printf("%d\n", cmap_ii_get(&nums, 8)->value);
     cmap_ii_destroy(&nums);
 }
 
@@ -137,10 +137,10 @@ void mapdemo3()
     cmap_ss_put(&table, "Map", cstring_make("test"));
     cmap_ss_put(&table, "Make", cstring_make("my"));
     cmap_ss_put(&table, "Sunny", cstring_make("day"));
-    printf("remove: Make: %s\n", cmap_ss_get(table, "Make")->value.str);
+    printf("remove: Make: %s\n", cmap_ss_get(&table, "Make")->value.str);
     cmap_ss_erase(&table, "Make");
 
-    printf("size %d\n", cmap_size(table));
+    printf("size %llu\n", cmap_size(table));
     c_foreach (i, cmap_ss, table)
         printf("key: %s\n", i.item->key.str);
     cmap_ss_destroy(&table); // frees key and value CStrings, and hash table (CVector).
diff --git a/stc/clist.h b/stc/clist.h
index 5fdb3b28..eba49d1a 100644
--- a/stc/clist.h
+++ b/stc/clist.h
@@ -85,18 +85,18 @@
                                declare_CList_6(tag, CString, cstring_destroy, const char*, cstring_compareRaw, cstring_getRaw)                            
 
 #define declare_CListTypes(tag, Value) \
-    c_struct (CListNode_##tag) { \
-        CListNode_##tag *next; \
+    typedef struct CListNode_##tag { \
+        struct CListNode_##tag *next; \
         Value value; \
-    }; \
+    } CListNode_##tag; \
  \
-    c_struct (CList_##tag) { \
-        CListNode_##tag* last; \
-    }; \
+    typedef struct CList_##tag { \
+        CListNode_##tag *last; \
+    } CList_##tag; \
  \
-    c_struct (clist_##tag##_iter_t) { \
+    typedef struct { \
         CListNode_##tag *item, **_last; \
-    }
+    } CListIter_##tag, clist_##tag##_iter_t
 
 #define clist_init          {NULL}
 #define clist_front(list)   (list).last->next->value
@@ -104,10 +104,9 @@
 #define clist_empty(list)   ((list).last == NULL)
 
 
-#define declare_CList_6(tag, Value, valueDestroy, ValueRaw, valueCompareRaw, valueGetRaw) \
+#define declare_CList_6(tag, Value, valueDestroy, RawValue, valueCompareRaw, valueGetRaw) \
  \
     declare_CListTypes(tag, Value); \
-    typedef ValueRaw clist_##tag##_raw_t; \
  \
     STC_API void \
     clist_##tag##_destroy(CList_##tag* self); \
@@ -134,13 +133,13 @@
     clist_##tag##_spliceAfter(CList_##tag* self, clist_##tag##_iter_t pos, CList_##tag* other); \
  \
     STC_API clist_##tag##_iter_t \
-    clist_##tag##_findBefore(CList_##tag* self, ValueRaw val); \
+    clist_##tag##_findBefore(CList_##tag* self, RawValue val); \
  \
     STC_API Value* \
-    clist_##tag##_find(CList_##tag* self, ValueRaw val); \
+    clist_##tag##_find(CList_##tag* self, RawValue val); \
  \
     STC_API clist_##tag##_iter_t \
-    clist_##tag##_remove(CList_##tag* self, ValueRaw val); \
+    clist_##tag##_remove(CList_##tag* self, RawValue val); \
  \
     STC_API void \
     clist_##tag##_sort(CList_##tag* self); \
@@ -159,15 +158,15 @@
         clist_##tag##_iter_t it = {self->last, &self->last}; return it; \
     } \
  \
-    implement_CList_6(tag, Value, valueDestroy, ValueRaw, valueCompareRaw, valueGetRaw) \
- \
-    typedef Value clist_##tag##_value_t
+    implement_CList_6(tag, Value, valueDestroy, RawValue, valueCompareRaw, valueGetRaw) \
+    typedef RawValue CListRawValue_##tag; \
+    typedef Value CListValue_##tag
 
     
 /* -------------------------- IMPLEMENTATION ------------------------- */
 
 #if !defined(STC_HEADER) || defined(STC_IMPLEMENTATION)
-#define implement_CList_6(tag, Value, valueDestroy, ValueRaw, valueCompareRaw, valueGetRaw) \
+#define implement_CList_6(tag, Value, valueDestroy, RawValue, valueCompareRaw, valueGetRaw) \
  \
     STC_API void \
     clist_##tag##_destroy(CList_##tag* self) { \
@@ -224,10 +223,10 @@
     } \
  \
     STC_API clist_##tag##_iter_t \
-    clist_##tag##_findBefore(CList_##tag* self, ValueRaw val) { \
+    clist_##tag##_findBefore(CList_##tag* self, RawValue val) { \
         clist_##tag##_iter_t prev = {self->last, &self->last}; \
         c_foreach (i, clist_##tag, *self) { \
-            ValueRaw r = valueGetRaw(&i.item->value); \
+            RawValue r = valueGetRaw(&i.item->value); \
             if (valueCompareRaw(&r, &val) == 0) { \
                 return prev; \
             } \
@@ -237,13 +236,13 @@
     } \
  \
     STC_API Value* \
-    clist_##tag##_find(CList_##tag* self, ValueRaw val) { \
+    clist_##tag##_find(CList_##tag* self, RawValue val) { \
         clist_##tag##_iter_t it = clist_##tag##_findBefore(self, val); \
         return it.item ? &it.item->next->value : NULL; \
     } \
  \
     STC_API clist_##tag##_iter_t \
-    clist_##tag##_remove(CList_##tag* self, ValueRaw val) { \
+    clist_##tag##_remove(CList_##tag* self, RawValue val) { \
         clist_##tag##_iter_t it = clist_##tag##_findBefore(self, val); \
         if (it.item) clist_##tag##_eraseAfter(self, it); \
         return it; \
@@ -251,8 +250,8 @@
  \
     static inline int \
     clist_##tag##_sortCmp(const void* x, const void* y) { \
-        ValueRaw a = valueGetRaw(&((CListNode_##tag *) x)->value); \
-        ValueRaw b = valueGetRaw(&((CListNode_##tag *) y)->value); \
+        RawValue a = valueGetRaw(&((CListNode_##tag *) x)->value); \
+        RawValue b = valueGetRaw(&((CListNode_##tag *) y)->value); \
         return valueCompareRaw(&a, &b); \
     } \
     STC_API void \
@@ -337,7 +336,7 @@ _clist_mergesort(CListNode__base *list, int (*cmp)(const void*, const void*)) {
 }
 
 #else
-#define implement_CList_6(tag, Value, valueDestroy, ValueRaw, valueCompareRaw, valueGetRaw)
+#define implement_CList_6(tag, Value, valueDestroy, RawValue, valueCompareRaw, valueGetRaw)
 #endif
 
 #endif
diff --git a/stc/cmap.h b/stc/cmap.h
index 095b9210..e8a7485b 100644
--- a/stc/cmap.h
+++ b/stc/cmap.h
@@ -86,22 +86,21 @@ enum   {cmapentry_HASH=0x7f, cmapentry_USED=0x80};
 /* CMap full: */

 #define declare_CMap_10(tag, Key, Value, valueDestroy, keyDestroy, RawKey, \

                              keyHashRaw, keyEqualsRaw, keyGetRaw, keyInitRaw) \

-\

-  struct CMapEntry_##tag { \

-      Key key; \

-      Value value; \

-  }; \

- \

-  static inline struct CMapEntry_##tag cmapentry_##tag##_make(Key key, Value value) { \

-      struct CMapEntry_##tag e = {key, value}; return e; \

-  } \

-  static inline void \

-  cmapentry_##tag##_destroy(struct CMapEntry_##tag* e) { \

-      keyDestroy(&e->key); \

-      valueDestroy(&e->value); \

-  } \

-  typedef struct CMapEntry_##tag CMapEntry_##tag; \

-  typedef RawKey cmap_##tag##_rawkey_t; \

+typedef struct CMapEntry_##tag { \

+    Key key; \

+    Value value; \

+} CMapEntry_##tag; \

+ \

+static inline CMapEntry_##tag cmapentry_##tag##_make(Key key, Value value) { \

+    CMapEntry_##tag e = {key, value}; return e; \

+} \

+static inline void \

+cmapentry_##tag##_destroy(CMapEntry_##tag* e) { \

+    keyDestroy(&e->key); \

+    valueDestroy(&e->value); \

+} \

+ \

+typedef RawKey CMapRawKey_##tag; \

  \

 typedef struct CMap_##tag { \

     CMapEntry_##tag* _table; \

@@ -111,10 +110,16 @@ typedef struct CMap_##tag { \
     uint8_t shrinkLimitPercent; \

 } CMap_##tag; \

  \

-typedef struct cmap_##tag##_iter_t { \

+typedef struct { \

     CMapEntry_##tag *item, *_end; \

     uint8_t* _hx; \

-} cmap_##tag##_iter_t; \

+} CMapIter_##tag, cmap_##tag##_iter_t; \

+ \

+typedef struct { \

+    CMapRawKey_##tag rawKey; \

+    size_t index; \

+    uint32_t hashx; \

+} CMapBucket_##tag; \

  \

 STC_API void \

 cmap_##tag##_destroy(CMap_##tag* self); \

@@ -129,19 +134,22 @@ STC_API void \
 cmap_##tag##_setShrinkLimitFactor(CMap_##tag* self, double limit); \

  \

 STC_API CMapEntry_##tag* \

-cmap_##tag##_get(CMap_##tag map, cmap_##tag##_rawkey_t rawKey); \

+cmap_##tag##_get(const CMap_##tag* self, CMapRawKey_##tag rawKey); \

  \

 STC_API CMapEntry_##tag* \

-cmap_##tag##_put(CMap_##tag* self, cmap_##tag##_rawkey_t rawKey, Value value); \

+cmap_##tag##_put(CMap_##tag* self, CMapRawKey_##tag rawKey, Value value); \

  \

 STC_API CMapEntry_##tag* \

-cmap_##tag##_insert(CMap_##tag* self, CMapEntry_##tag entry); \

+cmap_##tag##_find(CMap_##tag* self, CMapRawKey_##tag rawKey, CMapBucket_##tag* b); \

+ \

+STC_API void \

+cmap_##tag##_insert(CMap_##tag* self, CMapBucket_##tag b, Value value); \

  \

 STC_API size_t \

 cmap_##tag##_reserve(CMap_##tag* self, size_t size); \

  \

 STC_API bool \

-cmap_##tag##_erase(CMap_##tag* self, cmap_##tag##_rawkey_t rawKey); \

+cmap_##tag##_erase(CMap_##tag* self, CMapRawKey_##tag rawKey); \

  \

 STC_API cmap_##tag##_iter_t \

 cmap_##tag##_begin(CMap_##tag* map); \

@@ -152,8 +160,8 @@ cmap_##tag##_next(cmap_##tag##_iter_t it); \
 implement_CMap_10(tag, Key, Value, valueDestroy, keyDestroy, RawKey, \

                        keyHashRaw, keyEqualsRaw, keyGetRaw, keyInitRaw) \

  \

-typedef Key cmap_##tag##_key_t; \

-typedef Value cmap_##tag##_value_t

+typedef Key CMapKey_##tag; \

+typedef Value CMapValue_##tag

 

 /* -------------------------- IMPLEMENTATION ------------------------- */

 

@@ -193,15 +201,15 @@ cmap_##tag##_setShrinkLimitFactor(CMap_##tag* self, double limit) { \
 } \

  \

 static inline size_t \

-cmap_##tag##_bucket(CMap_##tag* self, const cmap_##tag##_rawkey_t* rawKeyPtr, uint32_t* hxPtr) { \

-    uint32_t hash = keyHashRaw(rawKeyPtr, sizeof(cmap_##tag##_rawkey_t)); \

+cmap_##tag##_bucket(const CMap_##tag* self, const CMapRawKey_##tag* rawKeyPtr, uint32_t* hxPtr) { \

+    uint32_t hash = keyHashRaw(rawKeyPtr, sizeof(CMapRawKey_##tag)); \

     uint32_t sx, hx = (hash & cmapentry_HASH) | cmapentry_USED; \

     size_t cap = cmap_bucketCount(*self); \

     size_t idx = cmap_reduce(hash, cap); \

     uint8_t* hashx = self->_hashx; \

     while ((sx = hashx[idx])) { \

         if (sx == hx) { \

-            cmap_##tag##_rawkey_t r = keyGetRaw(&self->_table[idx].key); \

+            CMapRawKey_##tag r = keyGetRaw(&self->_table[idx].key); \

             if (keyEqualsRaw(&r, rawKeyPtr)) break; \

         } \

         if (++idx == cap) idx = 0; \

@@ -211,17 +219,21 @@ cmap_##tag##_bucket(CMap_##tag* self, const cmap_##tag##_rawkey_t* rawKeyPtr, ui
 } \

  \

 STC_API CMapEntry_##tag* \

-cmap_##tag##_get(CMap_##tag map, cmap_##tag##_rawkey_t rawKey) { \

-    if (cmap_size(map) == 0) return NULL; \

+cmap_##tag##_get(const CMap_##tag* self, CMapRawKey_##tag rawKey) { \

+    if (cmap_bucketCount(*self) == 0) return NULL; \

     uint32_t hx; \

-    size_t idx = cmap_##tag##_bucket(&map, &rawKey, &hx); \

-    return map._hashx[idx] ? &map._table[idx] : NULL; \

+    size_t idx = cmap_##tag##_bucket(self, &rawKey, &hx); \

+    return self->_hashx[idx] ? &self->_table[idx] : NULL; \

 } \

  \

-STC_API CMapEntry_##tag* \

-cmap_##tag##_put(CMap_##tag* self, cmap_##tag##_rawkey_t rawKey, Value value) { \

+static inline void _cmap_##tag##_reserveExpand(CMap_##tag* self) { \

     if (cmap_size(*self) + 1 >= cmap_bucketCount(*self) * self->maxLoadPercent * 0.01) \

         cmap_##tag##_reserve(self, (size_t) 7 + (1.6 * cmap_bucketCount(*self))); \

+} \

+ \

+STC_API CMapEntry_##tag* \

+cmap_##tag##_put(CMap_##tag* self, CMapRawKey_##tag rawKey, Value value) { \

+    _cmap_##tag##_reserveExpand(self); \

     uint32_t hx; \

     size_t idx = cmap_##tag##_bucket(self, &rawKey, &hx); \

     CMapEntry_##tag* e = &self->_table[idx]; \

@@ -237,22 +249,24 @@ cmap_##tag##_put(CMap_##tag* self, cmap_##tag##_rawkey_t rawKey, Value value) {
 } \

  \

 STC_API CMapEntry_##tag* \

-cmap_##tag##_insert(CMap_##tag* self, CMapEntry_##tag entry) { \

-    if (cmap_size(*self) + 1 >= cmap_bucketCount(*self) * self->maxLoadPercent * 0.01) \

-        cmap_##tag##_reserve(self, (size_t) 7 + (1.6 * cmap_bucketCount(*self))); \

-    uint32_t hx; \

-    cmap_##tag##_rawkey_t r = keyGetRaw(&entry.key); \

-    size_t idx = cmap_##tag##_bucket(self, &r, &hx); \

-    CMapEntry_##tag* e = &self->_table[idx]; \

-    if (self->_hashx[idx]) \

+cmap_##tag##_find(CMap_##tag* self, CMapRawKey_##tag rawKey, CMapBucket_##tag* b) { \

+    _cmap_##tag##_reserveExpand(self); \

+    b->rawKey = rawKey; \

+    b->index = cmap_##tag##_bucket(self, &rawKey, &b->hashx); \

+    return self->_hashx[b->index] ? &self->_table[b->index] : NULL; \

+} \

+ \

+STC_API void \

+cmap_##tag##_insert(CMap_##tag* self, CMapBucket_##tag b, Value value) { \

+    CMapEntry_##tag* e = &self->_table[b.index]; \

+    if (self->_hashx[b.index]) \

         valueDestroy(&e->value); \

     else { \

-        e->key = entry.key; \

-        self->_hashx[idx] = (uint8_t) hx; \

+        e->key = keyInitRaw(b.rawKey); \

+        self->_hashx[b.index] = (uint8_t) b.hashx; \

         ++self->_size; \

     } \

-    e->value = entry.value; \

-    return e; \

+    e->value = value; \

 } \

  \

 static inline void \

@@ -277,7 +291,7 @@ cmap_##tag##_reserve(CMap_##tag* self, size_t size) { \
     uint32_t hx; \

     for (size_t i = 0; i < oldcap; ++i, ++e) \

         if (tmp._hashx[i]) { \

-            cmap_##tag##_rawkey_t r = keyGetRaw(&e->key); \

+            CMapRawKey_##tag r = keyGetRaw(&e->key); \

             size_t idx = cmap_##tag##_bucket(self, &r, &hx); \

             slot[idx] = *e, \

             hashx[idx] = (uint8_t) hx; \

@@ -288,7 +302,7 @@ cmap_##tag##_reserve(CMap_##tag* self, size_t size) { \
 } \

  \

 STC_API bool \

-cmap_##tag##_erase(CMap_##tag* self, cmap_##tag##_rawkey_t rawKey) { \

+cmap_##tag##_erase(CMap_##tag* self, CMapRawKey_##tag rawKey) { \

     if (cmap_size(*self) == 0) \

         return false; \

     size_t cap = cmap_bucketCount(*self); \

@@ -298,7 +312,7 @@ cmap_##tag##_erase(CMap_##tag* self, cmap_##tag##_rawkey_t rawKey) { \
     size_t i = cmap_##tag##_bucket(self, &rawKey, &hx), j = i, k; \

     CMapEntry_##tag* slot = self->_table; \

     uint8_t* hashx = self->_hashx; \

-    cmap_##tag##_rawkey_t r; \

+    CMapRawKey_##tag r; \

     if (! hashx[i]) \

         return false; \

     do { /* deletion from hash table without tombstone */ \

@@ -306,7 +320,7 @@ cmap_##tag##_erase(CMap_##tag* self, cmap_##tag##_rawkey_t rawKey) { \
         if (! hashx[j]) \

             break; \

         r = keyGetRaw(&slot[j].key); \

-        k = cmap_reduce(keyHashRaw(&r, sizeof(cmap_##tag##_rawkey_t)), cap); \

+        k = cmap_reduce(keyHashRaw(&r, sizeof(CMapRawKey_##tag)), cap); \

         if ((j < i) ^ (k <= i) ^ (k > j)) /* is k outside (i, j]? */ \

             slot[i] = slot[j], hashx[i] = hashx[j], i = j; \

     } while (true); \

diff --git a/stc/cvector.h b/stc/cvector.h
index fe9e2d7d..27caca6a 100644
--- a/stc/cvector.h
+++ b/stc/cvector.h
@@ -43,8 +43,8 @@
                                 declare_CVector_6(tag, CString, cstring_destroy, const char*, cstring_compareRaw, cstring_getRaw)

 

 

-#define declare_CVector_6(tag, Value, valueDestroy, ValueRaw, valueCompareRaw, valueGetRaw) \

-typedef ValueRaw cvector_##tag##_rawvalue_t; \

+#define declare_CVector_6(tag, Value, valueDestroy, RawValue, valueCompareRaw, valueGetRaw) \

+ \

 typedef struct CVector_##tag { \

     Value* data; \

 } CVector_##tag; \

@@ -82,7 +82,7 @@ STC_API void \
 cvector_##tag##_sort(CVector_##tag* self); \

  \

 STC_API size_t \

-cvector_##tag##_find(CVector_##tag cv, ValueRaw rawValue); \

+cvector_##tag##_find(CVector_##tag cv, RawValue rawValue); \

  \

 static inline void \

 cvector_##tag##_swap(CVector_##tag* a, CVector_##tag* b) { \

@@ -90,9 +90,9 @@ cvector_##tag##_swap(CVector_##tag* a, CVector_##tag* b) { \
 } \

  \

  \

-typedef struct cvector_##tag##_iter_t { \

+typedef struct { \

     Value *item, *end; \

-} cvector_##tag##_iter_t; \

+} CVectorIter_##tag, cvector_##tag##_iter_t; \

  \

 STC_API cvector_##tag##_iter_t \

 cvector_##tag##_begin(CVector_##tag* vec); \

@@ -103,14 +103,15 @@ cvector_##tag##_next(cvector_##tag##_iter_t it) { \
     return it; \

 } \

  \

-implement_CVector_6(tag, Value, valueDestroy, ValueRaw, valueCompareRaw, valueGetRaw) \

+implement_CVector_6(tag, Value, valueDestroy, RawValue, valueCompareRaw, valueGetRaw) \

  \

-typedef Value cvector_##tag##_value_t

+typedef Value CVectorValue_##tag; \

+typedef RawValue CVectorRawValue_##tag

 

 /* -------------------------- IMPLEMENTATION ------------------------- */

 

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

-#define implement_CVector_6(tag, Value, valueDestroy, ValueRaw, valueCompareRaw, valueGetRaw) \

+#define implement_CVector_6(tag, Value, valueDestroy, RawValue, valueCompareRaw, valueGetRaw) \

  \

 STC_API void \

 cvector_##tag##_destroy(CVector_##tag* self) { \

@@ -169,11 +170,10 @@ cvector_##tag##_erase(CVector_##tag* self, size_t pos, size_t size) { \
 } \

  \

 STC_API size_t \

-cvector_##tag##_find(CVector_##tag cv, ValueRaw rawValue) { \

+cvector_##tag##_find(CVector_##tag cv, RawValue rawValue) { \

     size_t n = cvector_size(cv); \

-    cvector_##tag##_rawvalue_t r; \

     for (size_t i = 0; i < n; ++i) { \

-        ValueRaw r = valueGetRaw(&cv.data[i]); \

+        RawValue r = valueGetRaw(&cv.data[i]); \

         if (valueCompareRaw(&r, &rawValue) == 0) return i; \

     } \

     return (size_t) (-1); /*SIZE_MAX;*/ \

@@ -181,8 +181,8 @@ cvector_##tag##_find(CVector_##tag cv, ValueRaw rawValue) { \
  \

 STC_API int \

 cvector_##tag##_sortCompare(const void* x, const void* y) { \

-    ValueRaw rx = valueGetRaw((const Value *) x); \

-    ValueRaw ry = valueGetRaw((const Value *) y); \

+    RawValue rx = valueGetRaw((const Value *) x); \

+    RawValue ry = valueGetRaw((const Value *) y); \

     return valueCompareRaw(&rx, &ry); \

 } \

 STC_EXTERN_IMPORT void qsort(void *base, size_t nitems, size_t size, int (*compar)(const void *, const void*)); \

@@ -200,7 +200,7 @@ cvector_##tag##_begin(CVector_##tag* vec) { \
     return it; \

 }

 #else

-#define implement_CVector_6(tag, Value, valueDestroy, ValueRaw, valueCompareRaw, valueGetRaw)

+#define implement_CVector_6(tag, Value, valueDestroy, RawValue, valueCompareRaw, valueGetRaw)

 #endif

 

 #if defined(_WIN32) && defined(_DLL)