Reverted c_trivial_*() to c_default_*().

15 files changed, 59 insertions, 55 deletions

diff --git a/benchmarks/others/carray_v1.h b/benchmarks/others/carray_v1.h
index 4b1c71db..65777416 100644
--- a/benchmarks/others/carray_v1.h
+++ b/benchmarks/others/carray_v1.h
@@ -49,7 +49,7 @@ int main()
 #define using_carray2(...) c_MACRO_OVERLOAD(using_carray2, __VA_ARGS__)

 

 #define using_carray2_2(X, Value) \

-    using_carray2_4(X, Value, c_trivial_del, c_trivial_fromraw)

+    using_carray2_4(X, Value, c_default_del, c_default_fromraw)

 

 #define using_carray2_4(X, Value, valueDel, valueClone) \

 \

@@ -120,7 +120,7 @@ int main()
 #define using_carray3(...) c_MACRO_OVERLOAD(using_carray3, __VA_ARGS__)

 

 #define using_carray3_2(X, Value) \

-    using_carray3_4(X, Value, c_trivial_del, c_trivial_fromraw)

+    using_carray3_4(X, Value, c_default_del, c_default_fromraw)

 

 #define using_carray3_4(X, Value, valueDel, valueClone) \

 \

diff --git a/benchmarks/others/clist_v1.h b/benchmarks/others/clist_v1.h
index 80484dba..00e04e9b 100644
--- a/benchmarks/others/clist_v1.h
+++ b/benchmarks/others/clist_v1.h
@@ -60,11 +60,11 @@
 #define using_clist_2(X, Value) \

             using_clist_3(X, Value, c_default_compare)

 #define using_clist_3(X, Value, valueCompare) \

-            using_clist_5(X, Value, valueCompare, c_trivial_del, c_trivial_fromraw)

+            using_clist_5(X, Value, valueCompare, c_default_del, c_default_fromraw)

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

             using_clist_5(X, Value, valueCompare, valueDel, c_no_clone)

 #define using_clist_5(X, Value, valueCompare, valueDel, valueClone) \

-            _c_using_clist(clist_##X, Value, valueCompare, valueDel, valueClone, c_trivial_toraw, Value)

+            _c_using_clist(clist_##X, Value, valueCompare, valueDel, valueClone, c_default_toraw, Value)

 #define using_clist_7(X, Value, valueCompare, valueDel, valueFromRaw, valueToRaw, RawValue) \

             _c_using_clist(clist_##X, Value, valueCompare, valueDel, valueFromRaw, valueToRaw, RawValue)

 

diff --git a/benchmarks/others/csmap_v1.h b/benchmarks/others/csmap_v1.h
index fa86c91c..061b1dfe 100644
--- a/benchmarks/others/csmap_v1.h
+++ b/benchmarks/others/csmap_v1.h
@@ -48,17 +48,17 @@ int main(void) {
 #define using_csmap_3(X, Key, Mapped) \

             using_csmap_4(X, Key, Mapped, c_default_compare)

 #define using_csmap_4(X, Key, Mapped, keyCompare) \

-            using_csmap_6(X, Key, Mapped, keyCompare, c_trivial_del, c_trivial_fromraw)

+            using_csmap_6(X, Key, Mapped, keyCompare, c_default_del, c_default_fromraw)

 #define using_csmap_6(X, Key, Mapped, keyCompare, mappedDel, mappedClone) \

-            using_csmap_8(X, Key, Mapped, keyCompare, mappedDel, mappedClone, c_trivial_del, c_trivial_fromraw)

+            using_csmap_8(X, Key, Mapped, keyCompare, mappedDel, mappedClone, c_default_del, c_default_fromraw)

 #define using_csmap_8(X, Key, Mapped, keyCompare, mappedDel, mappedClone, keyDel, keyClone) \

             using_csmap_10(X, Key, Mapped, keyCompare, mappedDel, mappedClone, \

-                           keyDel, keyClone, c_trivial_toraw, Key)

+                           keyDel, keyClone, c_default_toraw, Key)

 

 #define using_csmap_10(X, Key, Mapped, keyCompareRaw, mappedDel, mappedClone, \

                        keyDel, keyFromRaw, keyToRaw, RawKey) \

             _c_using_aatree(csmap_##X, csmap_, Key, Mapped, keyCompareRaw, mappedDel, keyDel, \

-                            keyFromRaw, keyToRaw, RawKey, mappedClone, c_trivial_toraw, Mapped)

+                            keyFromRaw, keyToRaw, RawKey, mappedClone, c_default_toraw, Mapped)

 

 /* csset: */

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

@@ -66,9 +66,9 @@ int main(void) {
 #define using_csset_2(X, Key) \

             using_csset_3(X, Key, c_default_compare)

 #define using_csset_3(X, Key, keyCompare) \

-            using_csset_5(X, Key, keyCompare, c_trivial_del, c_trivial_fromraw)

+            using_csset_5(X, Key, keyCompare, c_default_del, c_default_fromraw)

 #define using_csset_5(X, Key, keyCompare, keyDel, keyClone) \

-            using_csset_7(X, Key, keyCompare, keyDel, keyClone, c_trivial_toraw, Key)

+            using_csset_7(X, Key, keyCompare, keyDel, keyClone, c_default_toraw, Key)

 #define using_csset_7(X, Key, keyCompareRaw, keyDel, keyFromRaw, keyToRaw, RawKey) \

             _c_using_aatree(csset_##X, csset_, Key, Key, keyCompareRaw, @@, keyDel, \

                             keyFromRaw, keyToRaw, RawKey, @@, @@, void)

@@ -84,12 +84,12 @@ int main(void) {
 #define using_csmap_strkey(...) c_MACRO_OVERLOAD(using_csmap_strkey, __VA_ARGS__)

 

 #define using_csmap_strkey_2(X, Mapped) \

-            _c_using_aatree_strkey(X, csmap_, Mapped, c_trivial_del, c_trivial_fromraw)

+            _c_using_aatree_strkey(X, csmap_, Mapped, c_default_del, c_default_fromraw)

 #define using_csmap_strkey_4(X, Mapped, mappedDel, mappedClone) \

             _c_using_aatree_strkey(X, csmap_, Mapped, mappedDel, mappedClone)

 #define _c_using_aatree_strkey(X, C, Mapped, mappedDel, mappedClone) \

             _c_using_aatree(C##X, C, cstr, Mapped, c_rawstr_compare, mappedDel, cstr_del, \

-                            cstr_from, cstr_toraw, const char*, mappedClone, c_trivial_toraw, Mapped)

+                            cstr_from, cstr_toraw, const char*, mappedClone, c_default_toraw, Mapped)

 

 

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

@@ -97,9 +97,9 @@ int main(void) {
 #define using_csmap_strval_2(X, Key) \

             using_csmap_strval_3(X, Key, c_default_compare)

 #define using_csmap_strval_3(X, Key, keyCompare) \

-            using_csmap_strval_5(X, Key, keyCompare, c_trivial_del, c_trivial_fromraw)

+            using_csmap_strval_5(X, Key, keyCompare, c_default_del, c_default_fromraw)

 #define using_csmap_strval_5(X, Key, keyCompare, keyDel, keyClone) \

-            using_csmap_strval_7(X, Key, keyCompare, keyDel, keyClone, c_trivial_toraw, Key)

+            using_csmap_strval_7(X, Key, keyCompare, keyDel, keyClone, c_default_toraw, Key)

 #define using_csmap_strval_7(X, Key, keyCompare, keyDel, keyFromRaw, keyToRaw, RawKey) \

             _c_using_aatree(csmap_##X, csmap_, Key, cstr, keyCompare, cstr_del, keyDel, \

                             keyFromRaw, keyToRaw, RawKey, cstr_from, cstr_toraw, const char*)

diff --git a/docs/cmap_api.md b/docs/cmap_api.md
index 30a7b84a..37bfe110 100644
--- a/docs/cmap_api.md
+++ b/docs/cmap_api.md
@@ -91,11 +91,11 @@ uint64_t            c_string_hash(const char* str);                       // use
 uint64_t            c_default_hash32(const void* data, size_t);           // key one 32bit int
 uint64_t            c_default_hash64(const void* data, size_t);           // key one 64bit int
 int                 c_default_equals(const RawKey* a, const RawKey* b);   // the == operator
-int                 c_trivial_equals(const RawKey* a, const RawKey* b);   // memcmp
+int                 c_memcmp_equals(const RawKey* a, const RawKey* b);    // uses memcmp
 Type                c_no_clone(Type val);
-Type                c_trivial_fromraw(Type val);                          // plain copy
-Type                c_trivial_toraw(Type* val);
-void                c_trivial_del(Type* val);                             // does nothing
+Type                c_default_fromraw(Type val);                          // plain copy
+Type                c_default_toraw(Type* val);
+void                c_default_del(Type* val);                             // does nothing
 ```
 
 ## Types
@@ -201,7 +201,7 @@ Demonstrate cmap with plain-old-data key type Vec3i and int as mapped type: cmap
 
 typedef struct { int x, y, z; } Vec3i;
 
-using_cmap(vi, Vec3i, int, c_trivial_equals, // bitwise equals
+using_cmap(vi, Vec3i, int, c_memcmp_equals, // bitwise equals
                            c_default_hash);  // bytewise hash
 
 int main()
diff --git a/examples/complex.c b/examples/complex.c
index eea92dbd..13c36d97 100644
--- a/examples/complex.c
+++ b/examples/complex.c
@@ -5,7 +5,7 @@
 

 void check_del(float* v) {printf("destroy %g\n", *v);}

 

-using_carray2(f, float, check_del, c_trivial_fromraw);

+using_carray2(f, float, check_del, c_default_fromraw);

 using_clist(arr, carray2f, c_no_compare, carray2f_del, c_no_clone);

 using_cmap(lst, int, clist_arr, c_default_equals, c_default_hash, clist_arr_del, c_no_clone);

 using_cmap_strkey(map, cmap_lst, cmap_lst_del, c_no_clone);

diff --git a/stc/carray.h b/stc/carray.h
index 3fad0df7..1e0d26c6 100644
--- a/stc/carray.h
+++ b/stc/carray.h
@@ -55,7 +55,7 @@ int main() {
 #define using_carray2(...) c_MACRO_OVERLOAD(using_carray2, __VA_ARGS__)

 

 #define using_carray2_2(X, Value) \

-            _c_using_carray2(carray2##X, Value, c_trivial_del, c_trivial_fromraw)

+            _c_using_carray2(carray2##X, Value, c_default_del, c_default_fromraw)

 #define using_carray2_3(X, Value, valueDel) \

             _c_using_carray2(carray2##X, Value, valueDel, c_no_clone)

 #define using_carray2_4(X, Value, valueDel, valueClone) \

@@ -99,7 +99,7 @@ int main() {
 #define using_carray3(...) c_MACRO_OVERLOAD(using_carray3, __VA_ARGS__)

 

 #define using_carray3_2(X, Value) \

-    _c_using_carray3(carray3##X, Value, c_trivial_del, c_trivial_fromraw)

+    _c_using_carray3(carray3##X, Value, c_default_del, c_default_fromraw)

 #define using_carray3_3(X, Value, valueDel) \

     _c_using_carray3(carray3##X, Value, valueDel, c_no_clone)

 #define using_carray3_4(X, Value, valueDel, valueClone) \

diff --git a/stc/ccommon.h b/stc/ccommon.h
index 268b626d..5b5f7e59 100644
--- a/stc/ccommon.h
+++ b/stc/ccommon.h
@@ -89,13 +89,17 @@
 #define c_less_compare(less, x, y) (less(y, x) - less(x, y))

 

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

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

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

+

+#define c_rawstr_compare(x, y)  strcmp(*(x), *(y))

+#define c_rawstr_equals(x, y)   (strcmp(*(x), *(y)) == 0)

+#define c_rawstr_hash(p, none)  c_default_hash(*(p), strlen(*(p)))

 

 #define c_no_clone(x)           (assert(!"c_no_clone() called"), x)

-#define c_trivial_fromraw(x)    (x)

-#define c_trivial_toraw(ptr)    (*(ptr))

+#define c_default_fromraw(x)    (x)

+#define c_default_toraw(ptr)    (*(ptr))

 

-#define c_trivial_del(ptr)      ((void) (ptr))

+#define c_default_del(ptr)      ((void) (ptr))

 

 /* Generic algorithms */

 

diff --git a/stc/cdeq.h b/stc/cdeq.h
index dd751fc7..d59af7d9 100644
--- a/stc/cdeq.h
+++ b/stc/cdeq.h
@@ -32,11 +32,11 @@
 #define using_cdeq_2(X, Value) \

             using_cdeq_3(X, Value, c_default_compare)

 #define using_cdeq_3(X, Value, valueCompare) \

-            using_cdeq_5(X, Value, valueCompare, c_trivial_del, c_trivial_fromraw)

+            using_cdeq_5(X, Value, valueCompare, c_default_del, c_default_fromraw)

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

             using_cdeq_5(X, Value, valueCompare, valueDel, c_no_clone)

 #define using_cdeq_5(X, Value, valueCompare, valueDel, valueClone) \

-            using_cdeq_7(X, Value, valueCompare, valueDel, valueClone, c_trivial_toraw, Value)

+            using_cdeq_7(X, Value, valueCompare, valueDel, valueClone, c_default_toraw, Value)

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

             _c_using_cdeq(cdeq_##X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue)

 

diff --git a/stc/clist.h b/stc/clist.h
index a1b01125..ebdc7497 100644
--- a/stc/clist.h
+++ b/stc/clist.h
@@ -60,11 +60,11 @@
 #define using_clist_2(X, Value) \

             using_clist_3(X, Value, c_default_compare)

 #define using_clist_3(X, Value, valueCompare) \

-            using_clist_5(X, Value, valueCompare, c_trivial_del, c_trivial_fromraw)

+            using_clist_5(X, Value, valueCompare, c_default_del, c_default_fromraw)

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

             using_clist_5(X, Value, valueCompare, valueDel, c_no_clone)

 #define using_clist_5(X, Value, valueCompare, valueDel, valueClone) \

-            _c_using_clist(clist_##X, Value, valueCompare, valueDel, valueClone, c_trivial_toraw, Value)

+            _c_using_clist(clist_##X, Value, valueCompare, valueDel, valueClone, c_default_toraw, Value)

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

             _c_using_clist(clist_##X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue)

 

diff --git a/stc/cmap.h b/stc/cmap.h
index 00034099..1258bb12 100644
--- a/stc/cmap.h
+++ b/stc/cmap.h
@@ -56,18 +56,18 @@ int main(void) {
             using_cmap_5(X, Key, Mapped, c_default_equals, c_default_hash)

 #define using_cmap_5(X, Key, Mapped, keyEquals, keyHash) \

             using_cmap_7(X, Key, Mapped, keyEquals, keyHash, \

-                         c_trivial_del, c_trivial_fromraw)

+                         c_default_del, c_default_fromraw)

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

             using_cmap_7(X, Key, Mapped, keyEquals, keyHash, \

                          mappedDel, c_no_clone)

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

             using_cmap_9(X, Key, Mapped, keyEquals, keyHash, \

-                         mappedDel, mappedClone, c_trivial_toraw, Mapped)

+                         mappedDel, mappedClone, c_default_toraw, Mapped)

 #define using_cmap_9(X, Key, Mapped, keyEquals, keyHash, \

                      mappedDel, mappedFromRaw, mappedToRaw, RawMapped) \

             using_cmap_13(X, Key, Mapped, keyEquals, keyHash, \

                           mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \

-                          c_trivial_del, c_trivial_fromraw, c_trivial_toraw, Key)

+                          c_default_del, c_default_fromraw, c_default_toraw, Key)

 

 #define using_cmap_13(X, Key, Mapped, keyEqualsRaw, keyHashRaw, \

                       mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \

@@ -81,12 +81,12 @@ int main(void) {
 

 #define using_cmap_keydef_7(X, Key, Mapped, keyEquals, keyHash, keyDel, keyClone) \

             using_cmap_keydef_9(X, Key, Mapped, keyEquals, keyHash, \

-                                keyDel, keyClone, c_trivial_toraw, Key)

+                                keyDel, keyClone, c_default_toraw, Key)

 

 #define using_cmap_keydef_9(X, Key, Mapped, keyEqualsRaw, keyHashRaw, \

                             keyDel, keyFromRaw, keyToRaw, RawKey) \

             _c_using_chash(cmap_##X, cmap_, Key, Mapped, keyEqualsRaw, keyHashRaw, \

-                           c_trivial_del, c_trivial_fromraw, c_trivial_toraw, Mapped, \

+                           c_default_del, c_default_fromraw, c_default_toraw, Mapped, \

                            keyDel, keyFromRaw, keyToRaw, RawKey)

 

 #define using_cmap_str() \

@@ -98,11 +98,11 @@ int main(void) {
 #define using_cmap_strkey(...) c_MACRO_OVERLOAD(using_cmap_strkey, __VA_ARGS__)

 

 #define using_cmap_strkey_2(X, Mapped) \

-            using_cmap_strkey_4(X, Mapped, c_trivial_del, c_trivial_fromraw)

+            using_cmap_strkey_4(X, Mapped, c_default_del, c_default_fromraw)

 #define using_cmap_strkey_3(X, Mapped, mappedDel) \

             using_cmap_strkey_4(X, Mapped, mappedDel, c_no_clone)

 #define using_cmap_strkey_4(X, Mapped, mappedDel, mappedClone) \

-            _c_using_chash_strkey(X, cmap_, Mapped, mappedDel, mappedClone, c_trivial_toraw, Mapped)

+            _c_using_chash_strkey(X, cmap_, Mapped, mappedDel, mappedClone, c_default_toraw, Mapped)

 #define using_cmap_strkey_6(X, Mapped, mappedDel, mappedFromRaw, mappedToRaw, RawMapped) \

             _c_using_chash_strkey(X, cmap_, Mapped, mappedDel, mappedFromRaw, mappedToRaw, RawMapped)

 

@@ -117,11 +117,11 @@ int main(void) {
 #define using_cmap_strval_2(X, Key) \

             using_cmap_strval_4(X, Key, c_default_equals, c_default_hash)

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

-            using_cmap_strval_6(X, Key, keyEquals, keyHash, c_trivial_del, c_trivial_fromraw)

+            using_cmap_strval_6(X, Key, keyEquals, keyHash, c_default_del, c_default_fromraw)

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

             using_cmap_strval_6(X, Key, keyEquals, keyHash, keyDel, c_no_clone)

 #define using_cmap_strval_6(X, Key, keyEquals, keyHash, keyDel, keyClone) \

-            using_cmap_strval_8(X, Key, keyEquals, keyHash, keyDel, keyClone, c_trivial_toraw, Key)

+            using_cmap_strval_8(X, Key, keyEquals, keyHash, keyDel, keyClone, c_default_toraw, Key)

 

 #define using_cmap_strval_8(X, Key, keyEqualsRaw, keyHashRaw, keyDel, keyFromRaw, keyToRaw, RawKey) \

             _c_using_chash(cmap_##X, cmap_, Key, cstr, keyEqualsRaw, keyHashRaw, \

diff --git a/stc/cset.h b/stc/cset.h
index f8ccc511..81ccf6c7 100644
--- a/stc/cset.h
+++ b/stc/cset.h
@@ -50,11 +50,11 @@ int main(void) {
 #define using_cset_2(X, Key) \

             using_cset_4(X, Key, c_default_equals, c_default_hash)

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

-            using_cset_6(X, Key, keyEquals, keyHash, c_trivial_del, c_trivial_fromraw)

+            using_cset_6(X, Key, keyEquals, keyHash, c_default_del, c_default_fromraw)

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

             using_cset_6(X, Key, keyEquals, keyHash, keyDel, c_no_clone)

 #define using_cset_6(X, Key, keyEquals, keyHash, keyDel, keyClone) \

-            using_cset_8(X, Key, keyEquals, keyHash, keyDel, keyClone, c_trivial_toraw, Key)

+            using_cset_8(X, Key, keyEquals, keyHash, keyDel, keyClone, c_default_toraw, Key)

 

 #define using_cset_8(X, Key, keyEqualsRaw, keyHashRaw, keyDel, keyFromRaw, keyToRaw, RawKey) \

             _c_using_chash(cset_##X, cset_, Key, Key, keyEqualsRaw, keyHashRaw, \

diff --git a/stc/csmap.h b/stc/csmap.h
index b0d77e55..bea8abb4 100644
--- a/stc/csmap.h
+++ b/stc/csmap.h
@@ -54,15 +54,15 @@ int main(void) {
 #define using_csmap_3(X, Key, Mapped) \

             using_csmap_4(X, Key, Mapped, c_default_compare)

 #define using_csmap_4(X, Key, Mapped, keyCompare) \

-            using_csmap_6(X, Key, Mapped, keyCompare, c_trivial_del, c_trivial_fromraw)

+            using_csmap_6(X, Key, Mapped, keyCompare, c_default_del, c_default_fromraw)

 #define using_csmap_5(X, Key, Mapped, keyCompare, mappedDel) \

             using_csmap_6(X, Key, Mapped, keyCompare, mappedDel, c_no_clone)

 #define using_csmap_6(X, Key, Mapped, keyCompare, mappedDel, mappedClone) \

-            using_csmap_8(X, Key, Mapped, keyCompare, mappedDel, mappedClone, c_trivial_toraw, Mapped)

+            using_csmap_8(X, Key, Mapped, keyCompare, mappedDel, mappedClone, c_default_toraw, Mapped)

 #define using_csmap_8(X, Key, Mapped, keyCompare, mappedDel, mappedFromRaw, mappedToRaw, RawMapped) \

             using_csmap_12(X, Key, Mapped, keyCompare, \

                            mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \

-                           c_trivial_del, c_trivial_fromraw, c_trivial_toraw, Key)

+                           c_default_del, c_default_fromraw, c_default_toraw, Key)

 

 #define using_csmap_12(X, Key, Mapped, keyCompareRaw, \

                        mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \

@@ -76,12 +76,12 @@ int main(void) {
 

 #define using_csmap_keydef_6(X, Key, Mapped, keyCompare, keyDel, keyClone) \

             using_csmap_keydef_8(X, Key, Mapped, keyCompare, \

-                                 keyDel, keyClone, c_trivial_toraw, Key)

+                                 keyDel, keyClone, c_default_toraw, Key)

 

 #define using_csmap_keydef_8(X, Key, Mapped, keyCompareRaw, \

                              keyDel, keyFromRaw, keyToRaw, RawKey) \

             _c_using_aatree(csmap_##X, csmap_, Key, Mapped, keyCompareRaw, \

-                            c_trivial_del, c_trivial_fromraw, c_trivial_toraw, Mapped, \

+                            c_default_del, c_default_fromraw, c_default_toraw, Mapped, \

                             keyDel, keyFromRaw, keyToRaw, RawKey)

 

 #define using_csmap_str() \

@@ -93,11 +93,11 @@ int main(void) {
 #define using_csmap_strkey(...) c_MACRO_OVERLOAD(using_csmap_strkey, __VA_ARGS__)

 

 #define using_csmap_strkey_2(X, Mapped) \

-            using_csmap_strkey_4(X, Mapped, c_trivial_del, c_trivial_fromraw)

+            using_csmap_strkey_4(X, Mapped, c_default_del, c_default_fromraw)

 #define using_csmap_strkey_3(X, Mapped, mappedDel) \

             using_csmap_strkey_4(X, Mapped, mappedDel, c_no_clone)

 #define using_csmap_strkey_4(X, Mapped, mappedDel, mappedClone) \

-            _c_using_aatree_strkey(X, csmap_, Mapped, mappedDel, mappedClone, c_trivial_toraw, Mapped)

+            _c_using_aatree_strkey(X, csmap_, Mapped, mappedDel, mappedClone, c_default_toraw, Mapped)

 #define using_csmap_strkey_6(X, Mapped, mappedDel, mappedFromRaw, mappedToRaw, RawMapped) \

             _c_using_aatree_strkey(X, csmap_, Mapped, mappedDel, mappedFromRaw, mappedToRaw, RawMapped)

 

@@ -112,11 +112,11 @@ int main(void) {
 #define using_csmap_strval_2(X, Key) \

             using_csmap_strval_3(X, Key, c_default_compare)

 #define using_csmap_strval_3(X, Key, keyCompare) \

-            using_csmap_strval_5(X, Key, keyCompare, c_trivial_del, c_trivial_fromraw)

+            using_csmap_strval_5(X, Key, keyCompare, c_default_del, c_default_fromraw)

 #define using_csmap_strval_4(X, Key, keyCompare, keyDel) \

             using_csmap_strval_5(X, Key, keyCompare, keyDel, c_no_clone)

 #define using_csmap_strval_5(X, Key, keyCompare, keyDel, keyClone) \

-            using_csmap_strval_7(X, Key, keyCompare, keyDel, keyClone, c_trivial_toraw, Key)

+            using_csmap_strval_7(X, Key, keyCompare, keyDel, keyClone, c_default_toraw, Key)

 

 #define using_csmap_strval_7(X, Key, keyCompareRaw, keyDel, keyFromRaw, keyToRaw, RawKey) \

             _c_using_aatree(csmap_##X, csmap_, Key, cstr, keyCompareRaw, \

diff --git a/stc/csptr.h b/stc/csptr.h
index 435f8a35..66ae5240 100644
--- a/stc/csptr.h
+++ b/stc/csptr.h
@@ -89,7 +89,7 @@ typedef long atomic_count_t;
 #define using_csptr_2(X, Value) \

             using_csptr_3(X, Value, c_default_compare)

 #define using_csptr_3(X, Value, valueCompare) \

-            using_csptr_4(X, Value, valueCompare, c_trivial_del)

+            using_csptr_4(X, Value, valueCompare, c_default_del)

 #define using_csptr_4(X, Value, valueCompare, valueDel) \

             _c_using_csptr(csptr_##X, Value, valueCompare, valueDel)

 

diff --git a/stc/csset.h b/stc/csset.h
index 48ad6656..1218fb42 100644
--- a/stc/csset.h
+++ b/stc/csset.h
@@ -51,11 +51,11 @@ int main(void) {
 #define using_csset_2(X, Key) \

             using_csset_3(X, Key, c_default_compare)

 #define using_csset_3(X, Key, keyCompare) \

-            using_csset_5(X, Key, keyCompare, c_trivial_del, c_trivial_fromraw)

+            using_csset_5(X, Key, keyCompare, c_default_del, c_default_fromraw)

 #define using_csset_4(X, Key, keyCompare, keyDel) \

             using_csset_5(X, Key, keyCompare, keyDel, c_no_clone)

 #define using_csset_5(X, Key, keyCompare, keyDel, keyClone) \

-            using_csset_7(X, Key, keyCompare, keyDel, keyClone, c_trivial_toraw, Key)

+            using_csset_7(X, Key, keyCompare, keyDel, keyClone, c_default_toraw, Key)

 

 #define using_csset_7(X, Key, keyCompareRaw, keyDel, keyFromRaw, keyToRaw, RawKey) \

             _c_using_aatree(csset_##X, csset_, Key, Key, keyCompareRaw, \

diff --git a/stc/cvec.h b/stc/cvec.h
index 0c2206e9..88422be4 100644
--- a/stc/cvec.h
+++ b/stc/cvec.h
@@ -32,11 +32,11 @@
 #define using_cvec_2(X, Value) \

             using_cvec_3(X, Value, c_default_compare)

 #define using_cvec_3(X, Value, valueCompare) \

-            using_cvec_5(X, Value, valueCompare, c_trivial_del, c_trivial_fromraw)

+            using_cvec_5(X, Value, valueCompare, c_default_del, c_default_fromraw)

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

             using_cvec_5(X, Value, valueCompare, valueDel, c_no_clone)

 #define using_cvec_5(X, Value, valueCompare, valueDel, valueClone) \

-            using_cvec_7(X, Value, valueCompare, valueDel, valueClone, c_trivial_toraw, Value)

+            using_cvec_7(X, Value, valueCompare, valueDel, valueClone, c_default_toraw, Value)

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

             _c_using_cvec(cvec_##X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue)