API: Reverted to C_X_erase_at() instead of C_X_erase_it(). Sorry for the mess. Internal reorder of STC_API methods.

7 files changed, 13 insertions, 13 deletions

diff --git a/docs/cdeq_api.md b/docs/cdeq_api.md
index d4de155b..cea4f571 100644
--- a/docs/cdeq_api.md
+++ b/docs/cdeq_api.md
@@ -66,7 +66,7 @@ cdeq_X_iter_t       cdeq_X_insert_at(cdeq_X* self, size_t idx, const Value arr[]
 cdeq_X_iter_t       cdeq_X_emplace(cdeq_X* self, cdeq_X_iter_t it, RawValue raw);
 void                cdeq_X_emplace_n(cdeq_X *self, const RawValue arr[], size_t n);          // emplace_back only
 
-cdeq_X_iter_t       cdeq_X_erase_it(cdeq_X* self, cdeq_X_iter_t it);
+cdeq_X_iter_t       cdeq_X_erase_at(cdeq_X* self, cdeq_X_iter_t it);
 cdeq_X_iter_t       cdeq_X_erase_range(cdeq_X* self, cdeq_X_iter_t it1, cdeq_X_iter_t it2);
 cdeq_X_iter_t       cdeq_X_erase_n(cdeq_X* self, size_t idx, size_t n);
 
diff --git a/docs/clist_api.md b/docs/clist_api.md
index 035c5dcf..5c59be8a 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_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.
+- `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.
 - 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
@@ -67,7 +67,7 @@ void                clist_X_emplace_n(clist_X *self, const clist_X_rawvalue_t ar
 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_it(clist_X* self, clist_X_iter_t it);                   // return iter after it
+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_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
 
@@ -138,7 +138,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_it()* and *erase_range()*:
+Use of *erase_at()* and *erase_range()*:
 ```c
 // erasing from clist
 #include <stc/clist.h>
@@ -152,7 +152,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_it(&L, it);               // 10 30 40 50
+    it = clist_i_erase_at(&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 2f056479..78aecfa9 100644
--- a/docs/cmap_api.md
+++ b/docs/cmap_api.md
@@ -10,7 +10,7 @@ hashing (aka open addressing) with linear probing, and without leaving tombstone
 ***Iterator invalidation***: References and iterators are invalidated after erase. No iterators are invalidated after insert,
 unless the hash-table need to be extended. The hash table size can be reserved prior to inserts if the total max size is known.
 The order of elements is preserved after erase and insert. This makes it possible to erase individual elements while iterating
-through the container by using the returned iterator from *erase_it()*, which references the next element.
+through the container by using the returned iterator from *erase_at()*, which references the next element.
 
 See the c++ class [std::unordered_map](https://en.cppreference.com/w/cpp/container/unordered_map) for a functional description.
 
@@ -75,7 +75,7 @@ cmap_X_result_t     cmap_X_emplace_or_assign(cmap_X* self, RawKey rkey, RawMappe
 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);                                 // return 0 or 1
-cmap_X_iter_t       cmap_X_erase_it(cmap_X* self, cmap_X_iter_t it);                         // return iter after it
+cmap_X_iter_t       cmap_X_erase_at(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/cset_api.md b/docs/cset_api.md
index f28c4714..a1265ee8 100644
--- a/docs/cset_api.md
+++ b/docs/cset_api.md
@@ -47,7 +47,7 @@ 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 n);

 

 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

+cset_X_iter_t       cset_X_erase_at(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 6aa341cd..5717c287 100644
--- a/docs/csmap_api.md
+++ b/docs/csmap_api.md
@@ -8,7 +8,7 @@ using the comparison function *keyCompare*. Search, removal, and insertion opera
 
 ***Iterator invalidation***: Iterators are invalidated after insert and erase. References are only invalidated
 after erase. It is possible to erase individual elements while iterating through the container by using the 
-returned iterator from *erase_it()*, which references the next element. Alternatively *erase_range()* can be used.
+returned iterator from *erase_at()*, which references the next element. Alternatively *erase_range()* can be used.
 
 See the c++ class [std::map](https://en.cppreference.com/w/cpp/container/map) for a functional description.
 
@@ -69,7 +69,7 @@ csmap_X_result_t    csmap_X_emplace_or_assign(csmap_X* self, RawKey rkey, RawMap
 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_it(csmap_X* self, csmap_X_iter_t it);                         // returns iter after it
+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_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/csset_api.md b/docs/csset_api.md
index 54a0ece9..500e38e4 100644
--- a/docs/csset_api.md
+++ b/docs/csset_api.md
@@ -44,7 +44,7 @@ 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 n);

 

 size_t              csset_X_erase(csset_X* self, RawKey rkey);

-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_at(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/cvec_api.md b/docs/cvec_api.md
index 2f084704..0171f3e7 100644
--- a/docs/cvec_api.md
+++ b/docs/cvec_api.md
@@ -65,7 +65,7 @@ cvec_X_iter_t       cvec_X_insert_at(cvec_X* self, size_t idx, const Value[] arr
 cvec_X_iter_t       cvec_X_emplace(cvec_X* self, cvec_X_iter_t it, RawValue raw);
 void                cvec_X_emplace_n(cvec_X *self, const RawValue arr[], size_t n);          // emplace_back only
 
-cvec_X_iter_t       cvec_X_erase_it(cvec_X* self, cvec_X_iter_t it);
+cvec_X_iter_t       cvec_X_erase_at(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);