Fixup in API regarding _at() - more consistent.

10 files changed, 49 insertions, 42 deletions

diff --git a/docs/ccommon_api.md b/docs/ccommon_api.md
index 210c75ae..3214fbef 100644
--- a/docs/ccommon_api.md
+++ b/docs/ccommon_api.md
@@ -57,7 +57,6 @@ c_forrange (i, int, 30, 0, -5) printf(" %d", i);
 using_csset(x, int);
 ...
 c_init (csset_x, set, {23, 3, 7, 5, 12});
-double sum = 0;
 c_foreach (i, csset_x, set) printf(" %d", *i.ref);
 // 3 5 7 12 23
 csset_x_iter_t it = csset_x_find(&set, 7);
diff --git a/docs/cdeq_api.md b/docs/cdeq_api.md
index ca4855da..9aa8cd4b 100644
--- a/docs/cdeq_api.md
+++ b/docs/cdeq_api.md
@@ -56,6 +56,10 @@ cdeq_X_value_t*     cdeq_X_at(cdeq_X* self, size_t idx);
 cdeq_X_value_t*     cdeq_X_front(cdeq_X* self);
 cdeq_X_value_t*     cdeq_X_back(cdeq_X* self);
 
+cdeq_X_iter_t       cdeq_X_find(const cdeq_X* self, RawValue raw);
+cdeq_X_iter_t       cdeq_X_find_in_range(const cdeq_X* self,
+                                         cdeq_X_iter_t first, cdeq_X_iter_t finish, RawValue raw);
+
 void                cdeq_X_push_n(cdeq_X *self, const cdeq_X_rawvalue_t arr[], size_t size);
 void                cdeq_X_push_front(cdeq_X* self, Value value);
 void                cdeq_X_push_back(cdeq_X* self, Value value);
@@ -64,24 +68,20 @@ void                cdeq_X_emplace_back(cdeq_X* self, RawValue raw);
 void                cdeq_X_pop_front(cdeq_X* self);
 void                cdeq_X_pop_back(cdeq_X* self);
 
-cdeq_X_iter_t       cdeq_X_emplace(cdeq_X* self, cdeq_X_iter_t pos, 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 pos, Value value);
-cdeq_X_iter_t       cdeq_X_insert_at(cdeq_X* self, size_t idx, Value value);
+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 first, cdeq_X_iter_t finish);
 cdeq_X_iter_t       cdeq_X_insert_range_p(cdeq_X* self, cdeq_X_value_t* pos,
                                           const cdeq_X_value_t* pfirst, const cdeq_X_value_t* pfinish);
 
-cdeq_X_iter_t       cdeq_X_erase(cdeq_X* self, cdeq_X_iter_t pos);
-cdeq_X_iter_t       cdeq_X_erase_n(cdeq_X* self, size_t idx, size_t n);
+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_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_find(const cdeq_X* self, RawValue raw);
-cdeq_X_iter_t       cdeq_X_find_in_range(const cdeq_X* self,
-                                         cdeq_X_iter_t first, cdeq_X_iter_t finish, RawValue raw);
-
 void                cdeq_X_sort(cdeq_X* self);
 void                cdeq_X_sort_with(cdeq_X* self, size_t ifirst, size_t ifinish,
                                      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 dd3a9a49..d693a052 100644
--- a/docs/clist_api.md
+++ b/docs/clist_api.md
@@ -78,8 +78,9 @@ clist_X_iter_t      clist_X_splice_back(clist_X* self, clist_X* other);
 clist_X             clist_X_splice_out(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_before(const clist_X* self,
-                                        clist_X_iter_t it1, clist_X_iter_t it2, RawValue raw);
+clist_X_iter_t      clist_X_find_before(const clist_X* self, RawValue raw);
+clist_X_iter_t      clist_X_find_before_in_range(const clist_X* self,
+                                                 clist_X_iter_t it1, clist_X_iter_t it2, RawValue raw);
 
                     // std: removes all elements equal to raw
 size_t              clist_X_remove(clist_X* self, RawValue raw);
diff --git a/docs/cmap_api.md b/docs/cmap_api.md
index 4a39e3ae..61441fb7 100644
--- a/docs/cmap_api.md
+++ b/docs/cmap_api.md
@@ -104,7 +104,7 @@ uint32_t            c_default_hash32(const void* data, size_t len);
 | `cmap_X_mapped_t`    | `Mapped`                                        | The mapped type               |
 | `cmap_X_value_t`     | `struct { Key first; Mapped second; }`          | The value type                |
 | `cmap_X_rawvalue_t`  | `struct { RawKey first; RawMapped second; }`    | RawKey + RawMapped type       |
-| `cmap_X_result_t`    | `struct { cmap_X_value_t first; bool second; }` | Result of insert/put/emplace  |
+| `cmap_X_result_t`    | `struct { cmap_X_value_t *first; bool second; }`| Result of insert/put/emplace  |
 | `cmap_X_iter_t`      | `struct { cmap_X_value_t *ref; ... }`           | Iterator type                 |
 
 `c_default_hash` requires Key to be 16-bit aligned, and size to be a multiple of 16. There is also a `c_default_hash32` which is slightly faster.
diff --git a/docs/cvec_api.md b/docs/cvec_api.md
index aeaf8ca7..7c523f02 100644
--- a/docs/cvec_api.md
+++ b/docs/cvec_api.md
@@ -65,17 +65,17 @@ void                cvec_X_emplace_back(cvec_X* self, RawValue raw);
 void                cvec_X_push_back(cvec_X* self, Value value);
 void                cvec_X_pop_back(cvec_X* self);
 
-cvec_X_iter_t       cvec_X_emplace(cvec_X* self, cvec_X_iter_t pos, RawValue raw);
-cvec_X_iter_t       cvec_X_emplace_at(cvec_X* self, size_t idx, RawValue raw);
-cvec_X_iter_t       cvec_X_insert(cvec_X* self, cvec_X_iter_t pos, Value value);
-cvec_X_iter_t       cvec_X_insert_at(cvec_X* self, size_t idx, Value value);
+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, 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_erase(cvec_X* self, cvec_X_iter_t pos);
-cvec_X_iter_t       cvec_X_erase_n(cvec_X* self, size_t idx, size_t n);
+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);
 
diff --git a/examples/demos.c b/examples/demos.c
index 46715b74..55de0c14 100644
--- a/examples/demos.c
+++ b/examples/demos.c
@@ -45,10 +45,10 @@ void vectordemo1()
         cvec_ix_push_back(&bignums, i * i);

 

     printf("erase - %d: %zu\n", 3, bignums.data[3]);

-    cvec_ix_erase_n(&bignums, 3, 1); // erase index 3

+    cvec_ix_erase(&bignums, 3, 1); // erase index 3

 

     cvec_ix_pop_back(&bignums);      // erase the last

-    cvec_ix_erase_n(&bignums, 0, 1); // erase the first

+    cvec_ix_erase(&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]);

diff --git a/stc/ccommon.h b/stc/ccommon.h
index a94d58a0..bd2700ab 100644
--- a/stc/ccommon.h
+++ b/stc/ccommon.h
@@ -81,7 +81,7 @@
 #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)      (0)

+#define c_no_compare(x, y)      (assert(!"c_no_compare"), 0)

 

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

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

diff --git a/stc/cdeq.h b/stc/cdeq.h
index 4b89b15c..29bb72fa 100644
--- a/stc/cdeq.h
+++ b/stc/cdeq.h
@@ -125,20 +125,20 @@
         return cdeq_##X##_insert_range_p(self, pos.ref, first.ref, finish.ref); \

     } \

     STC_INLINE cdeq_##X##_iter_t \

-    cdeq_##X##_insert(cdeq_##X* self, cdeq_##X##_iter_t pos, Value value) { \

+    cdeq_##X##_insert_at(cdeq_##X* self, cdeq_##X##_iter_t pos, Value value) { \

         return cdeq_##X##_insert_range_p(self, pos.ref, &value, &value + 1); \

     } \

     STC_INLINE cdeq_##X##_iter_t \

-    cdeq_##X##_insert_at(cdeq_##X* self, size_t idx, Value value) { \

+    cdeq_##X##_insert(cdeq_##X* self, size_t idx, Value value) { \

         return cdeq_##X##_insert_range_p(self, self->data + idx, &value, &value + 1); \

     } \

     STC_INLINE cdeq_##X##_iter_t \

-    cdeq_##X##_emplace(cdeq_##X* self, cdeq_##X##_iter_t pos, RawValue raw) { \

-        return cdeq_##X##_insert(self, pos, valueFromRaw(raw)); \

+    cdeq_##X##_emplace_at(cdeq_##X* self, cdeq_##X##_iter_t pos, RawValue raw) { \

+        return cdeq_##X##_insert_at(self, pos, valueFromRaw(raw)); \

     } \

     STC_INLINE cdeq_##X##_iter_t \

-    cdeq_##X##_emplace_at(cdeq_##X* self, size_t idx, RawValue raw) { \

-        return cdeq_##X##_insert_at(self, idx, valueFromRaw(raw)); \

+    cdeq_##X##_emplace(cdeq_##X* self, size_t idx, RawValue raw) { \

+        return cdeq_##X##_insert(self, idx, valueFromRaw(raw)); \

     } \

 \

     STC_API cdeq_##X##_iter_t \

@@ -153,7 +153,7 @@
         return cdeq_##X##_erase_range_p(self, pos.ref, pos.ref + 1); \

     } \

     STC_INLINE cdeq_##X##_iter_t \

-    cdeq_##X##_erase_n(cdeq_##X* self, size_t idx, size_t n) { \

+    cdeq_##X##_erase_at(cdeq_##X* self, size_t idx, size_t n) { \

         return cdeq_##X##_erase_range_p(self, self->data + idx, self->data + idx + n); \

     } \

 \

diff --git a/stc/clist.h b/stc/clist.h
index c9189ffa..e777ebc8 100644
--- a/stc/clist.h
+++ b/stc/clist.h
@@ -194,7 +194,9 @@ STC_API size_t _clist_size(const clist_void* self);
     } \

 \

     STC_API clist_##X##_iter_t \

-    clist_##X##_find_before(const clist_##X* self, clist_##X##_iter_t first, clist_##X##_iter_t finish, RawValue val); \

+    clist_##X##_find_before_in_range(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 \

     clist_##X##_find(const clist_##X* self, RawValue val); \

     STC_API size_t \

@@ -263,7 +265,7 @@ STC_API size_t _clist_size(const clist_void* self);
     } \

 \

     STC_DEF clist_##X##_iter_t \

-    clist_##X##_find_before(const clist_##X* self, clist_##X##_iter_t first, clist_##X##_iter_t finish, RawValue val) { \

+    clist_##X##_find_before_in_range(const clist_##X* self, clist_##X##_iter_t first, clist_##X##_iter_t finish, RawValue val) { \

         clist_##X##_iter_t i = first; \

         for (clist_##X##_next(&i); i.ref != finish.ref; clist_##X##_next(&i)) { \

             RawValue r = valueToRaw(i.ref); \

@@ -272,13 +274,18 @@ STC_API size_t _clist_size(const clist_void* self);
         } \

         return clist_##X##_end(self); \

     } \

-\

+    STC_DEF clist_##X##_iter_t \

+    clist_##X##_find_before(const clist_##X* self, RawValue val) { \

+        clist_##X##_iter_t it = clist_##X##_find_before_in_range(self, clist_##X##_before_begin(self), clist_##X##_end(self), val); \

+        return it; \

+    } \

     STC_DEF clist_##X##_iter_t \

     clist_##X##_find(const clist_##X* self, RawValue val) { \

-        clist_##X##_iter_t it = clist_##X##_find_before(self, clist_##X##_before_begin(self), clist_##X##_end(self), val); \

+        clist_##X##_iter_t it = clist_##X##_find_before_in_range(self, clist_##X##_before_begin(self), clist_##X##_end(self), val); \

         if (it.ref != clist_##X##_end(self).ref) clist_##X##_next(&it); \

         return it; \

     } \

+\

     STC_DEF clist_##X##_node_t* \

     _clist_##X##_erase_after(clist_##X* self, clist_##X##_node_t* node) { \

         clist_##X##_node_t* del = node->next, *next = del->next; \

diff --git a/stc/cvec.h b/stc/cvec.h
index d17876f1..edfd77e9 100644
--- a/stc/cvec.h
+++ b/stc/cvec.h
@@ -112,20 +112,20 @@
         return cvec_##X##_insert_range_p(self, pos.ref, first.ref, finish.ref); \

     } \

     STC_INLINE cvec_##X##_iter_t \

-    cvec_##X##_insert(cvec_##X* self, cvec_##X##_iter_t pos, Value value) { \

+    cvec_##X##_insert_at(cvec_##X* self, cvec_##X##_iter_t pos, Value value) { \

         return cvec_##X##_insert_range_p(self, pos.ref, &value, &value + 1); \

     } \

     STC_INLINE cvec_##X##_iter_t \

-    cvec_##X##_insert_at(cvec_##X* self, size_t idx, Value value) { \

+    cvec_##X##_insert(cvec_##X* self, size_t idx, Value value) { \

         return cvec_##X##_insert_range_p(self, self->data + idx, &value, &value + 1); \

     } \

     STC_INLINE cvec_##X##_iter_t \

-    cvec_##X##_emplace(cvec_##X* self, cvec_##X##_iter_t pos, RawValue raw) { \

-        return cvec_##X##_insert(self, pos, valueFromRaw(raw)); \

+    cvec_##X##_emplace_at(cvec_##X* self, cvec_##X##_iter_t pos, RawValue raw) { \

+        return cvec_##X##_insert_at(self, pos, valueFromRaw(raw)); \

     } \

     STC_INLINE cvec_##X##_iter_t \

-    cvec_##X##_emplace_at(cvec_##X* self, size_t idx, RawValue raw) { \

-        return cvec_##X##_insert_at(self, idx, valueFromRaw(raw)); \

+    cvec_##X##_emplace(cvec_##X* self, size_t idx, RawValue raw) { \

+        return cvec_##X##_insert(self, idx, valueFromRaw(raw)); \

     } \

 \

     STC_API cvec_##X##_iter_t \

@@ -136,11 +136,11 @@
         return cvec_##X##_erase_range_p(self, first.ref, finish.ref); \

     } \

     STC_INLINE cvec_##X##_iter_t \

-    cvec_##X##_erase(cvec_##X* self, cvec_##X##_iter_t pos) { \

+    cvec_##X##_erase_at(cvec_##X* self, cvec_##X##_iter_t pos) { \

         return cvec_##X##_erase_range_p(self, pos.ref, pos.ref + 1); \

     } \

     STC_INLINE cvec_##X##_iter_t \

-    cvec_##X##_erase_n(cvec_##X* self, size_t idx, size_t n) { \

+    cvec_##X##_erase(cvec_##X* self, size_t idx, size_t n) { \

         return cvec_##X##_erase_range_p(self, self->data + idx, self->data + idx + n); \

     } \

 \