From 4d9378ef420b4787208a742057a60dcf408ef741 Mon Sep 17 00:00:00 2001 From: Tyge Løvset Date: Sat, 20 Feb 2021 16:57:09 +0100 Subject: Internal renaming improvements. --- benchmarks/cmap_benchmark3.cpp | 4 ++-- docs/cdeq_api.md | 2 +- docs/clist_api.md | 2 +- docs/cmap_api.md | 25 ++++++++++++------------- docs/cptr_api.md | 6 +++--- docs/csmap_api.md | 16 ++++++++-------- docs/cstr_api.md | 2 +- docs/cvec_api.md | 2 +- examples/csmap_v1.h | 24 ++++++++++++------------ examples/demos.c | 10 +++++----- stc/carray.h | 4 ++-- stc/ccommon.h | 10 +++++----- stc/cdeq.h | 6 +++--- stc/clist.h | 6 +++--- stc/cmap.h | 36 ++++++++++++++++++------------------ stc/csmap.h | 30 +++++++++++++++--------------- stc/cstr.h | 5 ++++- stc/cvec.h | 6 +++--- 18 files changed, 99 insertions(+), 97 deletions(-) diff --git a/benchmarks/cmap_benchmark3.cpp b/benchmarks/cmap_benchmark3.cpp index 2990619e..fa7edabd 100644 --- a/benchmarks/cmap_benchmark3.cpp +++ b/benchmarks/cmap_benchmark3.cpp @@ -47,8 +47,8 @@ stc64_t rng; #define CMAP_DTOR(X) cmap_##X##_del(&map) #define KMAP_SETUP(X, Key, Value) khash_t(ii)* map = kh_init(ii); khiter_t ki; int ret -#define KMAP_PUT(X, key, val) (*(ki = kh_emplace_put(ii, map, key, &ret), map->vals[ki] = val, &map->vals[ki])) -#define KMAP_EMPLACE(X, key, val) (ki = kh_emplace_put(ii, map, key, &ret), ret ? (map->vals[ki] = val, 0) : 0, map->vals[ki]) +#define KMAP_PUT(X, key, val) (*(ki = kh_put(ii, map, key, &ret), map->vals[ki] = val, &map->vals[ki])) +#define KMAP_EMPLACE(X, key, val) (ki = kh_put(ii, map, key, &ret), ret ? (map->vals[ki] = val, 0) : 0, map->vals[ki]) #define KMAP_ERASE(X, key) ((ki = kh_get(ii, map, key)) != kh_end(map) ? kh_del(ii, map, ki), 1 : 0) #define KMAP_FIND(X, key) (kh_get(ii, map, key) != kh_end(map)) #define KMAP_SIZE(X) kh_size(map) diff --git a/docs/cdeq_api.md b/docs/cdeq_api.md index 8061cbdd..ed4730c6 100644 --- a/docs/cdeq_api.md +++ b/docs/cdeq_api.md @@ -22,7 +22,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, cstr_from, cstr_to_raw, const char*) +using_cdeq(str, cstr_t, cstr_compare_raw, cstr_del, cstr_from, cstr_c_str, const char*) ``` ## Header file diff --git a/docs/clist_api.md b/docs/clist_api.md index c69d61d3..3482cede 100644 --- a/docs/clist_api.md +++ b/docs/clist_api.md @@ -29,7 +29,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, cstr_from, cstr_to_raw, const char*) +using_clist(str, cstr_t, cstr_compare_raw, cstr_del, cstr_from, cstr_c_str, const char*) ``` ## Header file diff --git a/docs/cmap_api.md b/docs/cmap_api.md index 1b953f1d..ccd4532f 100644 --- a/docs/cmap_api.md +++ b/docs/cmap_api.md @@ -197,17 +197,17 @@ Demonstrate cmap with plain-old-data key type Vec3i and int as mapped type: cmap typedef struct { int x, y, z; } Vec3i; -using_cmap(v3, Vec3i, int, c_mem_equals, // compare Vec3i bitwise +using_cmap(v3, Vec3i, int, c_memcmp_equals, // compare Vec3i bitwise c_default_hash); // hash Vec3i bitwise. int main() { cmap_v3 vecs = cmap_v3_init(); - cmap_v3_emplace_put(&vecs, (Vec3i){100, 0, 0}, 1); - cmap_v3_emplace_put(&vecs, (Vec3i){ 0, 100, 0}, 2); - cmap_v3_emplace_put(&vecs, (Vec3i){ 0, 0, 100}, 3); - cmap_v3_emplace_put(&vecs, (Vec3i){100, 100, 100}, 4); + cmap_v3_emplace(&vecs, (Vec3i){100, 0, 0}, 1); + cmap_v3_emplace(&vecs, (Vec3i){ 0, 100, 0}, 2); + cmap_v3_emplace(&vecs, (Vec3i){ 0, 0, 100}, 3); + cmap_v3_emplace(&vecs, (Vec3i){100, 100, 100}, 4); c_foreach (i, cmap_v3, vecs) printf("{ %3d, %3d, %3d }: %d\n", i.ref->first.x, i.ref->first.y, i.ref->first.z, i.ref->second); @@ -235,10 +235,10 @@ using_cmap(iv, int, Vec3i); int main() { cmap_iv vecs = cmap_iv_init(); - cmap_iv_emplace_put(&vecs, 1, (Vec3i){100, 0, 0}); - cmap_iv_emplace_put(&vecs, 2, (Vec3i){ 0, 100, 0}); - cmap_iv_emplace_put(&vecs, 3, (Vec3i){ 0, 0, 100}); - cmap_iv_emplace_put(&vecs, 4, (Vec3i){100, 100, 100}); + cmap_iv_emplace(&vecs, 1, (Vec3i){100, 0, 0}); + cmap_iv_emplace(&vecs, 2, (Vec3i){ 0, 100, 0}); + cmap_iv_emplace(&vecs, 3, (Vec3i){ 0, 0, 100}); + cmap_iv_emplace(&vecs, 4, (Vec3i){100, 100, 100}); c_foreach (i, cmap_iv, vecs) printf("%d: { %3d, %3d, %3d }\n", i.ref->first, i.ref->second.x, i.ref->second.y, i.ref->second.z); @@ -294,11 +294,10 @@ static inline VikingRaw viking_toRaw(Viking* vk) { VikingRaw raw = {vk->name.str, vk->country.str}; return raw; } -// With this in place, we use the full using_cmap() macro to define {Viking -> int} hash map type: +// With this in place, we use the using_cmap_keyarg() macro to define {Viking -> int} hash map type: -using_cmap(vk, Viking, int, vikingraw_equals, vikingraw_hash, - c_default_del, c_default_clone, // mapped: int => use default. - viking_del, viking_fromRaw, viking_toRaw, VikingRaw); +using_cmap_keyarg(vk, Viking, int, vikingraw_equals, vikingraw_hash, + viking_del, viking_fromRaw, viking_toRaw, VikingRaw); int main() { diff --git a/docs/cptr_api.md b/docs/cptr_api.md index 747f463c..baf31177 100644 --- a/docs/cptr_api.md +++ b/docs/cptr_api.md @@ -11,7 +11,7 @@ The pointed-to elements are automatically destructed and deleted when the contai ```c using_cptr(X, Value, valueCompare=c_default_compare, valueDestroy=c_default_del, - valueClone=c_default_clone) + valueClone=c_default_fromraw) using_csptr(X, Value, valueCompare=c_default_compare, valueDestroy=c_default_del, @@ -86,8 +86,8 @@ void Person_del(Person* p) { c_del(cstr, &p->name, &p->last); } // declare managed pointer and cvec with pointers -using_cptr(pe, Person, c_no_compare, Person_del, c_no_clone); -using_cvec(pe, Person*, c_no_compare, cptr_pe_del, c_no_clone); +using_cptr(pe, Person, c_no_compare, Person_del, c_no_fromraw); +using_cvec(pe, Person*, c_no_compare, cptr_pe_del, c_no_fromraw); int main() { cvec_pe vec = cvec_pe_init(); diff --git a/docs/csmap_api.md b/docs/csmap_api.md index ffbf7db4..7bc52406 100644 --- a/docs/csmap_api.md +++ b/docs/csmap_api.md @@ -189,10 +189,10 @@ int main() { csmap_vi vecs = csmap_vi_init(); - csmap_vi_emplace_put(&vecs, (Vec3i){100, 0, 0}, 1); - csmap_vi_emplace_put(&vecs, (Vec3i){ 0, 100, 0}, 2); - csmap_vi_emplace_put(&vecs, (Vec3i){ 0, 0, 100}, 3); - csmap_vi_emplace_put(&vecs, (Vec3i){100, 100, 100}, 4); + csmap_vi_emplace(&vecs, (Vec3i){100, 0, 0}, 1); + csmap_vi_emplace(&vecs, (Vec3i){ 0, 100, 0}, 2); + csmap_vi_emplace(&vecs, (Vec3i){ 0, 0, 100}, 3); + csmap_vi_emplace(&vecs, (Vec3i){100, 100, 100}, 4); c_foreach (i, csmap_vi, vecs) printf("{ %3d, %3d, %3d }: %d\n", i.ref->first.x, i.ref->first.y, i.ref->first.z, i.ref->second); @@ -220,10 +220,10 @@ using_csmap(iv, int, Vec3i); int main() { csmap_iv vecs = csmap_iv_init(); - csmap_iv_emplace_put(&vecs, 1, (Vec3i){100, 0, 0}); - csmap_iv_emplace_put(&vecs, 2, (Vec3i){ 0, 100, 0}); - csmap_iv_emplace_put(&vecs, 3, (Vec3i){ 0, 0, 100}); - csmap_iv_emplace_put(&vecs, 4, (Vec3i){100, 100, 100}); + csmap_iv_emplace(&vecs, 1, (Vec3i){100, 0, 0}); + csmap_iv_emplace(&vecs, 2, (Vec3i){ 0, 100, 0}); + csmap_iv_emplace(&vecs, 3, (Vec3i){ 0, 0, 100}); + csmap_iv_emplace(&vecs, 4, (Vec3i){100, 100, 100}); c_foreach (i, csmap_iv, vecs) printf("%d: { %3d, %3d, %3d }\n", i.ref->first, i.ref->second.x, i.ref->second.y, i.ref->second.z); diff --git a/docs/cstr_api.md b/docs/cstr_api.md index 9703e4ff..773ef3cc 100644 --- a/docs/cstr_api.md +++ b/docs/cstr_api.md @@ -93,7 +93,7 @@ Iterator methods, typically used via the general *c_foreach* macro. ``` `1-2)` Read a line of text from *stream* and store it in string. Line is separated by *delim*, which is *'\n'* in `1)`. ```c - const char* cstr_to_raw(const cstr* x); + const char* cstr_c_str(const cstr* x); int cstr_compare_raw(const char** x, const char** y); bool cstr_equals_raw(const char** x, const char** y); uint32_t cstr_hash_raw(const char* const* x, size_t ignored); diff --git a/docs/cvec_api.md b/docs/cvec_api.md index ef5c9f99..fdbd879f 100644 --- a/docs/cvec_api.md +++ b/docs/cvec_api.md @@ -26,7 +26,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, cstr_from, cstr_to_raw, const char*) +using_cvec(str, cstr_t, cstr_compare_raw, cstr_del, cstr_from, cstr_c_str, const char*) ``` ## Header file diff --git a/examples/csmap_v1.h b/examples/csmap_v1.h index 14abecbf..33673b65 100644 --- a/examples/csmap_v1.h +++ b/examples/csmap_v1.h @@ -50,19 +50,19 @@ int main(void) { 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_default_del, c_default_clone) + 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_default_del, c_default_clone) + 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_default_to_raw, Key) + keyDel, keyClone, c_default_toraw, Key) #define using_csmap_10(X, Key, Mapped, keyCompareRaw, mappedDel, mappedClone, \ keyDel, keyFromRaw, keyToRaw, RawKey) \ _using_CBST(X, csmap, Key, Mapped, keyCompareRaw, mappedDel, keyDel, \ - keyFromRaw, keyToRaw, RawKey, mappedClone, c_default_to_raw, Mapped) + keyFromRaw, keyToRaw, RawKey, mappedClone, c_default_toraw, Mapped) /* csset: */ #define using_csset(...) \ @@ -72,10 +72,10 @@ int main(void) { using_csset_3(X, Key, c_default_compare) #define using_csset_3(X, Key, keyCompare) \ - using_csset_5(X, Key, keyCompare, c_default_del, c_default_clone) + 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_default_to_raw, Key) + using_csset_7(X, Key, keyCompare, keyDel, keyClone, c_default_toraw, Key) #define using_csset_7(X, Key, keyCompareRaw, keyDel, keyFromRaw, keyToRaw, RawKey) \ _using_CBST(X, csset, Key, Key, keyCompareRaw, _UNUSED_, keyDel, \ @@ -86,20 +86,20 @@ int main(void) { _using_CBST_strkey(str, csset, cstr_t, _UNUSED_, _UNUSED_) #define using_csmap_str() \ _using_CBST(str, csmap, cstr_t, cstr_t, cstr_compare_raw, cstr_del, cstr_del, \ - cstr_from, cstr_to_raw, const char*, cstr_from, cstr_to_raw, const char*) + cstr_from, cstr_c_str, const char*, cstr_from, cstr_c_str, const char*) #define using_csmap_strkey(...) \ c_MACRO_OVERLOAD(using_csmap_strkey, __VA_ARGS__) #define using_csmap_strkey_2(X, Mapped) \ - _using_CBST_strkey(X, csmap, Mapped, c_default_del, c_default_clone) + _using_CBST_strkey(X, csmap, Mapped, c_default_del, c_default_fromraw) #define using_csmap_strkey_4(X, Mapped, mappedDel, mappedClone) \ _using_CBST_strkey(X, csmap, Mapped, mappedDel, mappedClone) #define _using_CBST_strkey(X, C, Mapped, mappedDel, mappedClone) \ _using_CBST(X, C, cstr_t, Mapped, cstr_compare_raw, mappedDel, cstr_del, \ - cstr_from, cstr_to_raw, const char*, mappedClone, c_default_to_raw, Mapped) + cstr_from, cstr_c_str, const char*, mappedClone, c_default_toraw, Mapped) #define using_csmap_strval(...) \ c_MACRO_OVERLOAD(using_csmap_strval, __VA_ARGS__) @@ -108,14 +108,14 @@ int main(void) { 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_default_del, c_default_clone) + 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_default_to_raw, 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) \ _using_CBST(X, csmap, Key, cstr_t, keyCompare, cstr_del, keyDel, \ - keyFromRaw, keyToRaw, RawKey, cstr_from, cstr_to_raw, const char*) + keyFromRaw, keyToRaw, RawKey, cstr_from, cstr_c_str, const char*) #define SET_ONLY_csset(...) __VA_ARGS__ #define SET_ONLY_csmap(...) diff --git a/examples/demos.c b/examples/demos.c index db284ea9..e89c3170 100644 --- a/examples/demos.c +++ b/examples/demos.c @@ -124,8 +124,8 @@ void mapdemo1() { printf("\nMAPDEMO1\n"); cmap_ii nums = cmap_ii_init(); - cmap_ii_emplace_put(&nums, 8, 64); - cmap_ii_emplace_put(&nums, 11, 121); + cmap_ii_emplace(&nums, 8, 64); + cmap_ii_emplace(&nums, 11, 121); printf("val 8: %d\n", *cmap_ii_at(&nums, 8)); cmap_ii_del(&nums); } @@ -159,9 +159,9 @@ void mapdemo3() { printf("\nMAPDEMO3\n"); cmap_str table = cmap_str_init(); - cmap_str_emplace_put(&table, "Map", "test"); - cmap_str_emplace_put(&table, "Make", "my"); - cmap_str_emplace_put(&table, "Sunny", "day"); + cmap_str_emplace(&table, "Map", "test"); + cmap_str_emplace(&table, "Make", "my"); + cmap_str_emplace(&table, "Sunny", "day"); cmap_str_value_t *e = cmap_str_find(&table, "Make").ref; c_foreach (i, cmap_str, table) printf("entry: %s: %s\n", i.ref->first.str, i.ref->second.str); diff --git a/stc/carray.h b/stc/carray.h index 6a42510f..3f0983bc 100644 --- a/stc/carray.h +++ b/stc/carray.h @@ -48,10 +48,10 @@ int main() #define using_carray(...) c_MACRO_OVERLOAD(using_carray, __VA_ARGS__) #define using_carray_2(X, Value) \ - using_carray_4(X, Value, c_default_del, c_default_clone) + using_carray_4(X, Value, c_default_del, c_default_fromraw) #define using_carray_3(X, Value, valueDestroy) \ - using_carray_4(X, Value, valueDestroy, c_no_clone) + using_carray_4(X, Value, valueDestroy, c_no_fromraw) #define using_carray_4(X, Value, valueDestroy, valueClone) \ \ diff --git a/stc/ccommon.h b/stc/ccommon.h index fd108208..5d63dbaa 100644 --- a/stc/ccommon.h +++ b/stc/ccommon.h @@ -81,14 +81,14 @@ #define c_default_compare(x, y) c_less_compare(c_default_less, x, y) #define c_default_less(x, y) (*(x) < *(y)) #define c_less_compare(less, x, y) (less(y, x) - less(x, y)) -#define c_no_compare(x, y) (assert(!"c_no_compare"), 0) +#define c_no_compare(x, y) (assert(!"c_no_compare() called"), 0) #define c_default_equals(x, y) (*(x) == *(y)) -#define c_mem_equals(x, y) (memcmp(x, y, sizeof *(x)) == 0) +#define c_memcmp_equals(x, y) (memcmp(x, y, sizeof *(x)) == 0) -#define c_default_clone(x) (x) -#define c_no_clone(x) (assert(!"c_no_clone"), x) -#define c_default_to_raw(ptr) (*(ptr)) +#define c_no_fromraw(x) (assert(!"emplace*() with c_no_fromraw"), x) +#define c_default_fromraw(x) (x) +#define c_default_toraw(ptr) (*(ptr)) #define c_default_del(ptr) ((void) (ptr)) diff --git a/stc/cdeq.h b/stc/cdeq.h index 340b5021..c8907660 100644 --- a/stc/cdeq.h +++ b/stc/cdeq.h @@ -31,11 +31,11 @@ #define using_cdeq_2(X, Value) \ using_cdeq_3(X, Value, c_default_compare) #define using_cdeq_3(X, Value, valueCompare) \ - using_cdeq_7(X, Value, valueCompare, c_default_del, c_default_clone, c_default_to_raw, Value) + using_cdeq_7(X, Value, valueCompare, c_default_del, c_default_fromraw, c_default_toraw, Value) #define using_cdeq_4(X, Value, valueCompare, valueDestroy) \ - using_cdeq_7(X, Value, valueCompare, valueDestroy, c_no_clone, c_default_to_raw, Value) + using_cdeq_7(X, Value, valueCompare, valueDestroy, c_no_fromraw, c_default_toraw, Value) #define using_cdeq_str() \ - using_cdeq_7(str, cstr_t, cstr_compare_raw, cstr_del, cstr_from, cstr_to_raw, const char*) + using_cdeq_7(str, cstr_t, cstr_compare_raw, cstr_del, cstr_from, cstr_c_str, const char*) #define typedefs_cdeq(X, Value, RawValue) \ typedef Value cdeq_##X##_value_t; \ diff --git a/stc/clist.h b/stc/clist.h index 11f8d0e0..ff05f97b 100644 --- a/stc/clist.h +++ b/stc/clist.h @@ -59,11 +59,11 @@ #define using_clist_2(X, Value) \ using_clist_3(X, Value, c_default_compare) #define using_clist_3(X, Value, valueCompare) \ - using_clist_7(X, Value, valueCompare, c_default_del, c_default_clone, c_default_to_raw, Value) + using_clist_7(X, Value, valueCompare, c_default_del, c_default_fromraw, c_default_toraw, Value) #define using_clist_4(X, Value, valueCompare, valueDestroy) \ - using_clist_7(X, Value, valueCompare, valueDestroy, c_no_clone, c_default_to_raw, Value) + using_clist_7(X, Value, valueCompare, valueDestroy, c_no_fromraw, c_default_toraw, Value) #define using_clist_str() \ - using_clist_7(str, cstr_t, cstr_compare_raw, cstr_del, cstr_from, cstr_to_raw, const char*) + using_clist_7(str, cstr_t, cstr_compare_raw, cstr_del, cstr_from, cstr_c_str, const char*) #define using_clist_types(X, Value) \ typedef Value clist_##X##_value_t; \ diff --git a/stc/cmap.h b/stc/cmap.h index 0d4bb9fe..94dbf8e1 100644 --- a/stc/cmap.h +++ b/stc/cmap.h @@ -39,9 +39,9 @@ int main(void) { cset_sx_del(&s); cmap_mx m = cmap_mx_init(); - cmap_mx_emplace_put(&m, 5, 'a'); - cmap_mx_emplace_put(&m, 8, 'b'); - cmap_mx_emplace_put(&m, 12, 'c'); + cmap_mx_emplace(&m, 5, 'a'); + cmap_mx_emplace(&m, 8, 'b'); + cmap_mx_emplace(&m, 12, 'c'); cmap_mx_iter_t it = cmap_mx_find(&m, 10); // none char val = cmap_mx_find(&m, 5).ref->second; cmap_mx_emplace_put(&m, 5, 'd'); // update @@ -65,17 +65,17 @@ typedef struct {size_t idx; uint32_t hx;} chash_bucket_t; #define using_cmap_5(X, Key, Mapped, keyEquals, keyHash) \ using_cmap_9(X, Key, Mapped, keyEquals, keyHash, \ - c_default_del, c_default_clone, c_default_to_raw, Mapped) + c_default_del, c_default_fromraw, c_default_toraw, Mapped) #define using_cmap_6(X, Key, Mapped, keyEquals, keyHash, mappedDel) \ using_cmap_9(X, Key, Mapped, keyEquals, keyHash, \ - mappedDel, c_no_clone, c_default_to_raw, Mapped) + mappedDel, c_no_fromraw, c_default_toraw, Mapped) #define using_cmap_9(X, Key, Mapped, keyEqualsRaw, keyHashRaw, \ mappedDel, mappedFromRaw, mappedToRaw, RawMapped) \ _using_CHASH(X, cmap, Key, Mapped, keyEqualsRaw, keyHashRaw, \ mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \ - c_default_del, c_default_clone, c_default_to_raw, Key) + c_default_del, c_default_fromraw, c_default_toraw, Key) #define using_cmap_13(X, Key, Mapped, keyEqualsRaw, keyHashRaw, \ mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \ @@ -87,11 +87,11 @@ typedef struct {size_t idx; uint32_t hx;} chash_bucket_t; #define using_cmap_keyarg(...) c_MACRO_OVERLOAD(using_cmap_keyarg, __VA_ARGS__) #define using_cmap_keyarg_6(X, Key, Mapped, keyEquals, keyHash, keyDel) \ using_cmap_keyarg_9(X, Key, Mapped, keyEquals, keyHash, \ - keyDel, c_no_clone, c_default_to_raw, Key) + keyDel, c_no_fromraw, c_default_toraw, Key) #define using_cmap_keyarg_9(X, Key, Mapped, keyEqualsRaw, keyHashRaw, \ keyDel, keyFromRaw, keyToRaw, RawKey) \ _using_CHASH(X, cmap, Key, Mapped, keyEqualsRaw, keyHashRaw, \ - c_default_del, c_default_clone, c_default_to_raw, Mapped, \ + c_default_del, c_default_fromraw, c_default_toraw, Mapped, \ keyDel, keyFromRaw, keyToRaw, RawKey) /* cset: */ @@ -102,10 +102,10 @@ typedef struct {size_t idx; uint32_t hx;} chash_bucket_t; using_cset_4(X, Key, c_default_equals, c_default_hash) #define using_cset_4(X, Key, keyEquals, keyHash) \ - using_cset_8(X, Key, keyEquals, keyHash, c_default_del, c_default_clone, c_default_to_raw, Key) + using_cset_8(X, Key, keyEquals, keyHash, c_default_del, c_default_fromraw, c_default_toraw, Key) #define using_cset_5(X, Key, keyEquals, keyHash, keyDel) \ - using_cset_8(X, Key, keyEquals, keyHash, keyDel, c_no_clone, c_default_to_raw, Key) + using_cset_8(X, Key, keyEquals, keyHash, keyDel, c_no_fromraw, c_default_toraw, Key) #define using_cset_8(X, Key, keyEqualsRaw, keyHashRaw, keyDel, keyFromRaw, keyToRaw, RawKey) \ _using_CHASH(X, cset, Key, Key, keyEqualsRaw, keyHashRaw, \ @@ -117,17 +117,17 @@ typedef struct {size_t idx; uint32_t hx;} chash_bucket_t; _using_CHASH_strkey(str, cset, cstr_t, _UNUSED_, _UNUSED_, _UNUSED_, void) #define using_cmap_str() \ _using_CHASH(str, cmap, cstr_t, cstr_t, cstr_equals_raw, cstr_hash_raw, \ - cstr_del, cstr_from, cstr_to_raw, const char*, \ - cstr_del, cstr_from, cstr_to_raw, const char*) + cstr_del, cstr_from, cstr_c_str, const char*, \ + cstr_del, cstr_from, cstr_c_str, const char*) #define using_cmap_strkey(...) \ c_MACRO_OVERLOAD(using_cmap_strkey, __VA_ARGS__) #define using_cmap_strkey_2(X, Mapped) \ - _using_CHASH_strkey(X, cmap, Mapped, c_default_del, c_default_clone, c_default_to_raw, Mapped) + _using_CHASH_strkey(X, cmap, Mapped, c_default_del, c_default_fromraw, c_default_toraw, Mapped) #define using_cmap_strkey_3(X, Mapped, mappedDel) \ - _using_CHASH_strkey(X, cmap, Mapped, mappedDel, c_no_clone, c_default_to_raw, Mapped) + _using_CHASH_strkey(X, cmap, Mapped, mappedDel, c_no_fromraw, c_default_toraw, Mapped) #define using_cmap_strkey_6(X, Mapped, mappedDel, mappedFromRaw, mappedToRaw, RawMapped) \ _using_CHASH_strkey(X, cmap, Mapped, mappedDel, mappedFromRaw, mappedToRaw, RawMapped) @@ -135,7 +135,7 @@ typedef struct {size_t idx; uint32_t hx;} chash_bucket_t; #define _using_CHASH_strkey(X, C, Mapped, mappedDel, mappedFromRaw, mappedToRaw, RawMapped) \ _using_CHASH(X, C, cstr_t, Mapped, cstr_equals_raw, cstr_hash_raw, \ mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \ - cstr_del, cstr_from, cstr_to_raw, const char*) + cstr_del, cstr_from, cstr_c_str, const char*) #define using_cmap_strval(...) \ c_MACRO_OVERLOAD(using_cmap_strval, __VA_ARGS__) @@ -144,14 +144,14 @@ typedef struct {size_t idx; uint32_t hx;} chash_bucket_t; using_cmap_strval_4(X, Key, c_default_equals, c_default_hash) #define using_cmap_strval_4(X, Key, keyEquals, keyHash) \ - using_cmap_strval_8(X, Key, keyEquals, keyHash, c_default_del, c_default_clone, c_default_to_raw, Key) + using_cmap_strval_8(X, Key, keyEquals, keyHash, c_default_del, c_default_fromraw, c_default_toraw, Key) #define using_cmap_strval_5(X, Key, keyEquals, keyHash, keyDel) \ - using_cmap_strval_8(X, Key, keyEquals, keyHash, keyDel, c_no_clone, c_default_to_raw, Key) + using_cmap_strval_8(X, Key, keyEquals, keyHash, keyDel, c_no_fromraw, c_default_toraw, Key) #define using_cmap_strval_8(X, Key, keyEquals, keyHash, keyDel, keyFromRaw, keyToRaw, RawKey) \ _using_CHASH(X, cmap, Key, cstr_t, keyEquals, keyHash, \ - cstr_del, cstr_from, cstr_to_raw, const char*, \ + cstr_del, cstr_from, cstr_c_str, const char*, \ keyDel, keyFromRaw, keyToRaw, RawKey) #define SET_ONLY_cset(...) __VA_ARGS__ diff --git a/stc/csmap.h b/stc/csmap.h index 7a9ea97b..6920b7c5 100644 --- a/stc/csmap.h +++ b/stc/csmap.h @@ -49,15 +49,15 @@ int main(void) { using_csmap_4(X, Key, Mapped, c_default_compare) #define using_csmap_4(X, Key, Mapped, keyCompare) \ - using_csmap_8(X, Key, Mapped, keyCompare, c_default_del, c_default_clone, c_default_to_raw, Mapped) + using_csmap_8(X, Key, Mapped, keyCompare, c_default_del, c_default_fromraw, c_default_toraw, Mapped) #define using_csmap_5(X, Key, Mapped, keyCompare, mappedDel) \ - using_csmap_8(X, Key, Mapped, keyCompare, mappedDel, c_no_clone, c_default_to_raw, Mapped) + using_csmap_8(X, Key, Mapped, keyCompare, mappedDel, c_no_fromraw, 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_default_del, c_default_clone, c_default_to_raw, Key) + c_default_del, c_default_fromraw, c_default_toraw, Key) #define using_csmap_12(X, Key, Mapped, keyCompareRaw, \ mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \ @@ -69,11 +69,11 @@ int main(void) { #define using_csmap_keyarg(...) c_MACRO_OVERLOAD(using_csmap_keyarg, __VA_ARGS__) #define using_csmap_keyarg_5(X, Key, Mapped, keyCompare, keyDel) \ using_csmap_keyarg_8(X, Key, Mapped, keyCompare, \ - keyDel, c_no_clone, c_default_to_raw, Key) + keyDel, c_no_fromraw, c_default_toraw, Key) #define using_csmap_keyarg_8(X, Key, Mapped, keyCompareRaw, \ keyDel, keyFromRaw, keyToRaw, RawKey) \ _using_AATREE(X, csmap, Key, Mapped, keyCompareRaw, \ - c_default_del, c_default_clone, c_default_to_raw, Mapped, \ + c_default_del, c_default_fromraw, c_default_toraw, Mapped, \ keyDel, keyFromRaw, keyToRaw, RawKey) /* csset: */ @@ -84,10 +84,10 @@ int main(void) { using_csset_3(X, Key, c_default_compare) #define using_csset_3(X, Key, keyCompare) \ - using_csset_7(X, Key, keyCompare, c_default_del, c_default_clone, c_default_to_raw, Key) + using_csset_7(X, Key, keyCompare, c_default_del, c_default_fromraw, c_default_toraw, Key) #define using_csset_4(X, Key, keyCompare, keyDel) \ - using_csset_7(X, Key, keyCompare, keyDel, c_no_clone, c_default_to_raw, Key) + using_csset_7(X, Key, keyCompare, keyDel, c_no_fromraw, c_default_toraw, Key) #define using_csset_7(X, Key, keyCompareRaw, keyDel, keyFromRaw, keyToRaw, RawKey) \ _using_AATREE(X, csset, Key, Key, keyCompareRaw, \ @@ -99,17 +99,17 @@ int main(void) { _using_AATREE_strkey(str, csset, cstr_t, _UNUSED_, _UNUSED_, _UNUSED_, void) #define using_csmap_str() \ _using_AATREE(str, csmap, cstr_t, cstr_t, cstr_compare_raw, \ - cstr_del, cstr_from, cstr_to_raw, const char*, \ - cstr_del, cstr_from, cstr_to_raw, const char*) + cstr_del, cstr_from, cstr_c_str, const char*, \ + cstr_del, cstr_from, cstr_c_str, const char*) #define using_csmap_strkey(...) \ c_MACRO_OVERLOAD(using_csmap_strkey, __VA_ARGS__) #define using_csmap_strkey_2(X, Mapped) \ - _using_AATREE_strkey(X, csmap, Mapped, c_default_del, c_default_clone, c_default_to_raw, Mapped) + _using_AATREE_strkey(X, csmap, Mapped, c_default_del, c_default_fromraw, c_default_toraw, Mapped) #define using_csmap_strkey_3(X, Mapped, mappedDel) \ - _using_AATREE_strkey(X, csmap, Mapped, mappedDel, c_no_clone, c_default_to_raw, Mapped) + _using_AATREE_strkey(X, csmap, Mapped, mappedDel, c_no_fromraw, c_default_toraw, Mapped) #define using_csmap_strkey_6(X, Mapped, mappedDel, mappedFromRaw, mappedToRaw, RawMapped) \ _using_AATREE_strkey(X, csmap, Mapped, mappedDel, mappedFromRaw, mappedToRaw, RawMapped) @@ -117,7 +117,7 @@ int main(void) { #define _using_AATREE_strkey(X, C, Mapped, mappedDel, mappedFromRaw, mappedToRaw, RawMapped) \ _using_AATREE(X, C, cstr_t, Mapped, cstr_compare_raw, \ mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \ - cstr_del, cstr_from, cstr_to_raw, const char*) + cstr_del, cstr_from, cstr_c_str, const char*) #define using_csmap_strval(...) \ c_MACRO_OVERLOAD(using_csmap_strval, __VA_ARGS__) @@ -126,14 +126,14 @@ int main(void) { using_csmap_strval_3(X, Key, c_default_compare) #define using_csmap_strval_3(X, Key, keyCompare) \ - using_csmap_strval_7(X, Key, keyCompare, c_default_del, c_default_clone, c_default_to_raw, Key) + using_csmap_strval_7(X, Key, keyCompare, c_default_del, c_default_fromraw, c_default_toraw, Key) #define using_csmap_strval_4(X, Key, keyCompare, keyDel) \ - using_csmap_strval_7(X, Key, keyCompare, keyDel, c_no_clone, c_default_to_raw, Key) + using_csmap_strval_7(X, Key, keyCompare, keyDel, c_no_fromraw, c_default_toraw, Key) #define using_csmap_strval_7(X, Key, keyCompare, keyDel, keyFromRaw, keyToRaw, RawKey) \ _using_AATREE(X, csmap, Key, cstr_t, keyCompare, \ - cstr_del, cstr_from, cstr_to_raw, const char*, \ + cstr_del, cstr_from, cstr_c_str, const char*, \ keyDel, keyFromRaw, keyToRaw, RawKey) #define SET_ONLY_csset(...) __VA_ARGS__ diff --git a/stc/cstr.h b/stc/cstr.h index 19c356c0..4fb929f8 100644 --- a/stc/cstr.h +++ b/stc/cstr.h @@ -218,12 +218,15 @@ cstr_iends_with(cstr_t s, const char* needle) { } /* cvec/cmap adaption functions: */ -#define cstr_to_raw(x) ((x)->str) +#define cstr_c_str(x) ((x)->str) #define cstr_compare_raw(x, y) strcmp(*(x), *(y)) #define cstr_equals_raw(x, y) (strcmp(*(x), *(y)) == 0) #define cstr_hash_raw(p, none) c_default_hash(*(p), strlen(*(p))) + #define cstr_compare_ref(x, y) strcmp((x)->str, (y)->str) #define cstr_equals_ref(x, y) (strcmp((x)->str, (y)->str) == 0) +#define cstr_hash_ref(p, none) c_default_hash((p)->str, cstr_size(*(p))) + #define c_strhash(s) c_default_hash(s, strlen(s)) /* -------------------------- IMPLEMENTATION ------------------------- */ diff --git a/stc/cvec.h b/stc/cvec.h index 2e7b6c75..ad63bd2b 100644 --- a/stc/cvec.h +++ b/stc/cvec.h @@ -31,11 +31,11 @@ #define using_cvec_2(X, Value) \ using_cvec_3(X, Value, c_default_compare) #define using_cvec_3(X, Value, valueCompare) \ - using_cvec_7(X, Value, valueCompare, c_default_del, c_default_clone, c_default_to_raw, Value) + using_cvec_7(X, Value, valueCompare, c_default_del, c_default_fromraw, c_default_toraw, Value) #define using_cvec_4(X, Value, valueCompare, valueDestroy) \ - using_cvec_7(X, Value, valueCompare, valueDestroy, c_no_clone, c_default_to_raw, Value) + using_cvec_7(X, Value, valueCompare, valueDestroy, c_no_fromraw, c_default_toraw, Value) #define using_cvec_str() \ - using_cvec_7(str, cstr_t, cstr_compare_raw, cstr_del, cstr_from, cstr_to_raw, const char*) + using_cvec_7(str, cstr_t, cstr_compare_raw, cstr_del, cstr_from, cstr_c_str, const char*) #define typedefs_cvec(X, Value, RawValue) \ typedef Value cvec_##X##_value_t; \ -- cgit v1.2.3