From 6b55c6fee03d6a1d846eb1b05e810f1841ac7ae2 Mon Sep 17 00:00:00 2001 From: Tyge Løvset Date: Thu, 15 Apr 2021 15:15:02 +0200 Subject: NB! Changed API: *_erase_at(container, it) --> *_erase_it(container, it). cvec and cdeq insert_at() swapped with insert(). Docs update. --- README.md | 55 ++++++++++++++++++++++---------------------- benchmarks/others/clist_v1.h | 14 +++++------ benchmarks/others/csmap_v1.h | 2 +- docs/cdeq_api.md | 22 +++++++++--------- docs/clist_api.md | 30 ++++++++++++------------ docs/cmap_api.md | 6 ++--- docs/cpque_api.md | 2 +- docs/cqueue_api.md | 2 +- docs/cset_api.md | 6 ++--- docs/csmap_api.md | 4 ++-- docs/csptr_api.md | 5 ++-- docs/csset_api.md | 4 ++-- docs/cstack_api.md | 2 +- docs/cvec_api.md | 31 ++++++++++++------------- examples/csset_erase.c | 2 +- examples/demos.c | 6 ++--- examples/list_erase.c | 2 +- stc/cdeq.h | 26 ++++++++++----------- stc/clist.h | 12 +++++----- stc/cmap.h | 6 ++--- stc/cpque.h | 8 +++---- stc/csmap.h | 6 ++--- stc/csptr.h | 5 ++-- stc/cvec.h | 34 +++++++++++++-------------- 24 files changed, 147 insertions(+), 145 deletions(-) diff --git a/README.md b/README.md index 47796372..d484235d 100644 --- a/README.md +++ b/README.md @@ -7,9 +7,8 @@ Introduction ------------ A modern, templated, user-friendly, fast, fully type-safe, and customizable container library for C99, with a uniform API across the containers, and is similar to the c++ standard library containers API. - -Please read [this blog](https://iafisher.com/blog/2020/06/type-safe-generics-in-c) by Ian Fisher for -an introduction to type-safe generic data structures in C. +For an introduction to templated containers, please read the blog by Ian Fisher on +[type-safe generic data structures in C](https://iafisher.com/blog/2020/06/type-safe-generics-in-c). STC is a compact, header-only library with the all the major "standard" data containers, except for the multi-map/set variants: @@ -130,11 +129,11 @@ int main(void) { *i3.ref, *i4.ref, i5.ref->first, i5.ref->second); // erase the elements found - cset_i_erase_at(&set, i1); - cvec_p_erase_at(&vec, i2); - cdeq_i_erase_at(&deq, i3); - clist_i_erase_at(&lst, i4); - csmap_i_erase_at(&map, i5); + cset_i_erase_it(&set, i1); + cvec_p_erase_it(&vec, i2); + cdeq_i_erase_it(&deq, i3); + clist_i_erase_it(&lst, i4); + csmap_i_erase_it(&map, i5); printf("After erasing elements found:"); printf("\n set:"); c_foreach (i, cset_i, set) printf(" %d", *i.ref); @@ -195,26 +194,18 @@ with **emplace**, e.g. **cvec_X_emplace_back()**. This is a convenient alternati **cvec_X_push_back()** when dealing non-trivial container elements, e.g. smart pointers or elements using dynamic memory. -| Move and insert element | Construct element in-place | Container | -|:--------------------------|:-----------------------------|:--------------------------------| -| insert() | emplace() | cmap, cset, csmap, csset, clist | -| insert_or_assign(), put() | emplace_or_assign() | cmap, csmap | -| push() | emplace() | cstack, cqueue, cpque | -| push_back() | emplace_back() | cvec, cdeq, clist | -| push_front() | emplace_front() | cdeq, clist | - -For containers of integral or trivial element types, **emplace** and corresponding non-emplace -methods are identical, so the following does not apply for those. - The **emplace** methods ***construct*** or ***clone*** their own copy of the element to be added. -In contrast, the non-emplace methods requires elements to be explicitly constructed or cloned before adding them. - -A few of the differences between STC and c++ STL maps methods are: - -| STC maps | C++ STL maps | -|:-------------------------------------|:------------------------------| -| insert(Key, Mapped) | insert(Value) | -| emplace_or_assign(RawKey, RawMapped) | N/A | +In contrast, the non-emplace methods requires elements to be explicitly constructed or cloned +before adding them. For containers of integral or trivial element types, **emplace** and +corresponding non-emplace methods are identical, so the following does not apply for those. + +| Move and insert element | Construct element in-place | Container | +|:--------------------------|:-----------------------------|:--------------------------------------------| +| insert() | emplace() | cmap, cset, csmap, csset, cvec, cdeq, clist | +| insert_or_assign(), put() | emplace_or_assign() | cmap, csmap | +| push() | emplace() | cstack, cqueue, cpque | +| push_back() | emplace_back() | cvec, cdeq, clist | +| push_front() | emplace_front() | cdeq, clist | Strings are the most commonly used non-trivial data type. STC containers have proper pre-defined **using**-declarations for cstr-elements, so they are fail-safe to use both with the **emplace** @@ -261,6 +252,16 @@ it = cmap_str_find(&map, "Hello"); Apart from strings, maps and sets are normally used with trivial value types. However, the last example on the **cmap** page demonstrates how to specify a map with non-trivial keys. +Erase methods +------------- +| Name | Description | Container | +|:--------------------------|:-----------------------------|:--------------------------------------------| +| erase() | key based | csmap, csset, cmap, cset | +| erase_it() | iterator based | csmap, csset, cmap, cset, cvec, cdeq, clist | +| erase_range() | iterator based | csmap, csset, cvec, cdeq, clist | +| erase_n() | index based | cvec, cdeq | +| remove() | remove all matching values | clist | + Memory efficiency ----------------- - **cstr**, **cvec**: Type size: one pointer. The size and capacity is stored as part of the heap allocation that also holds the vector elements. diff --git a/benchmarks/others/clist_v1.h b/benchmarks/others/clist_v1.h index ae70dacf..c1f76d0b 100644 --- a/benchmarks/others/clist_v1.h +++ b/benchmarks/others/clist_v1.h @@ -114,7 +114,7 @@ STC_API size_t _clist_size(const clist_void* self); clist_##X##_clear(clist_##X* self) {clist_##X##_del(self);} \ \ STC_API void \ - clist_##X##_emplace_n(clist_##X *self, const clist_##X##_rawvalue_t arr[], size_t size); \ + clist_##X##_emplace_n(clist_##X *self, const clist_##X##_rawvalue_t arr[], size_t n); \ STC_API void \ clist_##X##_push_back(clist_##X* self, Value value); \ STC_INLINE void \ @@ -188,7 +188,7 @@ STC_API size_t _clist_size(const clist_void* self); } \ \ STC_API clist_##X##_iter_t \ - clist_##X##_find_before_in_range(const clist_##X* self, clist_##X##_iter_t first, clist_##X##_iter_t finish, RawValue val); \ + clist_##X##_find_before_in(const clist_##X* self, clist_##X##_iter_t first, clist_##X##_iter_t finish, RawValue val); \ STC_API clist_##X##_iter_t \ clist_##X##_find_before(const clist_##X* self, RawValue val); \ STC_API clist_##X##_iter_t \ @@ -234,8 +234,8 @@ STC_API size_t _clist_size(const clist_void* self); if (!self->last) self->last = entry; \ } \ STC_DEF void \ - clist_##X##_emplace_n(clist_##X *self, const clist_##X##_rawvalue_t arr[], size_t size) { \ - for (size_t i=0; isize -= erased; return erased; \ } \ STC_INLINE size_t \ - C##X##_erase_at(C##X* self, C##X##_iter_t pos) { \ + C##X##_erase_it(C##X* self, C##X##_iter_t pos) { \ return C##X##_erase(self, keyToRaw(KEY_REF_##C(pos.ref))); \ } \ \ diff --git a/docs/cdeq_api.md b/docs/cdeq_api.md index 03843fcf..b07ee2b0 100644 --- a/docs/cdeq_api.md +++ b/docs/cdeq_api.md @@ -54,27 +54,27 @@ void cdeq_X_push_front(cdeq_X* self, Value value); void cdeq_X_push_back(cdeq_X* self, Value value); void cdeq_X_emplace_front(cdeq_X* self, RawValue raw); void cdeq_X_emplace_back(cdeq_X* self, RawValue raw); -void cdeq_X_emplace_n(cdeq_X *self, const cdeq_X_rawvalue_t arr[], size_t size); +void cdeq_X_emplace_n(cdeq_X *self, const cdeq_X_rawvalue_t arr[], size_t n); void cdeq_X_pop_front(cdeq_X* self); -void cdeq_X_pop_back(cdeq_X* self); +void cdeq_X_pop_back(cdeq_X* self); -cdeq_X_iter_t cdeq_X_emplace(cdeq_X* self, size_t idx, RawValue raw); -cdeq_X_iter_t cdeq_X_emplace_at(cdeq_X* self, cdeq_X_iter_t pos, RawValue raw); -cdeq_X_iter_t cdeq_X_insert(cdeq_X* self, size_t idx, Value value); -cdeq_X_iter_t cdeq_X_insert_at(cdeq_X* self, cdeq_X_iter_t pos, Value value); -cdeq_X_iter_t cdeq_X_insert_range(cdeq_X* self, cdeq_X_iter_t pos, +cdeq_X_iter_t cdeq_X_emplace(cdeq_X* self, cdeq_X_iter_t it, RawValue raw); +cdeq_X_iter_t cdeq_X_emplace_at(cdeq_X* self, size_t idx, RawValue raw); +cdeq_X_iter_t cdeq_X_insert(cdeq_X* self, cdeq_X_iter_t it, Value value); +cdeq_X_iter_t cdeq_X_insert_at(cdeq_X* self, size_t idx, Value value); +cdeq_X_iter_t cdeq_X_insert_range(cdeq_X* self, cdeq_X_iter_t it, cdeq_X_iter_t first, cdeq_X_iter_t finish); -cdeq_X_iter_t cdeq_X_insert_range_p(cdeq_X* self, cdeq_X_value_t* pos, +cdeq_X_iter_t cdeq_X_insert_range_p(cdeq_X* self, cdeq_X_value_t* it, const cdeq_X_value_t* pfirst, const cdeq_X_value_t* pfinish); -cdeq_X_iter_t cdeq_X_erase(cdeq_X* self, size_t idx, size_t n); -cdeq_X_iter_t cdeq_X_erase_at(cdeq_X* self, cdeq_X_iter_t pos); +cdeq_X_iter_t cdeq_X_erase_it(cdeq_X* self, cdeq_X_iter_t it); cdeq_X_iter_t cdeq_X_erase_range(cdeq_X* self, cdeq_X_iter_t first, cdeq_X_iter_t finish); cdeq_X_iter_t cdeq_X_erase_range_p(cdeq_X* self, cdeq_X_value_t* pfirst, cdeq_X_value_t* pfinish); +cdeq_X_iter_t cdeq_X_erase_n(cdeq_X* self, size_t idx, size_t n); cdeq_X_iter_t cdeq_X_find(const cdeq_X* self, RawValue raw); -cdeq_X_iter_t cdeq_X_find_in_range(cdeq_X_iter_t i1, cdeq_X_iter_t i2, RawValue raw); +cdeq_X_iter_t cdeq_X_find_in(cdeq_X_iter_t i1, cdeq_X_iter_t i2, RawValue raw); void cdeq_X_sort(cdeq_X* self); void cdeq_X_sort_range(cdeq_X_iter_t i1, cdeq_X_iter_t i2, int(*cmp)(const cdeq_X_value_t*, const cdeq_X_value_t*)); diff --git a/docs/clist_api.md b/docs/clist_api.md index d1219046..6477eea7 100644 --- a/docs/clist_api.md +++ b/docs/clist_api.md @@ -15,8 +15,8 @@ However, an iterator to a succesive element can both be dereferenced and advance iterator is in a valid state. This implies: - `clist_X_insert(&L, clist_X_fwd(it,1), x)` is identical to *std::forward_list* `L.insert_after(it, x)`. -- `clist_X_erase_at(&L, clist_X_fwd(it,1))` is identical to *std::forward_list* `L.erase_after(it)`. -- Iterators returned from *clist_X_insert()* and *clist_X_erase_at()* are always valid. +- `clist_X_erase_it(&L, clist_X_fwd(it,1))` is identical to *std::forward_list* `L.erase_after(it)`. +- Iterators returned from *clist_X_insert()* and *clist_X_erase_it()* are always valid. - Elements can be safely removed from a list via multiple iterators if done back to front order. See the c++ class [std::list](https://en.cppreference.com/w/cpp/container/list) for similar API and @@ -48,10 +48,10 @@ clist_X clist_X_init(void); clist_X clist_X_clone(clist_X list); void clist_X_clear(clist_X* self); -void clist_X_del(clist_X* self); // destructor +void clist_X_del(clist_X* self); // destructor bool clist_X_empty(clist_X list); -size_t clist_X_count(clist_X list); // size() in O(n) time +size_t clist_X_count(clist_X list); // size() in O(n) time clist_X_value_t* clist_X_front(const clist_X* self); clist_X_value_t* clist_X_back(const clist_X* self); @@ -60,26 +60,26 @@ void clist_X_push_front(clist_X* self, Value value); void clist_X_emplace_front(clist_X* self, RawValue raw); void clist_X_pop_front(clist_X* self); -void clist_X_push_back(clist_X* self, Value value); // note: no pop_back(). -void clist_X_emplace_back(clist_X* self, RawValue raw); -void clist_X_emplace_n(clist_X *self, const clist_X_rawvalue_t arr[], size_t size); +void clist_X_push_back(clist_X* self, Value value); // note no pop_back(). +void clist_X_emplace_back(clist_X* self, RawValue raw); // note no emplace_back(). +void clist_X_emplace_n(clist_X *self, const clist_X_rawvalue_t arr[], size_t n); -clist_X_iter_t clist_X_insert(clist_X* self, clist_X_iter_t it, Value value); // return iter to new elem; End allowed +clist_X_iter_t clist_X_insert(clist_X* self, clist_X_iter_t it, Value value); // return iter to new elem clist_X_iter_t clist_X_emplace(clist_X* self, clist_X_iter_t it, RawValue raw); -clist_X_iter_t clist_X_erase_at(clist_X* self, clist_X_iter_t it); // return iter after it +clist_X_iter_t clist_X_erase_it(clist_X* self, clist_X_iter_t it); // return iter after it clist_X_iter_t clist_X_erase_range(clist_X* self, clist_X_iter_t it1, clist_X_iter_t it2); -size_t clist_X_remove(clist_X* self, RawValue raw); // removes all elements equal to raw +size_t clist_X_remove(clist_X* self, RawValue raw); // removes all elements equal to raw void clist_X_splice(clist_X* self, clist_X_iter_t it, clist_X* other); -void clist_X_splice_range(clist_X* self, clist_X_iter_t it, // see std::list::splice() docs +void clist_X_splice_range(clist_X* self, clist_X_iter_t it, // see std::list::splice() docs clist_X* other, clist_X_iter_t it1, clist_X_iter_t it2); // split out [it1, it2) from self, and return as a clist clist_X clist_X_split(clist_X* self, clist_X_iter_t it1, clist_X_iter_t it2); clist_X_iter_t clist_X_find(const clist_X* self, RawValue raw); -clist_X_iter_t clist_X_find_in_range(const clist_X* self, - clist_X_iter_t it1, clist_X_iter_t it2, RawValue raw); +clist_X_iter_t clist_X_find_in(const clist_X* self, + clist_X_iter_t it1, clist_X_iter_t it2, RawValue raw); void clist_X_sort(clist_X* self); @@ -139,7 +139,7 @@ sorted: 1 2 3 4 5 6 7 8 9 10 20 30 40 50 60 70 80 90 ``` ### Example 2 -Use of *erase_at()* and *erase_range()*: +Use of *erase_it()* and *erase_range()*: ```c // erasing from clist #include @@ -153,7 +153,7 @@ int main () // 10 20 30 40 50 clist_i_iter_t it = clist_i_begin(&L); // ^ clist_i_next(&it); - it = clist_i_erase_at(&L, it); // 10 30 40 50 + it = clist_i_erase_it(&L, it); // 10 30 40 50 // ^ clist_i_iter_t end = clist_i_end(&L); // clist_i_next(&it); diff --git a/docs/cmap_api.md b/docs/cmap_api.md index aec048e6..39550a19 100644 --- a/docs/cmap_api.md +++ b/docs/cmap_api.md @@ -63,10 +63,10 @@ cmap_X_result_t cmap_X_put(cmap_X* self, Key key, Mapped mapped); cmap_X_result_t cmap_X_emplace(cmap_X* self, RawKey rkey, RawMapped rmapped); // no change if rkey in map cmap_X_result_t cmap_X_emplace_or_assign(cmap_X* self, RawKey rkey, RawMapped rmapped); // always update rmapped -void cmap_X_emplace_n(cmap_X* self, const cmap_X_rawvalue_t arr[], size_t size); +void cmap_X_emplace_n(cmap_X* self, const cmap_X_rawvalue_t arr[], size_t n); -size_t cmap_X_erase(cmap_X* self, RawKey rkey); -cmap_X_iter_t cmap_X_erase_at(cmap_X* self, cmap_X_iter_t pos); +size_t cmap_X_erase(cmap_X* self, RawKey rkey); // return 0 or 1 +cmap_X_iter_t cmap_X_erase_it(cmap_X* self, cmap_X_iter_t it); // return iter after it void cmap_X_erase_entry(cmap_X* self, cmap_X_value_t* entry); cmap_X_iter_t cmap_X_begin(const cmap_X* self); diff --git a/docs/cpque_api.md b/docs/cpque_api.md index 822b4ad5..261c2909 100644 --- a/docs/cpque_api.md +++ b/docs/cpque_api.md @@ -37,7 +37,7 @@ const cpque_X_value_t* cpque_X_top(const cpque_X* self); void cpque_X_push(cpque_X* self, cpque_X_value_t value); void cpque_X_emplace(cpque_X* self, cpque_X_rawvalue_t raw); -void cpque_X_emplace_n(cpque_X *self, const cpque_X_rawvalue_t arr[], size_t size); +void cpque_X_emplace_n(cpque_X *self, const cpque_X_rawvalue_t arr[], size_t n); void cpque_X_pop(cpque_X* self); void cpque_X_erase_at(cpque_X* self, size_t idx); diff --git a/docs/cqueue_api.md b/docs/cqueue_api.md index 2d9b113c..7a18a9b4 100644 --- a/docs/cqueue_api.md +++ b/docs/cqueue_api.md @@ -32,7 +32,7 @@ cqueue_X_value_t* cqueue_X_back(const cqueue_X* self); void cqueue_X_push(cqueue_X* self, cqueue_X_value_t value); void cqueue_X_emplace(cqueue_X* self, cqueue_X_rawvalue_t raw); -void cqueue_X_emplace_n(cqueue_X *self, const cqueue_X_rawvalue_t arr[], size_t size); +void cqueue_X_emplace_n(cqueue_X *self, const cqueue_X_rawvalue_t arr[], size_t n); void cqueue_X_pop(cqueue_X* self); diff --git a/docs/cset_api.md b/docs/cset_api.md index dfdad074..848c6c63 100644 --- a/docs/cset_api.md +++ b/docs/cset_api.md @@ -43,10 +43,10 @@ bool cset_X_contains(const cset_X* self, RawKey rkey); cset_X_result_t cset_X_insert(cset_X* self, Key key); cset_X_result_t cset_X_emplace(cset_X* self, RawKey rkey); -void cset_X_emplace_n(cset_X* self, const RawKey arr[], size_t size); +void cset_X_emplace_n(cset_X* self, const RawKey arr[], size_t n); -size_t cset_X_erase(cset_X* self, RawKey rkey); -cset_X_iter_t cset_X_erase_at(cset_X* self, cset_X_iter_t pos); +size_t cset_X_erase(cset_X* self, RawKey rkey); // return 0 or 1 +cset_X_iter_t cset_X_erase_it(cset_X* self, cset_X_iter_t it); // return iter after it void cset_X_erase_entry(cset_X* self, cset_X_value_t* entry); cset_X_iter_t cset_X_begin(const cset_X* self); diff --git a/docs/csmap_api.md b/docs/csmap_api.md index 758bce09..dca919fb 100644 --- a/docs/csmap_api.md +++ b/docs/csmap_api.md @@ -62,10 +62,10 @@ csmap_X_result_t csmap_X_put(csmap_X* self, Key key, Mapped mapped); csmap_X_result_t csmap_X_emplace(csmap_X* self, RawKey rkey, RawMapped rmapped); // no change if rkey in map csmap_X_result_t csmap_X_emplace_or_assign(csmap_X* self, RawKey rkey, RawMapped rmapped); // always update rmapped -void csmap_X_emplace_n(csmap_X* self, const csmap_X_rawvalue_t arr[], size_t size); +void csmap_X_emplace_n(csmap_X* self, const csmap_X_rawvalue_t arr[], size_t n); size_t csmap_X_erase(csmap_X* self, RawKey rkey); -csmap_X_iter_t csmap_X_erase_at(csmap_X* self, csmap_X_iter_t it); // returns iter after it +csmap_X_iter_t csmap_X_erase_it(csmap_X* self, csmap_X_iter_t it); // returns iter after it csmap_X_iter_t csmap_X_erase_range(csmap_X* self, csmap_X_iter_t it1, csmap_X_iter_t it2); // returns updated it2 csmap_X_iter_t csmap_X_begin(const csmap_X* self); diff --git a/docs/csptr_api.md b/docs/csptr_api.md index 9669d97b..e1670bb2 100644 --- a/docs/csptr_api.md +++ b/docs/csptr_api.md @@ -39,7 +39,7 @@ The *csptr_X_compare()*, *csptr_X_equals()* and *csptr_X_del()* methods are defi csptr_X csptr_X_from(csptr_X_value_t* ptr); // constructor csptr_X csptr_X_make(csptr_X_value_t val); // make_shared void csptr_X_reset(csptr_X* self); -void csptr_X_reset_to(csptr_X* self, csptr_X_value_t* ptr); +void csptr_X_reset_with(csptr_X* self, csptr_X_value_t* ptr); csptr_X csptr_X_clone(csptr_X sptr); // share the pointer (increase use count) void csptr_X_move(csptr_X* self); // transfer ownership instead of sharing. @@ -49,10 +49,11 @@ int csptr_X_compare(csptr_X* x, csptr_X* y); bool csptr_X_equals(csptr_X* x, csptr_X* y); ``` -## Types +## Types and constants | Type name | Type definition | Used to represent... | |:--------------------|:--------------------------------------------------------------|:-------------------------| +| `csptr_null` | `{NULL, NULL}` | Init nullptr const | | `csptr_X` | `struct { csptr_X_value_t* get; atomic_count_t* use_count; }` | The csptr type | | `csptr_X_value_t` | `Value` | The csptr element type | | `atomic_count_t` | `long` | The reference counter | diff --git a/docs/csset_api.md b/docs/csset_api.md index 67e3c6a7..54a0ece9 100644 --- a/docs/csset_api.md +++ b/docs/csset_api.md @@ -41,10 +41,10 @@ bool csset_X_contains(const csset_X* self, RawKey rkey); csset_X_result_t csset_X_insert(csset_X* self, Key key); csset_X_result_t csset_X_emplace(csset_X* self, RawKey rkey); -void csset_X_emplace_n(csset_X* self, const RawKey arr[], size_t size); +void csset_X_emplace_n(csset_X* self, const RawKey arr[], size_t n); size_t csset_X_erase(csset_X* self, RawKey rkey); -csset_X_iter_t csset_X_erase_at(csset_X* self, csset_X_iter_t it); // return iter after it +csset_X_iter_t csset_X_erase_it(csset_X* self, csset_X_iter_t it); // return iter after it csset_X_iter_t csset_X_erase_range(csset_X* self, csset_X_iter_t it1, csset_X_iter_t it2); // return updated it2 csset_X_iter_t csset_X_begin(const csset_X* self); diff --git a/docs/cstack_api.md b/docs/cstack_api.md index 06163518..e892ac8e 100644 --- a/docs/cstack_api.md +++ b/docs/cstack_api.md @@ -32,7 +32,7 @@ cstack_X_value_t* cstack_X_top(const cstack_X* self); void cstack_X_push(cstack_X* self, cstack_X_value_t value); void cstack_X_emplace(cstack_X* self, cstack_X_rawvalue_t raw); -void cstack_X_emplace_n(cstack_X *self, const cstack_X_rawvalue_t arr[], size_t size); +void cstack_X_emplace_n(cstack_X *self, const cstack_X_rawvalue_t arr[], size_t n); void cstack_X_pop(cstack_X* self); diff --git a/docs/cvec_api.md b/docs/cvec_api.md index 6f495cae..d945e5e2 100644 --- a/docs/cvec_api.md +++ b/docs/cvec_api.md @@ -55,35 +55,34 @@ cvec_X_value_t* cvec_X_back(const cvec_X* self); void cvec_X_push_back(cvec_X* self, Value value); void cvec_X_emplace_back(cvec_X* self, RawValue raw); -void cvec_X_emplace_n(cvec_X *self, const cvec_X_rawvalue_t arr[], size_t size); +void cvec_X_emplace_n(cvec_X *self, const cvec_X_rawvalue_t arr[], size_t n); void cvec_X_pop_back(cvec_X* self); -cvec_X_iter_t cvec_X_insert(cvec_X* self, size_t idx, Value value); -cvec_X_iter_t cvec_X_insert_at(cvec_X* self, cvec_X_iter_t pos, Value value); -cvec_X_iter_t cvec_X_insert_range(cvec_X* self, cvec_X_iter_t pos, - cvec_X_iter_t first, cvec_X_iter_t finish); -cvec_X_iter_t cvec_X_insert_range_p(cvec_X* self, cvec_X_value_t* pos, - const cvec_X_value_t* pfirst, const cvec_X_value_t* pfinish); -cvec_X_iter_t cvec_X_emplace(cvec_X* self, size_t idx, RawValue raw); -cvec_X_iter_t cvec_X_emplace_at(cvec_X* self, cvec_X_iter_t pos, RawValue raw); +cvec_X_iter_t cvec_X_insert(cvec_X* self, cvec_X_iter_t it, Value value); +cvec_X_iter_t cvec_X_insert_at(cvec_X* self, size_t idx, Value value); +cvec_X_iter_t cvec_X_insert_range(cvec_X* self, cvec_X_iter_t it, + cvec_X_iter_t i1, cvec_X_iter_t i2); -cvec_X_iter_t cvec_X_erase(cvec_X* self, size_t idx, size_t n); -cvec_X_iter_t cvec_X_erase_at(cvec_X* self, cvec_X_iter_t pos); -cvec_X_iter_t cvec_X_erase_range(cvec_X* self, cvec_X_iter_t first, cvec_X_iter_t finish); -cvec_X_iter_t cvec_X_erase_range_p(cvec_X* self, cvec_X_value_t* pfirst, cvec_X_value_t* pfinish); +cvec_X_iter_t cvec_X_emplace(cvec_X* self, cvec_X_iter_t it, RawValue raw); +cvec_X_iter_t cvec_X_emplace_at(cvec_X* self, size_t idx, RawValue raw); + +cvec_X_iter_t cvec_X_erase_it(cvec_X* self, cvec_X_iter_t it); +cvec_X_iter_t cvec_X_erase_range(cvec_X* self, cvec_X_iter_t i1, cvec_X_iter_t i2); +cvec_X_iter_t cvec_X_erase_n(cvec_X* self, size_t idx, size_t n); cvec_X_iter_t cvec_X_find(const cvec_X* self, RawValue raw); -cvec_X_iter_t cvec_X_find_in_range(cvec_X_iter_t i1, cvec_X_iter_t i2, RawValue raw); +cvec_X_iter_t cvec_X_find_in(cvec_X_iter_t i1, cvec_X_iter_t i2, RawValue raw); cvec_X_iter_t cvec_X_bsearch(const cvec_X* self, RawValue raw); -cvec_X_iter_t cvec_X_bsearch_in_range(cvec_X_iter_t i1, cvec_X_iter_t i2, RawValue raw); +cvec_X_iter_t cvec_X_bsearch_in(cvec_X_iter_t i1, cvec_X_iter_t i2, RawValue raw); + void cvec_X_sort(cvec_X* self); void cvec_X_sort_range(cvec_X_iter_t i1, cvec_X_iter_t i2, int(*cmp)(const cvec_X_value_t*, const cvec_X_value_t*)); cvec_X_iter_t cvec_X_begin(const cvec_X* self); cvec_X_iter_t cvec_X_end(const cvec_X* self); -void cvec_X_next(cvec_X_iter_t* it); +void cvec_X_next(cvec_X_iter_t* iter); size_t cvec_X_index(const cvec_X vec, cvec_X_iter_t it); cvec_X_value_t cvec_X_value_clone(cvec_X_value_t val); diff --git a/examples/csset_erase.c b/examples/csset_erase.c index 9a05290d..96bc4c98 100644 --- a/examples/csset_erase.c +++ b/examples/csset_erase.c @@ -15,7 +15,7 @@ int main() c_foreach (k, csset_i, it, csset_i_end(&set)) printf(" %d", *k.ref); puts(""); printf("Erase values >= %d:\n", val); - while (it.ref) it = csset_i_erase_at(&set, it); + while (it.ref) it = csset_i_erase_it(&set, it); c_foreach (k, csset_i, set) printf(" %d", *k.ref); puts(""); val = 35; diff --git a/examples/demos.c b/examples/demos.c index 14bf20d4..f6f1a6cf 100644 --- a/examples/demos.c +++ b/examples/demos.c @@ -46,10 +46,10 @@ void vectordemo1() cvec_ix_push_back(&bignums, i * i); printf("erase - %d: %zu\n", 3, bignums.data[3]); - cvec_ix_erase(&bignums, 3, 1); // erase index 3 + cvec_ix_erase_n(&bignums, 3, 1); // erase index 3 cvec_ix_pop_back(&bignums); // erase the last - cvec_ix_erase(&bignums, 0, 1); // erase the first + cvec_ix_erase_n(&bignums, 0, 1); // erase the first for (size_t i = 0; i < cvec_ix_size(bignums); ++i) { printf("%zu: %zu\n", i, bignums.data[i]); @@ -170,7 +170,7 @@ void mapdemo3() printf("entry: %s: %s\n", i.ref->first.str, i.ref->second.str); printf("size %zu: remove: Make: %s\n", cmap_str_size(table), it.ref->second.str); //cmap_str_erase(&table, "Make"); - cmap_str_erase_at(&table, it); + cmap_str_erase_it(&table, it); printf("size %zu\n", cmap_str_size(table)); c_foreach (i, cmap_str, table) diff --git a/examples/list_erase.c b/examples/list_erase.c index 6e70b103..fd68b250 100644 --- a/examples/list_erase.c +++ b/examples/list_erase.c @@ -10,7 +10,7 @@ int main () // 10 20 30 40 50 clist_i_iter_t it = clist_i_begin(&L); // ^ clist_i_next(&it); - it = clist_i_erase_at(&L, it); // 10 30 40 50 + it = clist_i_erase_it(&L, it); // 10 30 40 50 // ^ clist_i_iter_t end = clist_i_end(&L); // clist_i_next(&it); diff --git a/stc/cdeq.h b/stc/cdeq.h index 52dfb5d7..9c07fc4b 100644 --- a/stc/cdeq.h +++ b/stc/cdeq.h @@ -90,8 +90,8 @@ typedef int (*c_cmp_fn)(const void*, const void*); CX##_value_t* CX##_back(const CX* self) \ {return self->data + cdeq_rep_(self)->size - 1;} \ STC_INLINE \ - CX##_value_t* CX##_at(const CX* self, size_t i) \ - {assert(i < cdeq_rep_(self)->size); return self->data + i;} \ + CX##_value_t* CX##_at(const CX* self, size_t idx) \ + {assert(idx < cdeq_rep_(self)->size); return self->data + idx;} \ \ STC_INLINE CX \ CX##_with_size(size_t size, Value null_val) { \ @@ -120,20 +120,20 @@ typedef int (*c_cmp_fn)(const void*, const void*); return CX##_insert_range_p(self, it.ref, first.ref, finish.ref); \ } \ STC_INLINE CX##_iter_t \ - CX##_insert_at(CX* self, CX##_iter_t it, Value value) { \ + CX##_insert(CX* self, CX##_iter_t it, Value value) { \ return CX##_insert_range_p(self, it.ref, &value, &value + 1); \ } \ STC_INLINE CX##_iter_t \ - CX##_insert(CX* self, size_t idx, Value value) { \ + CX##_insert_at(CX* self, size_t idx, Value value) { \ return CX##_insert_range_p(self, self->data + idx, &value, &value + 1); \ } \ STC_INLINE CX##_iter_t \ - CX##_emplace_at(CX* self, CX##_iter_t it, RawValue raw) { \ - return CX##_insert_at(self, it, valueFromRaw(raw)); \ + CX##_emplace(CX* self, CX##_iter_t it, RawValue raw) { \ + return CX##_insert(self, it, valueFromRaw(raw)); \ } \ STC_INLINE CX##_iter_t \ - CX##_emplace(CX* self, size_t idx, RawValue raw) { \ - return CX##_insert(self, idx, valueFromRaw(raw)); \ + CX##_emplace_at(CX* self, size_t idx, RawValue raw) { \ + return CX##_insert_at(self, idx, valueFromRaw(raw)); \ } \ \ STC_API CX##_iter_t \ @@ -144,11 +144,11 @@ typedef int (*c_cmp_fn)(const void*, const void*); return CX##_erase_range_p(self, first.ref, finish.ref); \ } \ STC_INLINE CX##_iter_t \ - CX##_erase_at(CX* self, CX##_iter_t it) { \ + CX##_erase_it(CX* self, CX##_iter_t it) { \ return CX##_erase_range_p(self, it.ref, it.ref + 1); \ } \ STC_INLINE CX##_iter_t \ - CX##_erase(CX* self, size_t idx, size_t n) { \ + CX##_erase_n(CX* self, size_t idx, size_t n) { \ return CX##_erase_range_p(self, self->data + idx, self->data + idx + n); \ } \ \ @@ -166,10 +166,10 @@ typedef int (*c_cmp_fn)(const void*, const void*); CX##_index(CX deq, CX##_iter_t it) {return it.ref - deq.data;} \ \ STC_API CX##_iter_t \ - CX##_find_in_range(CX##_iter_t first, CX##_iter_t finish, RawValue raw); \ + CX##_find_in(CX##_iter_t first, CX##_iter_t finish, RawValue raw); \ STC_INLINE CX##_iter_t \ CX##_find(const CX* self, RawValue raw) { \ - return CX##_find_in_range(CX##_begin(self), CX##_end(self), raw); \ + return CX##_find_in(CX##_begin(self), CX##_end(self), raw); \ } \ STC_API int \ CX##_value_compare(const CX##_value_t* x, const CX##_value_t* y); \ @@ -314,7 +314,7 @@ static inline double _maxf(double x, double y) {return x > y ? x : y;} } \ \ STC_DEF CX##_iter_t \ - CX##_find_in_range(CX##_iter_t i1, CX##_iter_t i2, RawValue raw) { \ + CX##_find_in(CX##_iter_t i1, CX##_iter_t i2, RawValue raw) { \ for (; i1.ref != i2.ref; ++i1.ref) { \ RawValue r = valueToRaw(i1.ref); \ if (valueCompareRaw(&raw, &r) == 0) return i1; \ diff --git a/stc/clist.h b/stc/clist.h index 66a42a2d..a2f7668c 100644 --- a/stc/clist.h +++ b/stc/clist.h @@ -121,18 +121,18 @@ STC_API size_t _clist_size(const clist_VOID* self); STC_INLINE \ CX##_iter_t CX##_emplace(CX* self, CX##_iter_t it, RawValue raw) \ {return CX##_insert(self, it, valueFromRaw(raw));} \ - STC_API void CX##_emplace_n(CX *self, const CX##_rawvalue_t arr[], size_t size); \ + STC_API void CX##_emplace_n(CX *self, const CX##_rawvalue_t arr[], size_t n); \ \ STC_API CX##_node_t* CX##_erase_after_(CX* self, CX##_node_t* node); \ STC_INLINE void CX##_pop_front(CX* self) {CX##_erase_after_(self, self->last);} \ - STC_API CX##_iter_t CX##_erase_at(CX* self, CX##_iter_t it); \ + STC_API CX##_iter_t CX##_erase_it(CX* self, CX##_iter_t it); \ STC_API CX##_iter_t CX##_erase_range(CX* self, CX##_iter_t it1, CX##_iter_t it2); \ STC_API size_t CX##_remove(CX* self, RawValue val); \ \ STC_API void CX##_splice(CX* self, CX##_iter_t it, CX* other); \ STC_API CX CX##_split(CX* self, CX##_iter_t it1, CX##_iter_t it2); \ STC_API void CX##_sort(CX* self); \ - STC_API CX##_iter_t CX##_find_in_range(const CX* self, CX##_iter_t it1, CX##_iter_t it2, RawValue val); \ + STC_API CX##_iter_t CX##_find_in(const CX* self, CX##_iter_t it1, CX##_iter_t it2, RawValue val); \ \ STC_INLINE Value* CX##_front(const CX* self) {return &self->last->next->value;} \ STC_INLINE Value* CX##_back(const CX* self) {return &self->last->value;} \ @@ -169,7 +169,7 @@ STC_API size_t _clist_size(const clist_VOID* self); \ STC_INLINE CX##_iter_t \ CX##_find(const CX* self, RawValue val) { \ - return CX##_find_in_range(self, CX##_begin(self), CX##_end(self), val); \ + return CX##_find_in(self, CX##_begin(self), CX##_end(self), val); \ } \ \ _c_implement_clist(CX, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue) \ @@ -222,7 +222,7 @@ STC_API size_t _clist_size(const clist_VOID* self); } \ \ STC_DEF CX##_iter_t \ - CX##_erase_at(CX* self, CX##_iter_t it) { \ + CX##_erase_it(CX* self, CX##_iter_t it) { \ CX##_node_t *node = _clist_node(CX, it.ref); \ it.ref = (node == self->last) ? NULL : &node->next->value; \ CX##_erase_after_(self, it._prev); \ @@ -239,7 +239,7 @@ STC_API size_t _clist_size(const clist_VOID* self); } \ \ STC_DEF CX##_iter_t \ - CX##_find_in_range(const CX* self, CX##_iter_t it1, CX##_iter_t it2, RawValue val) { \ + CX##_find_in(const CX* self, CX##_iter_t it1, CX##_iter_t it2, RawValue val) { \ c_foreach_4 (it, CX, it1, it2) { \ RawValue r = valueToRaw(it.ref); \ if (valueCompareRaw(&r, &val) == 0) return it; \ diff --git a/stc/cmap.h b/stc/cmap.h index 4690b995..ed1da3d9 100644 --- a/stc/cmap.h +++ b/stc/cmap.h @@ -293,9 +293,9 @@ STC_INLINE uint64_t c_default_hash64(const void* data, size_t ignored) } \ \ STC_INLINE CX##_iter_t \ - CX##_erase_at(CX* self, CX##_iter_t pos) { \ - CX##_erase_entry(self, pos.ref); \ - CX##_next(&pos); return pos; \ + CX##_erase_it(CX* self, CX##_iter_t it) { \ + CX##_erase_entry(self, it.ref); \ + CX##_next(&it); return it; \ } \ \ _c_implement_chash(CX, C, Key, Mapped, keyEqualsRaw, keyHashRaw, \ diff --git a/stc/cpque.h b/stc/cpque.h index 05a2295b..9bc365c2 100644 --- a/stc/cpque.h +++ b/stc/cpque.h @@ -72,7 +72,7 @@ STC_INLINE bool CX##_empty(CX pq) {return ctype##_empty(pq);} \ \ STC_API void CX##_make_heap(CX* self); \ - STC_API void CX##_erase_at(CX* self, size_t i); \ + STC_API void CX##_erase_at(CX* self, size_t idx); \ STC_INLINE \ const CX##_value_t* CX##_top(const CX* self) {return &self->data[0];} \ STC_INLINE void CX##_pop(CX* self) {CX##_erase_at(self, 0);} \ @@ -114,11 +114,11 @@ } \ \ STC_API void \ - CX##_erase_at(CX* self, size_t i) { \ + CX##_erase_at(CX* self, size_t idx) { \ size_t n = CX##_size(*self) - 1; \ - self->data[i] = self->data[n]; \ + self->data[idx] = self->data[n]; \ ctype##_pop_back(self); \ - CX##_sift_down_(self->data - 1, i + 1, n); \ + CX##_sift_down_(self->data - 1, idx + 1, n); \ } \ \ STC_API void \ diff --git a/stc/csmap.h b/stc/csmap.h index 74298dad..6b58c6a3 100644 --- a/stc/csmap.h +++ b/stc/csmap.h @@ -188,7 +188,7 @@ struct csmap_rep { size_t root, disp, head, size, cap; void* nodes[]; }; STC_API CX##_value_t* CX##_front(const CX* self); \ STC_API CX##_value_t* CX##_back(const CX* self); \ STC_API int CX##_erase(CX* self, RawKey rkey); \ - STC_API CX##_iter_t CX##_erase_at(CX* self, CX##_iter_t pos); \ + STC_API CX##_iter_t CX##_erase_it(CX* self, CX##_iter_t it); \ STC_API CX##_iter_t CX##_erase_range(CX* self, CX##_iter_t it1, CX##_iter_t it2); \ STC_API CX##_result_t CX##_insert_entry_(CX* self, RawKey rkey); \ \ @@ -500,7 +500,7 @@ static struct csmap_rep _csmap_inits = {0, 0, 0, 0}; } \ \ STC_DEF CX##_iter_t \ - CX##_erase_at(CX* self, CX##_iter_t it) { \ + CX##_erase_it(CX* self, CX##_iter_t it) { \ CX##_rawkey_t raw = keyToRaw(KEY_REF_##C(it.ref)), nxt; \ CX##_next(&it); \ if (it.ref) nxt = keyToRaw(KEY_REF_##C(it.ref)); \ @@ -511,7 +511,7 @@ static struct csmap_rep _csmap_inits = {0, 0, 0, 0}; \ STC_DEF CX##_iter_t \ CX##_erase_range(CX* self, CX##_iter_t it1, CX##_iter_t it2) { \ - if (!it2.ref) { while (it1.ref) it1 = CX##_erase_at(self, it1); \ + if (!it2.ref) { while (it1.ref) it1 = CX##_erase_it(self, it1); \ return it1; } \ CX##_key_t k1 = *KEY_REF_##C(it1.ref), k2 = *KEY_REF_##C(it2.ref); \ CX##_rawkey_t r1 = keyToRaw(&k1); \ diff --git a/stc/csptr.h b/stc/csptr.h index 6c2f1a36..d4f81e5d 100644 --- a/stc/csptr.h +++ b/stc/csptr.h @@ -143,10 +143,11 @@ typedef long atomic_count_t; self->use_count = NULL, self->get = NULL; \ } \ \ - STC_INLINE void \ - CX##_reset_to(CX* self, CX##_value_t* p) { \ + STC_INLINE CX##_value_t* \ + CX##_reset_with(CX* self, CX##_value_t* p) { \ CX##_del(self); \ *self = CX##_from(p); \ + return self->get; \ } \ \ STC_INLINE int \ diff --git a/stc/cvec.h b/stc/cvec.h index 6a21db16..e938195b 100644 --- a/stc/cvec.h +++ b/stc/cvec.h @@ -108,20 +108,20 @@ typedef int (*c_cmp_fn)(const void*, const void*); return CX##_insert_range_p(self, it.ref, it1.ref, it2.ref); \ } \ STC_INLINE CX##_iter_t \ - CX##_insert_at(CX* self, CX##_iter_t it, Value value) { \ + CX##_insert(CX* self, CX##_iter_t it, Value value) { \ return CX##_insert_range_p(self, it.ref, &value, &value + 1); \ } \ STC_INLINE CX##_iter_t \ - CX##_insert(CX* self, size_t idx, Value value) { \ + CX##_insert_at(CX* self, size_t idx, Value value) { \ return CX##_insert_range_p(self, self->data + idx, &value, &value + 1); \ } \ STC_INLINE CX##_iter_t \ - CX##_emplace_at(CX* self, CX##_iter_t it, RawValue raw) { \ - return CX##_insert_at(self, it, valueFromRaw(raw)); \ + CX##_emplace(CX* self, CX##_iter_t it, RawValue raw) { \ + return CX##_insert(self, it, valueFromRaw(raw)); \ } \ STC_INLINE CX##_iter_t \ - CX##_emplace(CX* self, size_t idx, RawValue raw) { \ - return CX##_insert(self, idx, valueFromRaw(raw)); \ + CX##_emplace_at(CX* self, size_t idx, RawValue raw) { \ + return CX##_insert_at(self, idx, valueFromRaw(raw)); \ } \ \ STC_API CX##_iter_t \ @@ -132,11 +132,11 @@ typedef int (*c_cmp_fn)(const void*, const void*); return CX##_erase_range_p(self, it1.ref, it2.ref); \ } \ STC_INLINE CX##_iter_t \ - CX##_erase_at(CX* self, CX##_iter_t it) { \ + CX##_erase_it(CX* self, CX##_iter_t it) { \ return CX##_erase_range_p(self, it.ref, it.ref + 1); \ } \ STC_INLINE CX##_iter_t \ - CX##_erase(CX* self, size_t idx, size_t n) { \ + CX##_erase_n(CX* self, size_t idx, size_t n) { \ return CX##_erase_range_p(self, self->data + idx, self->data + idx + n); \ } \ \ @@ -146,9 +146,9 @@ typedef int (*c_cmp_fn)(const void*, const void*); CX##_back(const CX* self) {return self->data + _cvec_rep(self)->size - 1;} \ \ STC_INLINE CX##_value_t* \ - CX##_at(const CX* self, size_t i) { \ - assert(i < _cvec_rep(self)->size); \ - return self->data + i; \ + CX##_at(const CX* self, size_t idx) { \ + assert(idx < _cvec_rep(self)->size); \ + return self->data + idx; \ } \ \ STC_INLINE CX##_iter_t \ @@ -165,17 +165,17 @@ typedef int (*c_cmp_fn)(const void*, const void*); CX##_index(CX vec, CX##_iter_t it) {return it.ref - vec.data;} \ \ STC_API CX##_iter_t \ - CX##_find_in_range(CX##_iter_t it1, CX##_iter_t it2, RawValue raw); \ + CX##_find_in(CX##_iter_t it1, CX##_iter_t it2, RawValue raw); \ STC_INLINE CX##_iter_t \ CX##_find(const CX* self, RawValue raw) { \ - return CX##_find_in_range(CX##_begin(self), CX##_end(self), raw); \ + return CX##_find_in(CX##_begin(self), CX##_end(self), raw); \ } \ \ STC_API CX##_iter_t \ - CX##_bsearch_in_range(CX##_iter_t i1, CX##_iter_t i2, RawValue raw); \ + CX##_bsearch_in(CX##_iter_t i1, CX##_iter_t i2, RawValue raw); \ STC_INLINE CX##_iter_t \ CX##_bsearch(const CX* self, RawValue raw) { \ - return CX##_bsearch_in_range(CX##_begin(self), CX##_end(self), raw); \ + return CX##_bsearch_in(CX##_begin(self), CX##_end(self), raw); \ } \ STC_INLINE void \ CX##_sort_range(CX##_iter_t i1, CX##_iter_t i2, \ @@ -293,7 +293,7 @@ static struct cvec_rep _cvec_inits = {0, 0}; } \ \ STC_DEF CX##_iter_t \ - CX##_find_in_range(CX##_iter_t i1, CX##_iter_t i2, RawValue raw) { \ + CX##_find_in(CX##_iter_t i1, CX##_iter_t i2, RawValue raw) { \ for (; i1.ref != i2.ref; ++i1.ref) { \ RawValue r = valueToRaw(i1.ref); \ if (valueCompareRaw(&raw, &r) == 0) return i1; \ @@ -301,7 +301,7 @@ static struct cvec_rep _cvec_inits = {0, 0}; return i2; \ } \ STC_DEF CX##_iter_t \ - CX##_bsearch_in_range(CX##_iter_t i1, CX##_iter_t i2, RawValue raw) { \ + CX##_bsearch_in(CX##_iter_t i1, CX##_iter_t i2, RawValue raw) { \ CX##_iter_t mid, last = i2; \ while (i1.ref != i2.ref) { \ mid.ref = i1.ref + ((i2.ref - i1.ref)>>1); \ -- cgit v1.2.3