Almost internal: Swapped toRaw(), fromRaw() template arguments in containers.

9 files changed, 53 insertions, 52 deletions

diff --git a/docs/cdeq_api.md b/docs/cdeq_api.md
index eebdd155..6ff3bb64 100644
--- a/docs/cdeq_api.md
+++ b/docs/cdeq_api.md
@@ -10,8 +10,8 @@ See [std::deque](https://en.cppreference.com/w/cpp/container/deque) for correspo
 #define using_cdeq(X, Value, valueCompareRaw=c_default_compare,
                              valueDestroy=c_default_del,
                              RawValue=Value,
-                             valueToRaw=c_default_to_raw,
-                             valueFromRaw=c_default_from_raw)
+                             valueFromRaw=c_default_from_raw,
+                             valueToRaw=c_default_to_raw)
 #define using_cdeq_str()
 ```
 The macro `using_cdeq()` can be instantiated with 2, 3, 4, or 7 arguments in the global scope.
@@ -21,7 +21,7 @@ be replaced by `my` in all of the following documentation.
 
 `using_cdeq_str()` is a shorthand for:
 ```
-using_cdeq(str, cstr_t, cstr_compare_raw, cstr_del, const char*, cstr_to_raw, cstr_from)
+using_cdeq(str, cstr_t, cstr_compare_raw, cstr_del, const char*, cstr_from, cstr_to_raw)
 ```
 
 ## Types
diff --git a/docs/clist_api.md b/docs/clist_api.md
index b49e164c..7fe15c09 100644
--- a/docs/clist_api.md
+++ b/docs/clist_api.md
@@ -12,8 +12,8 @@ is only one pointer, and length of the list is not stored. The method *clist_X_s
 #define using_clist(X, Value, valueCompareRaw=c_default_compare,
                               valueDestroy=c_default_del,
                               RawValue=Value,
-                              valueToRaw=c_default_to_raw,
-                              valueFromRaw=c_default_from_raw)
+                              valueFromRaw=c_default_from_raw,
+                              valueToRaw=c_default_to_raw)
 #define using_clist_str()
 ```
 The macro `using_clist()` can be instantiated with 2, 3, 4, or 7 arguments in the global scope.
@@ -21,7 +21,7 @@ Default values are given above for args not specified. `X` is a type tag name an
 will affect the names of all clist types and methods. E.g. declaring `using_clist(my, int);`, `X` should
 be replaced by `my` in all of the following documentation. `using_clist_str()` is a shorthand for
 ```c
-using_clist(str, cstr_t, cstr_compare_raw, cstr_del, const char*, cstr_to_raw, cstr_from)
+using_clist(str, cstr_t, cstr_compare_raw, cstr_del, const char*, cstr_from, cstr_to_raw)
 ```
 
 ## Types
diff --git a/docs/cmap_api.md b/docs/cmap_api.md
index 74ad7e55..69c975af 100644
--- a/docs/cmap_api.md
+++ b/docs/cmap_api.md
@@ -13,8 +13,8 @@ See [std::unordered_map](https://en.cppreference.com/w/cpp/container/unordered_m
                                    keyHashRaw=c_default_hash,
                                    keyDestroy=c_default_del,
                                    RawKey=Key,
-                                   keyToRaw=c_default_to_raw,
                                    keyFromRaw=c_default_from_raw,
+                                   keyToRaw=c_default_to_raw,
                                    RawMapped=Mapped,
                                    mappedFromRaw=c_default_from_raw)
 
@@ -24,8 +24,8 @@ See [std::unordered_map](https://en.cppreference.com/w/cpp/container/unordered_m
                                   keyHash=c_default_hash,
                                   keyDestroy=c_default_del,
                                   RawKey=Key,
-                                  keyToRaw=c_default_to_raw,
-                                  keyFromRaw=c_default_from_raw)
+                                  keyFromRaw=c_default_from_raw,
+                                  keyToRaw=c_default_to_raw)
 #define using_cmap_str()
 ```
 The macro `using_cmap()` can be instantiated with 3, 4, 6, 10, or 12 arguments in the global scope.
@@ -39,7 +39,7 @@ be replaced by `my` in all of the following documentation.
 `using_cmap()`. The macro `using_cmap_str()` is a shorthand for
 ```c
 using_cmap(str, cstr_t, cstr_t, cstr_del, cstr_equals_raw, cstr_hash_raw,
-           cstr_del, const char*, cstr_to_raw, cstr_from, const char*, cstr_from)
+           cstr_del, const char*, cstr_from, cstr_to_raw, const char*, cstr_from)
 ```
 
 ## Types
diff --git a/docs/cvec_api.md b/docs/cvec_api.md
index d3b1aff7..435c2a3d 100644
--- a/docs/cvec_api.md
+++ b/docs/cvec_api.md
@@ -10,8 +10,8 @@ See [std::vector](https://en.cppreference.com/w/cpp/container/vector) for a simi
 #define using_cvec(X, Value, valueCompareRaw=c_default_compare,
                              valueDestroy=c_default_del,
                              RawValue=Value,
-                             valueToRaw=c_default_to_raw,
-                             valueFromRaw=c_default_from_raw)
+                             valueFromRaw=c_default_from_raw,
+                             valueToRaw=c_default_to_raw)
 #define using_cvec_str()
 ```
 The macro `using_cvec()` can be instantiated with 2, 3, 4, or 7 arguments in the global scope.
@@ -21,7 +21,7 @@ be replaced by `my` in all of the following documentation.
 
 `using_cvec_str()` is a shorthand for:
 ```
-using_cvec(str, cstr_t, cstr_compare_raw, cstr_del, const char*, cstr_to_raw, cstr_from)
+using_cvec(str, cstr_t, cstr_compare_raw, cstr_del, const char*, cstr_from, cstr_to_raw)
 ```
 
 ## Types
diff --git a/examples/advanced.c b/examples/advanced.c
index 931efb57..a79caaee 100644
--- a/examples/advanced.c
+++ b/examples/advanced.c
@@ -51,7 +51,7 @@ Viking viking_fromVw(VikingVw vw) {
 
 // Using the full using_cmap() macro to define [Viking -> int] hash map type:
 using_cmap(vk, Viking, int, c_default_del, vikingvw_equals, vikingvw_hash,
-                 viking_del, VikingVw, viking_toVw, viking_fromVw);
+               viking_del, VikingVw, viking_fromVw, viking_toVw);
 
 // cmap_vk uses vikingvw_hash() for hash value calculations, and vikingvw_equals() for equality test.
 // cmap_vk_del() will free all memory allocated for Viking keys and the hash table values.
diff --git a/stc/cdeq.h b/stc/cdeq.h
index 4fb4281b..977456d7 100644
--- a/stc/cdeq.h
+++ b/stc/cdeq.h
@@ -35,9 +35,9 @@
 #define using_cdeq_3(X, Value, valueCompare) \

                     using_cdeq_4(X, Value, valueCompare, c_default_del)

 #define using_cdeq_4(X, Value, valueCompare, valueDestroy) \

-                    using_cdeq_7(X, Value, valueCompare, valueDestroy, Value, c_default_to_raw, c_default_from_raw)

+                    using_cdeq_7(X, Value, valueCompare, valueDestroy, Value, c_default_from_raw, c_default_to_raw)

 #define using_cdeq_str() \

-                    using_cdeq_7(str, cstr_t, cstr_compare_raw, cstr_del, const char*, cstr_to_raw, cstr_from)

+                    using_cdeq_7(str, cstr_t, cstr_compare_raw, cstr_del, const char*, cstr_from, cstr_to_raw)

 

 #define typedefs_cdeq(X, Value, RawValue) \

     typedef Value cdeq_##X##_value_t; \

@@ -48,7 +48,7 @@
         cdeq_##X##_value_t *base, *data; \

     } cdeq_##X

 

-#define using_cdeq_7(X, Value, valueCompareRaw, valueDestroy, RawValue, valueToRaw, valueFromRaw) \

+#define using_cdeq_7(X, Value, valueCompareRaw, valueDestroy, RawValue, valueFromRaw, valueToRaw) \

     typedefs_cdeq(X, Value, RawValue); \

 \

     STC_INLINE cdeq_##X \

@@ -199,13 +199,13 @@
     STC_INLINE size_t \

     cdeq_##X##_index(cdeq_##X deq, cdeq_##X##_iter_t it) {return it.ref - deq.data;} \

 \

-    _c_implement_cdeq_7(X, Value, valueCompareRaw, valueDestroy, RawValue, valueToRaw, valueFromRaw) \

+    _c_implement_cdeq_7(X, Value, valueCompareRaw, valueDestroy, RawValue, valueFromRaw, valueToRaw) \

     typedef cdeq_##X cdeq_##X##_t

 

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

 

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

-#define _c_implement_cdeq_7(X, Value, valueCompareRaw, valueDestroy, RawValue, valueToRaw, valueFromRaw) \

+#define _c_implement_cdeq_7(X, Value, valueCompareRaw, valueDestroy, RawValue, valueFromRaw, valueToRaw) \

 \

     STC_DEF void \

     cdeq_##X##_push_n(cdeq_##X *self, const cdeq_##X##_input_t arr[], size_t n) { \

@@ -334,7 +334,7 @@
     }

 

 #else

-#define _c_implement_cdeq_7(X, Value, valueCompareRaw, valueDestroy, RawValue, valueToRaw, valueFromRaw)

+#define _c_implement_cdeq_7(X, Value, valueCompareRaw, valueDestroy, RawValue, valueFromRaw, valueToRaw)

 #endif

 

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

diff --git a/stc/clist.h b/stc/clist.h
index 77eac272..a7ac9b0b 100644
--- a/stc/clist.h
+++ b/stc/clist.h
@@ -63,9 +63,9 @@
                              using_clist_4(X, Value, valueCompare, c_default_del)

 #define using_clist_4(X, Value, valueCompare, valueDestroy) \

                              using_clist_7(X, Value, valueCompare, valueDestroy, \

-                                              Value, c_default_to_raw, c_default_from_raw)

+                                              Value, c_default_from_raw, c_default_to_raw)

 #define using_clist_str()    using_clist_7(str, cstr_t, cstr_compare_raw, cstr_del, \

-                                              const char*, cstr_to_raw, cstr_from)

+                                              const char*, cstr_from, cstr_to_raw)

 

 #define using_clist_types(X, Value) \

     typedef Value clist_##X##_value_t; \

@@ -100,7 +100,7 @@ using_clist_types(void, int);
 STC_API size_t _clist_size(const clist_void* self);

 #define _clist_node(X, vp) c_container_of(vp, clist_##X##_node_t, value)

 

-#define using_clist_7(X, Value, valueCompareRaw, valueDestroy, RawValue, valueToRaw, valueFromRaw) \

+#define using_clist_7(X, Value, valueCompareRaw, valueDestroy, RawValue, valueFromRaw, valueToRaw) \

 \

     using_clist_types(X, Value); \

     typedef RawValue clist_##X##_rawvalue_t; \

@@ -206,13 +206,13 @@ STC_API size_t _clist_size(const clist_void* self);
     STC_INLINE Value* \

     clist_##X##_back(clist_##X* self) {return &self->last->value;} \

 \

-    _c_implement_clist_7(X, Value, valueCompareRaw, valueDestroy, RawValue, valueToRaw, valueFromRaw) \

+    _c_implement_clist_7(X, Value, valueCompareRaw, valueDestroy, RawValue, valueFromRaw, valueToRaw) \

     typedef clist_##X clist_##X##_t

 

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

 

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

-#define _c_implement_clist_7(X, Value, valueCompareRaw, valueDestroy, RawValue, valueToRaw, valueFromRaw) \

+#define _c_implement_clist_7(X, Value, valueCompareRaw, valueDestroy, RawValue, valueFromRaw, valueToRaw) \

 \

     STC_DEF clist_##X \

     clist_##X##_clone(clist_##X list) { \

@@ -404,7 +404,7 @@ _clist_mergesort(clist_void_node_t *list, int (*cmp)(const void*, const void*))
 }

 

 #else

-#define _c_implement_clist_7(X, Value, valueCompareRaw, valueDestroy, RawValue, valueToRaw, valueFromRaw)

+#define _c_implement_clist_7(X, Value, valueCompareRaw, valueDestroy, RawValue, valueFromRaw, valueToRaw)

 #endif

 

 #endif

diff --git a/stc/cmap.h b/stc/cmap.h
index f10f5dc1..d6304e0e 100644
--- a/stc/cmap.h
+++ b/stc/cmap.h
@@ -80,17 +80,17 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t;
 

 #define using_cmap_6(X, Key, Mapped, mappedDel, keyEquals, keyHash) \

     using_cmap_10(X, Key, Mapped, mappedDel, keyEquals, keyHash, \

-                     c_default_del, Key, c_default_to_raw, c_default_from_raw)

+                     c_default_del, Key, c_default_from_raw, c_default_to_raw)

 

 #define using_cmap_10(X, Key, Mapped, mappedDel, keyEqualsRaw, keyHashRaw, \

-                        keyDel, RawKey, keyToRaw, keyFromRaw) \

+                        keyDel, RawKey, keyFromRaw, keyToRaw) \

     _c_typedef_CHASH(X, cmap, Key, Mapped, mappedDel, keyEqualsRaw, keyHashRaw, \

-                        keyDel, RawKey, keyToRaw, keyFromRaw, Mapped, c_default_from_raw)

+                        keyDel, RawKey, keyFromRaw, keyToRaw, Mapped, c_default_from_raw)

 

 #define using_cmap_12(X, Key, Mapped, mappedDel, keyEqualsRaw, keyHashRaw, \

-                        keyDel, RawKey, keyToRaw, keyFromRaw, RawMapped, mappedFromRaw) \

+                        keyDel, RawKey, keyFromRaw, keyToRaw, RawMapped, mappedFromRaw) \

     _c_typedef_CHASH(X, cmap, Key, Mapped, mappedDel, keyEqualsRaw, keyHashRaw, \

-                        keyDel, RawKey, keyToRaw, keyFromRaw, RawMapped, mappedFromRaw)

+                        keyDel, RawKey, keyFromRaw, keyToRaw, RawMapped, mappedFromRaw)

 

 /* cset: */

 #define using_cset(...) \

@@ -104,12 +104,12 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t;
 

 #define using_cset_5(X, Key, keyEquals, keyHash, keyDel) \

     using_cset_8(X, Key, keyEquals, keyHash, keyDel, \

-                Key, c_default_to_raw, c_default_from_raw)

+                    Key, c_default_from_raw, c_default_to_raw)

 

 #define using_cset_8(X, Key, keyEqualsRaw, keyHashRaw, keyDel, \

-                    RawKey, keyToRaw, keyFromRaw) \

+                    RawKey, keyFromRaw, keyToRaw) \

     _c_typedef_CHASH(X, cset, Key, Key, void, keyEqualsRaw, keyHashRaw, \

-                        keyDel, RawKey, keyToRaw, keyFromRaw, void, c_default_from_raw)

+                        keyDel, RawKey, keyFromRaw, keyToRaw, void, c_default_from_raw)

 

 /* cset_str, cmap_str, cmap_strkey, cmap_strval: */

 #define using_cset_str() \

@@ -117,7 +117,7 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t;
 

 #define using_cmap_str() \

     _c_typedef_CHASH(str, cmap, cstr_t, cstr_t, cstr_del, cstr_equals_raw, cstr_hash_raw, \

-                          cstr_del, const char*, cstr_to_raw, cstr_from, const char*, cstr_from)

+                          cstr_del, const char*, cstr_from, cstr_to_raw, const char*, cstr_from)

 

 #define using_cmap_strkey(...) \

     c_MACRO_OVERLOAD(using_cmap_strkey, __VA_ARGS__)

@@ -136,16 +136,16 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t;
 

 #define using_cmap_strval_4(X, Key, keyEquals, keyHash) \

     using_cmap_strval_8(X, Key, keyEquals, keyHash, \

-                             c_default_del, Key, c_default_to_raw, c_default_from_raw)

+                           c_default_del, Key, c_default_from_raw, c_default_to_raw)

 

-#define using_cmap_strval_8(X, Key, keyEquals, keyHash, keyDel, RawKey, keyToRaw, keyFromRaw) \

+#define using_cmap_strval_8(X, Key, keyEquals, keyHash, keyDel, RawKey, keyFromRaw, keyToRaw) \

     _c_typedef_CHASH(X, cmap, Key, cstr_t, cstr_del, keyEquals, keyHash, \

-                        keyDel, RawKey, keyToRaw, keyFromRaw, const char*, cstr_from)

+                        keyDel, RawKey, keyFromRaw, keyToRaw, const char*, cstr_from)

 

 

 #define _c_declare_CHASH_strkey(X, ctype, Mapped, mappedDel) \

     _c_typedef_CHASH(X, ctype, cstr_t, Mapped, mappedDel, cstr_equals_raw, cstr_hash_raw, \

-                        cstr_del, const char*, cstr_to_raw, cstr_from, Mapped, c_default_from_raw)

+                        cstr_del, const char*, cstr_from, cstr_to_raw, Mapped, c_default_from_raw)

 

 #define CSET_ONLY_cset(...) __VA_ARGS__

 #define CSET_ONLY_cmap(...)

@@ -156,7 +156,7 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t;
 

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

 #define _c_typedef_CHASH(X, ctype, Key, Mapped, mappedDel, keyEqualsRaw, keyHashRaw, \

-                            keyDel, RawKey, keyToRaw, keyFromRaw, RawMapped, mappedFromRaw) \

+                            keyDel, RawKey, keyFromRaw, keyToRaw, RawMapped, mappedFromRaw) \

     typedef Key ctype##_##X##_key_t; \

     typedef Mapped ctype##_##X##_mapped_t; \

     typedef RawKey ctype##_##X##_rawkey_t; \

@@ -305,14 +305,14 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t;
     STC_API uint32_t c_default_hash32(const void* data, size_t len); \

 \

     _c_implement_CHASH(X, ctype, Key, Mapped, mappedDel, keyEqualsRaw, keyHashRaw, \

-                          keyDel, RawKey, keyToRaw, keyFromRaw, RawMapped, mappedFromRaw) \

+                          keyDel, RawKey, keyFromRaw, keyToRaw, RawMapped, mappedFromRaw) \

     typedef ctype##_##X ctype##_##X##_t

 

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

 

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

 #define _c_implement_CHASH(X, ctype, Key, Mapped, mappedDel, keyEqualsRaw, keyHashRaw, \

-                              keyDel, RawKey, keyToRaw, keyFromRaw, RawMapped, mappedFromRaw) \

+                              keyDel, RawKey, keyFromRaw, keyToRaw, RawMapped, mappedFromRaw) \

     STC_DEF ctype##_##X \

     ctype##_##X##_with_capacity(size_t cap) { \

         ctype##_##X h = ctype##_inits; \

@@ -451,7 +451,7 @@ STC_DEF uint32_t c_default_hash32(const void* data, size_t len) {
 

 #else

 #define _c_implement_CHASH(X, ctype, Key, Mapped, mappedDel, keyEqualsRaw, keyHashRaw, \

-                              keyDel, RawKey, keyToRaw, keyFromRaw, RawMapped, mappedFromRaw)

+                              keyDel, RawKey, keyFromRaw, keyToRaw, RawMapped, mappedFromRaw)

 #endif

 

 #endif

diff --git a/stc/cvec.h b/stc/cvec.h
index 2078470c..9404cc36 100644
--- a/stc/cvec.h
+++ b/stc/cvec.h
@@ -35,9 +35,9 @@
 #define using_cvec_3(X, Value, valueCompare) \

                     using_cvec_4(X, Value, valueCompare, c_default_del)

 #define using_cvec_4(X, Value, valueCompare, valueDestroy) \

-                    using_cvec_7(X, Value, valueCompare, valueDestroy, Value, c_default_to_raw, c_default_from_raw)

+                    using_cvec_7(X, Value, valueCompare, valueDestroy, Value, c_default_from_raw, c_default_to_raw)

 #define using_cvec_str() \

-                    using_cvec_7(str, cstr_t, cstr_compare_raw, cstr_del, const char*, cstr_to_raw, cstr_from)

+                    using_cvec_7(str, cstr_t, cstr_compare_raw, cstr_del, const char*, cstr_from, cstr_to_raw)

 

 #define typedefs_cvec(X, Value, RawValue) \

     typedef Value cvec_##X##_value_t; \

@@ -48,7 +48,7 @@
         cvec_##X##_value_t* data; \

     } cvec_##X

 

-#define using_cvec_7(X, Value, valueCompareRaw, valueDestroy, RawValue, valueToRaw, valueFromRaw) \

+#define using_cvec_7(X, Value, valueCompareRaw, valueDestroy, RawValue, valueFromRaw, valueToRaw) \

     typedefs_cvec(X, Value, RawValue); \

 \

     STC_INLINE cvec_##X \

@@ -188,13 +188,13 @@
     STC_INLINE size_t \

     cvec_##X##_index(cvec_##X vec, cvec_##X##_iter_t it) {return it.ref - vec.data;} \

 \

-    _c_implement_cvec_7(X, Value, valueCompareRaw, valueDestroy, RawValue, valueToRaw, valueFromRaw) \

+    _c_implement_cvec_7(X, Value, valueCompareRaw, valueDestroy, RawValue, valueFromRaw, valueToRaw) \

     typedef cvec_##X cvec_##X##_t

 

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

 

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

-#define _c_implement_cvec_7(X, Value, valueCompareRaw, valueDestroy, RawValue, valueToRaw, valueFromRaw) \

+#define _c_implement_cvec_7(X, Value, valueCompareRaw, valueDestroy, RawValue, valueFromRaw, valueToRaw) \

 \

     STC_DEF void \

     cvec_##X##_push_n(cvec_##X *self, const cvec_##X##_input_t arr[], size_t n) { \

@@ -256,11 +256,12 @@
     STC_DEF cvec_##X##_iter_t \

     cvec_##X##_insert_range_p(cvec_##X* self, cvec_##X##_value_t* pos, const cvec_##X##_value_t* first, const cvec_##X##_value_t* finish) { \

         size_t len = finish - first, idx = pos - self->data, size = cvec_##X##_size(*self); \

+        cvec_##X##_iter_t it = {pos}; \

+        if (len == 0) return it; \

         if (size + len > cvec_##X##_capacity(*self)) \

-            cvec_##X##_reserve(self, 4 + (size + len)*3/2); \

+            cvec_##X##_reserve(self, 4 + (size + len)*3/2), \

+            it.ref = pos = self->data + idx; \

         _cvec_size(self) += len; \

-        pos = self->data + idx; \

-        cvec_##X##_iter_t it = {pos}; \

         memmove(pos + len, pos, (size - idx) * sizeof(Value)); \

         while (first != finish) \

             *pos++ = valueFromRaw(valueToRaw(first++)); \

@@ -300,7 +301,7 @@
     }

 

 #else

-#define _c_implement_cvec_7(X, Value, valueCompareRaw, valueDestroy, RawValue, valueToRaw, valueFromRaw)

+#define _c_implement_cvec_7(X, Value, valueCompareRaw, valueDestroy, RawValue, valueFromRaw, valueToRaw)

 #endif

 

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