Changed container_X_get() and container_X_at() to return const value* (or const mapped*). Added container_X_getmut() for mutable version. Updated docs.

19 files changed, 87 insertions, 61 deletions

diff --git a/benchmarks/cmap_benchmark.cpp b/benchmarks/cmap_benchmark.cpp
index dc104c2d..0dbe5a31 100644
--- a/benchmarks/cmap_benchmark.cpp
+++ b/benchmarks/cmap_benchmark.cpp
@@ -91,7 +91,7 @@ Sample test_stc_unordered_map() {
         stc64_srandom(seed);

         s.test[FIND].t1 = clock();

         size_t sum = 0;

-        cmap_x_value* val;

+        const cmap_x_value* val;

         c_forrange (N) 

             if ((val = cmap_x_get(&con, stc64_random() & mask1)))

                 sum += val->second;

diff --git a/benchmarks/csmap_benchmark.cpp b/benchmarks/csmap_benchmark.cpp
index bb055367..47762791 100644
--- a/benchmarks/csmap_benchmark.cpp
+++ b/benchmarks/csmap_benchmark.cpp
@@ -91,7 +91,7 @@ Sample test_stc_map() {
         stc64_srandom(seed);

         s.test[FIND].t1 = clock();

         size_t sum = 0;

-        csmap_x_value* val;

+        const csmap_x_value* val;

         c_forrange (N) 

             if ((val = csmap_x_get(&con, stc64_random() & mask1)))

                 sum += val->second;

diff --git a/benchmarks/rust_cmap.c b/benchmarks/rust_cmap.c
index 6014b23d..88dfbec1 100644
--- a/benchmarks/rust_cmap.c
+++ b/benchmarks/rust_cmap.c
@@ -27,7 +27,6 @@ int main() {
         c_forrange (n) {

             uint64_t key = romu_trio(rng) & mask;

             cmap_u64_insert(&m, key, 0).ref->second += 1;

-            

         }

         printf("insert  : %zums  \tsize : %zu\n", (clock() - now)/ms, cmap_u64_size(m));

         now = clock();

diff --git a/benchmarks/shootout3_csmap.cpp b/benchmarks/shootout3_csmap.cpp
index dfa0ab1b..7a0addad 100644
--- a/benchmarks/shootout3_csmap.cpp
+++ b/benchmarks/shootout3_csmap.cpp
@@ -179,7 +179,7 @@ static void ins_and_access_csmap_i(picobench::state& s)
     picobench::scope scope(s);

     c_forrange (s.iterations()) {

         result += ++csmap_i_emplace(&map, stc64_random() & mask, 0).ref->second;

-        csmap_i_value* val = csmap_i_get(&map, stc64_random() & mask);

+        const csmap_i_value* val = csmap_i_get(&map, stc64_random() & mask);

         if (val) csmap_i_erase(&map, val->first);

     }

     s.set_result(result + csmap_i_size(map));

diff --git a/docs/cdeq_api.md b/docs/cdeq_api.md
index ab0a1b12..0e83024b 100644
--- a/docs/cdeq_api.md
+++ b/docs/cdeq_api.md
@@ -28,17 +28,21 @@ cdeq_X              cdeq_X_clone(cdeq_X deq);
 
 void                cdeq_X_clear(cdeq_X* self);
 void                cdeq_X_copy(cdeq_X* self, cdeq_X other);
-void                cdeq_X_shrink_to_fit(cdeq_X* self);
 void                cdeq_X_reserve(cdeq_X* self, size_t cap);
+void                cdeq_X_shrink_to_fit(cdeq_X* self);
 void                cdeq_X_swap(cdeq_X* a, cdeq_X* b);
-
-void                cdeq_X_del(cdeq_X* self);      // destructor
+void                cdeq_X_del(cdeq_X* self);                                                    // destructor
 
 bool                cdeq_X_empty(cdeq_X deq);
 size_t              cdeq_X_size(cdeq_X deq);
 size_t              cdeq_X_capacity(cdeq_X deq);
 
-cdeq_X_value*       cdeq_X_at(const cdeq_X* self, size_t idx);
+const cdeq_X_value* cdeq_X_at(const cdeq_X* self, size_t idx);
+const cdeq_X_value* cdeq_X_get(const cdeq_X* self, i_valraw raw);                                 // return NULL if not found
+cdeq_X_value*       cdeq_X_mutget(cdeq_X* self, i_valraw raw);                                    // mutable get
+cdeq_X_iter         cdeq_X_find(const cdeq_X* self, i_valraw raw);
+cdeq_X_iter         cdeq_X_find_in(cdeq_X_iter i1, cdeq_X_iter i2, i_valraw raw);
+
 cdeq_X_value*       cdeq_X_front(const cdeq_X* self);
 cdeq_X_value*       cdeq_X_back(const cdeq_X* self);
 
@@ -52,13 +56,13 @@ void                cdeq_X_pop_back(cdeq_X* self);
 
 cdeq_X_iter         cdeq_X_insert(cdeq_X* self, size_t idx, i_val value);                        // move value 
 cdeq_X_iter         cdeq_X_insert_n(cdeq_X* self, size_t idx, const i_val[] arr, size_t n);      // move arr values
-cdeq_X_iter         cdeq_X_insert_at(cdeq_X* self, cdeq_X_iter it, i_val value);               // move value 
+cdeq_X_iter         cdeq_X_insert_at(cdeq_X* self, cdeq_X_iter it, i_val value);                 // move value 
 
 cdeq_X_iter         cdeq_X_emplace(cdeq_X* self, size_t idx, i_valraw raw);
 cdeq_X_iter         cdeq_X_emplace_n(cdeq_X* self, size_t idx, const i_valraw[] arr, size_t n);
 cdeq_X_iter         cdeq_X_emplace_at(cdeq_X* self, cdeq_X_iter it, i_valraw raw);
 cdeq_X_iter         cdeq_X_emplace_range(cdeq_X* self, cdeq_X_iter it, 
-                                         cdeq_X_iter it1, cdeq_X_iter it2);                 // will clone
+                                         cdeq_X_iter it1, cdeq_X_iter it2);                      // will clone
 cdeq_X_iter         cdeq_X_emplace_range_p(cdeq_X* self, i_val* pos, 
                                            const i_val* p1, const i_val* p2);
 
@@ -66,10 +70,6 @@ cdeq_X_iter         cdeq_X_erase_n(cdeq_X* self, size_t idx, size_t n);
 cdeq_X_iter         cdeq_X_erase_at(cdeq_X* self, cdeq_X_iter it);
 cdeq_X_iter         cdeq_X_erase_range(cdeq_X* self, cdeq_X_iter it1, cdeq_X_iter it2);
 
-cdeq_X_iter         cdeq_X_find(const cdeq_X* self, i_valraw raw);
-cdeq_X_iter         cdeq_X_find_in(cdeq_X_iter i1, cdeq_X_iter i2, i_valraw raw);
-cdeq_X_value*       cdeq_X_get(const cdeq_X* self, i_valraw raw);                            // returns NULL if not found
-
 void                cdeq_X_sort(cdeq_X* self);
 void                cdeq_X_sort_range(cdeq_X_iter i1, cdeq_X_iter i2,
                                       int(*cmp)(const i_val*, const i_val*));
diff --git a/docs/cmap_api.md b/docs/cmap_api.md
index 9bdafcb9..0e677880 100644
--- a/docs/cmap_api.md
+++ b/docs/cmap_api.md
@@ -49,15 +49,16 @@ void                cmap_X_shrink_to_fit(cmap_X* self);
 void                cmap_X_swap(cmap_X* a, cmap_X* b);
 void                cmap_X_del(cmap_X* self);                                                 // destructor
 
-bool                cmap_X_empty(cmap_X map);
 size_t              cmap_X_size(cmap_X map);
 size_t              cmap_X_capacity(cmap_X map);                                              // buckets * max_load_factor
+bool                cmap_X_empty(cmap_X map);
 size_t              cmap_X_bucket_count(cmap_X map);                                          // num. of allocated buckets
 
-bool                cmap_X_contains(const cmap_X* self, i_keyraw rkey);
-cmap_X_mapped*      cmap_X_at(const cmap_X* self, i_keyraw rkey);                             // rkey must be in map.
-cmap_X_value*       cmap_X_get(const cmap_X* self, i_keyraw rkey);                            // return NULL if not found
-cmap_X_iter         cmap_X_find(const cmap_X* self, i_keyraw rkey);
+const cmap_X_mapped* cmap_X_at(const cmap_X* self, i_keyraw rkey);                            // rkey must be in map.
+const cmap_X_value*  cmap_X_get(const cmap_X* self, i_keyraw rkey);                           // const get
+cmap_X_value*        cmap_X_mutget(cmap_X* self, i_keyraw rkey);                              // mutable get
+bool                 cmap_X_contains(const cmap_X* self, i_keyraw rkey);
+cmap_X_iter          cmap_X_find(const cmap_X* self, i_keyraw rkey);                          // find element
 
 cmap_X_result       cmap_X_insert(cmap_X* self, i_key key, i_val mapped);                     // no change if key in map
 cmap_X_result       cmap_X_insert_or_assign(cmap_X* self, i_key key, i_val mapped);           // always update mapped
diff --git a/docs/cset_api.md b/docs/cset_api.md
index 04a1617f..4ca7ab7c 100644
--- a/docs/cset_api.md
+++ b/docs/cset_api.md
@@ -35,13 +35,14 @@ void                cset_X_shrink_to_fit(cset_X* self);
 void                cset_X_swap(cset_X* a, cset_X* b);

 void                cset_X_del(cset_X* self);                                                // destructor

 

-bool                cset_X_empty(cset_X set);

 size_t              cset_X_size(cset_X set);                                                 // num. of allocated buckets

 size_t              cset_X_capacity(cset_X set);                                             // buckets * max_load_factor

+bool                cset_X_empty(cset_X set);

 size_t              cset_X_bucket_count(cset_X set);

 

 bool                cset_X_contains(const cset_X* self, i_keyraw rkey);

-cset_X_value*       cset_X_get(const cset_X* self, i_keyraw rkey);                           // return NULL if not found

+const cset_X_value* cset_X_get(const cset_X* self, i_keyraw rkey);                           // return NULL if not found

+cset_X_value*       cset_X_mutget(cset_X* self, i_keyraw rkey);                              // mutable get

 cset_X_iter         cset_X_find(const cset_X* self, i_keyraw rkey);

 

 cset_X_result       cset_X_insert(cset_X* self, i_key key);

diff --git a/docs/csmap_api.md b/docs/csmap_api.md
index 7a528c7b..176ebad6 100644
--- a/docs/csmap_api.md
+++ b/docs/csmap_api.md
@@ -42,15 +42,19 @@ void                csmap_X_copy(csmap_X* self, csmap_X other);
 void                csmap_X_swap(csmap_X* a, csmap_X* b);
 void                csmap_X_del(csmap_X* self);                                                  // destructor
 
-bool                csmap_X_empty(csmap_X map);
 size_t              csmap_X_size(csmap_X map);
+bool                csmap_X_empty(csmap_X map);
+
+const csmap_X_mapped* csmap_X_at(const csmap_X* self, i_keyraw rkey);                            // rkey must be in map.
+const csmap_X_value*  csmap_X_get(const csmap_X* self, i_keyraw rkey);                           // return NULL if not found
+csmap_X_value*        csmap_X_mutget(csmap_X* self, i_keyraw rkey);                              // mutable get
+bool                  csmap_X_contains(const csmap_X* self, i_keyraw rkey);
+csmap_X_iter          csmap_X_find(const csmap_X* self, i_keyraw rkey);
+csmap_X_value*        csmap_X_find_it(const csmap_X* self, i_keyraw rkey, csmap_X_iter* out);    // return NULL if not found
+csmap_X_iter          csmap_X_lower_bound(const csmap_X* self, i_keyraw rkey);                   // find closest entry >= rkey
 
-bool                csmap_X_contains(const csmap_X* self, i_keyraw rkey);
-csmap_X_mapped*     csmap_X_at(const csmap_X* self, i_keyraw rkey);                              // rkey must be in map.
-csmap_X_value*      csmap_X_get(const csmap_X* self, i_keyraw rkey);                             // return NULL if not found
-csmap_X_iter        csmap_X_lower_bound(const csmap_X* self, i_keyraw rkey);                     // find closest entry >= rkey
-csmap_X_iter        csmap_X_find(const csmap_X* self, i_keyraw rkey);
-csmap_X_value*      csmap_X_find_it(const csmap_X* self, i_keyraw rkey, csmap_X_iter* out);      // return NULL if not found
+csmap_X_value*      csmap_X_front(const csmap_X* self);
+csmap_X_value*      csmap_X_back(const csmap_X* self);
 
 csmap_X_result      csmap_X_insert(csmap_X* self, i_key key, i_val mapped);                      // no change if key in map
 csmap_X_result      csmap_X_insert_or_assign(csmap_X* self, i_key key, i_val mapped);            // always update mapped
diff --git a/docs/csset_api.md b/docs/csset_api.md
index 41e0063f..451d52c9 100644
--- a/docs/csset_api.md
+++ b/docs/csset_api.md
@@ -30,14 +30,15 @@ void                csset_X_copy(csset_X* self, csset_X other);
 void                csset_X_swap(csset_X* a, csset_X* b);

 void                csset_X_del(csset_X* self);                                               // destructor

 

-bool                csset_X_empty(csset_X set);

 size_t              csset_X_size(csset_X set);

+bool                csset_X_empty(csset_X set);

 

-bool                csset_X_contains(const csset_X* self, i_keyraw rkey);

-csset_X_value*      csset_X_get(const csset_X* self, i_keyraw rkey);                          // return NULL if not found

-csset_X_iter        csset_X_lower_bound(const csset_X* self, i_keyraw rkey);                  // find closest entry >= rkey

-csset_X_iter        csset_X_find(const csset_X* self, i_keyraw rkey);

-csset_X_value*      csset_X_find_it(const csset_X* self, i_keyraw rkey, csset_X_iter* out);   // return NULL if not found

+const csset_X_value* csset_X_get(const csset_X* self, i_keyraw rkey);                         // const get

+csset_X_value*       csset_X_mutget(csset_X* self, i_keyraw rkey);                            // return NULL if not found

+bool                 csset_X_contains(const csset_X* self, i_keyraw rkey);

+csset_X_iter         csset_X_find(const csset_X* self, i_keyraw rkey);

+csset_X_value*       csset_X_find_it(const csset_X* self, i_keyraw rkey, csset_X_iter* out);  // return NULL if not found

+csset_X_iter         csset_X_lower_bound(const csset_X* self, i_keyraw rkey);                 // find closest entry >= rkey

 

 csset_X_result      csset_X_insert(csset_X* self, i_key key);

 csset_X_result      csset_X_emplace(csset_X* self, i_keyraw rkey);

diff --git a/docs/cstack_api.md b/docs/cstack_api.md
index a1edf9ea..25cbcfb7 100644
--- a/docs/cstack_api.md
+++ b/docs/cstack_api.md
@@ -36,8 +36,9 @@ void                cstack_X_del(cstack_X* self);       // destructor
 size_t              cstack_X_size(cstack_X st);
 size_t              cstack_X_capacity(cstack_X st);
 bool                cstack_X_empty(cstack_X st);
-cstack_X_value*     cstack_X_top(const cstack_X* self);
-cstack_X_value*     cstack_X_at(const cstack_X* self, size_t idx);
+
+cstack_X_value*       cstack_X_top(const cstack_X* self);
+const cstack_X_value* cstack_X_at(const cstack_X* self, size_t idx);
 
 cstack_X_value*     cstack_X_push(cstack_X* self, i_val value);
 cstack_X_value*     cstack_X_emplace(cstack_X* self, i_valraw raw);
diff --git a/docs/cvec_api.md b/docs/cvec_api.md
index 42ec944e..db119c14 100644
--- a/docs/cvec_api.md
+++ b/docs/cvec_api.md
@@ -35,9 +35,9 @@ cvec_X              cvec_X_clone(cvec_X vec);
 
 void                cvec_X_clear(cvec_X* self);
 void                cvec_X_copy(cvec_X* self, cvec_X other);
-void                cvec_X_shrink_to_fit(cvec_X* self);
 void                cvec_X_reserve(cvec_X* self, size_t cap);
 void                cvec_X_resize(cvec_X* self, size_t size, i_val fill);
+void                cvec_X_shrink_to_fit(cvec_X* self);
 void                cvec_X_swap(cvec_X* a, cvec_X* b);
 void                cvec_X_del(cvec_X* self);                                                // destructor
 
@@ -45,7 +45,14 @@ bool                cvec_X_empty(cvec_X vec);
 size_t              cvec_X_size(cvec_X vec);
 size_t              cvec_X_capacity(cvec_X vec);
 
-cvec_X_value*       cvec_X_at(const cvec_X* self, size_t idx);
+const cvec_X_value* cvec_X_at(const cvec_X* self, size_t idx);
+const cvec_X_value* cvec_X_get(const cvec_X* self, i_valraw raw);                            // return NULL if not found
+cvec_X_value*       cvec_X_mutget(cvec_X* self, i_valraw raw);                               // mutable get
+cvec_X_iter         cvec_X_find(const cvec_X* self, i_valraw raw);
+cvec_X_iter         cvec_X_find_in(cvec_X_iter i1, cvec_X_iter i2, i_valraw raw);
+cvec_X_iter         cvec_X_bsearch(const cvec_X* self, i_valraw raw);
+cvec_X_iter         cvec_X_bsearch_in(cvec_X_iter i1, cvec_X_iter i2, i_valraw raw);
+
 cvec_X_value*       cvec_X_front(const cvec_X* self);
 cvec_X_value*       cvec_X_back(const cvec_X* self);
 
@@ -69,12 +76,6 @@ cvec_X_iter         cvec_X_erase_n(cvec_X* self, size_t idx, size_t n);
 cvec_X_iter         cvec_X_erase_at(cvec_X* self, cvec_X_iter it);
 cvec_X_iter         cvec_X_erase_range(cvec_X* self, cvec_X_iter it1, cvec_X_iter it2);
 
-cvec_X_iter         cvec_X_find(const cvec_X* self, i_valraw raw);
-cvec_X_iter         cvec_X_find_in(cvec_X_iter i1, cvec_X_iter i2, i_valraw raw);
-cvec_X_value*       cvec_X_get(const cvec_X* self, i_valraw raw);                            // return NULL if not found
-cvec_X_iter         cvec_X_bsearch(const cvec_X* self, i_valraw raw);
-cvec_X_iter         cvec_X_bsearch_in(cvec_X_iter i1, cvec_X_iter i2, i_valraw raw);
-
 void                cvec_X_sort(cvec_X* self);
 void                cvec_X_sort_range(cvec_X_iter i1, cvec_X_iter i2,
                                       int(*cmp)(const i_val*, const i_val*));
diff --git a/examples/astar.c b/examples/astar.c
index 04c18113..7410de96 100644
--- a/examples/astar.c
+++ b/examples/astar.c
@@ -107,7 +107,7 @@ astar(cstr* maze, int width)
                 int new_cost = *csmap_pcost_at(&costs, current);

                 if (maze->str[point_index(&next)] != '#')

                 {

-                    csmap_pcost_value *cost = csmap_pcost_get(&costs, next);

+                    const csmap_pcost_value *cost = csmap_pcost_get(&costs, next);

                     if (cost == NULL || new_cost < cost->second)

                     {

                         csmap_pcost_insert(&costs, next, new_cost);

diff --git a/examples/mapmap.c b/examples/mapmap.c
index 047132d1..73a00861 100644
--- a/examples/mapmap.c
+++ b/examples/mapmap.c
@@ -19,7 +19,7 @@ void add(csmap_conf* map, const char* section, const char* entry, const char* va
 

 bool contains(csmap_conf* map, const char* section, const char* entry)

 {

-    csmap_conf_value *val = csmap_conf_get(map, section);

+    const csmap_conf_value *val = csmap_conf_get(map, section);

     return val && csmap_sect_get(&val->second, entry);

 }

 

diff --git a/examples/stack.c b/examples/stack.c
index 54d5aeed..dac0112e 100644
--- a/examples/stack.c
+++ b/examples/stack.c
@@ -11,9 +11,8 @@
 #include <stc/cstack.h>

 

 int main() {

-    cstack_i stack = cstack_i_init();

-    cstack_c chars = cstack_c_init();

-    c_autodefer (cstack_i_del(&stack), cstack_c_del(&chars))

+    c_auto (cstack_i, stack)

+    c_auto (cstack_c, chars)

     {

         c_forrange (i, int, 101)

             cstack_i_push(&stack, i*i);

diff --git a/include/stc/cdeq.h b/include/stc/cdeq.h
index ab454247..2cdedcd8 100644
--- a/include/stc/cdeq.h
+++ b/include/stc/cdeq.h
@@ -112,7 +112,7 @@ STC_INLINE void _cx_memb(_pop_back)(_cx_self* self) {
     i_valdel(p);

 }

 

-STC_INLINE _cx_value* _cx_memb(_at)(const _cx_self* self, size_t idx) {

+STC_INLINE const _cx_value* _cx_memb(_at)(const _cx_self* self, size_t idx) {

     assert(idx < cdeq_rep_(self)->size); 

     return self->data + idx;

 }

@@ -175,13 +175,17 @@ _cx_memb(_find)(const _cx_self* self, i_valraw raw) {
     return _cx_memb(_find_in)(_cx_memb(_begin)(self), _cx_memb(_end)(self), raw);

 }

 

-STC_INLINE _cx_value*

+STC_INLINE const _cx_value*

 _cx_memb(_get)(const _cx_self* self, i_valraw raw) {

     _cx_iter end = _cx_memb(_end)(self);

     _cx_value* val = _cx_memb(_find_in)(_cx_memb(_begin)(self), end, raw).ref;

     return val == end.ref ? NULL : val;

 }

 

+STC_INLINE _cx_value*

+_cx_memb(_mutget)(_cx_self* self, i_valraw raw)

+    { return (_cx_value *) _cx_memb(_get)(self, raw); }

+

 STC_INLINE void

 _cx_memb(_sort_range)(_cx_iter i1, _cx_iter i2,

                 int(*_cmp_)(const _cx_value*, const _cx_value*)) {

diff --git a/include/stc/clist.h b/include/stc/clist.h
index a97c9526..5ae56634 100644
--- a/include/stc/clist.h
+++ b/include/stc/clist.h
@@ -166,11 +166,16 @@ _cx_memb(_find)(const _cx_self* self, i_valraw val) {
     return _cx_memb(_find_in)(_cx_memb(_begin)(self), _cx_memb(_end)(self), val);

 }

 

-STC_INLINE _cx_value*

+STC_INLINE const _cx_value*

 _cx_memb(_get)(const _cx_self* self, i_valraw val) {

     return _cx_memb(_find_in)(_cx_memb(_begin)(self), _cx_memb(_end)(self), val).ref;

 }

 

+STC_INLINE _cx_value*

+_cx_memb(_mutget)(_cx_self* self, i_valraw val) {

+    return _cx_memb(_find_in)(_cx_memb(_begin)(self), _cx_memb(_end)(self), val).ref;

+}

+

 // -------------------------- IMPLEMENTATION -------------------------

 

 #if !defined(STC_HEADER) || defined(STC_IMPLEMENTATION) || defined(i_imp)

diff --git a/include/stc/cmap.h b/include/stc/cmap.h
index 0c5aab4e..cccf3199 100644
--- a/include/stc/cmap.h
+++ b/include/stc/cmap.h
@@ -117,7 +117,7 @@ cx_MAP_ONLY(
         return _cx_memb(_insert_or_assign)(self, key, mapped);

     }

 

-    STC_INLINE _cx_mapped*

+    STC_INLINE const _cx_mapped*

     _cx_memb(_at)(const _cx_self* self, i_keyraw rkey) {

         chash_bucket_t b = _cx_memb(_bucket_)(self, &rkey);

         assert(self->_hashx[b.idx]);

@@ -169,13 +169,17 @@ _cx_memb(_find)(const _cx_self* self, i_keyraw rkey) {
     return c_make(_cx_iter){self->table+idx, self->_hashx+idx};

 }

 

-STC_INLINE _cx_value*

+STC_INLINE const _cx_value*

 _cx_memb(_get)(const _cx_self* self, i_keyraw rkey) {

     _cx_size idx;

     return self->size && self->_hashx[idx = _cx_memb(_bucket_)(self, &rkey).idx] ?

            self->table + idx : NULL;

 }

 

+STC_INLINE _cx_value*

+_cx_memb(_mutget)(const _cx_self* self, i_keyraw rkey)

+    { return (_cx_value*) _cx_memb(_get)(self, rkey); }

+

 STC_INLINE _cx_iter

 _cx_memb(_begin)(const _cx_self* self) {

     _cx_iter it = {self->table, self->_hashx};

diff --git a/include/stc/csmap.h b/include/stc/csmap.h
index 3319d435..4eedb60d 100644
--- a/include/stc/csmap.h
+++ b/include/stc/csmap.h
@@ -114,7 +114,9 @@ STC_INLINE void         _cx_memb(_clear)(_cx_self* self) { _cx_memb(_del)(self);
 STC_INLINE void         _cx_memb(_swap)(_cx_self* a, _cx_self* b) { c_swap(_cx_self, *a, *b); }

 STC_INLINE bool         _cx_memb(_contains)(const _cx_self* self, i_keyraw rkey)

                             { _cx_iter it; return _cx_memb(_find_it)(self, rkey, &it) != NULL; }

-STC_INLINE _cx_value*   _cx_memb(_get)(const _cx_self* self, i_keyraw rkey)

+STC_INLINE const _cx_value* _cx_memb(_get)(const _cx_self* self, i_keyraw rkey)

+                            { _cx_iter it; return _cx_memb(_find_it)(self, rkey, &it); }

+STC_INLINE _cx_value*   _cx_memb(_mutget)(_cx_self* self, i_keyraw rkey)

                             { _cx_iter it; return _cx_memb(_find_it)(self, rkey, &it); }

 

 STC_INLINE _cx_self

@@ -156,7 +158,7 @@ cx_MAP_ONLY(
     _cx_memb(_put)(_cx_self* self, i_key key, i_val mapped)

         { return _cx_memb(_insert_or_assign)(self, key, mapped); }

 

-    STC_INLINE _cx_mapped*

+    STC_INLINE const _cx_mapped*

     _cx_memb(_at)(const _cx_self* self, i_keyraw rkey)

         { _cx_iter it; return &_cx_memb(_find_it)(self, rkey, &it)->second; }

 )

diff --git a/include/stc/cvec.h b/include/stc/cvec.h
index 92c8f5bd..2e1dcd6e 100644
--- a/include/stc/cvec.h
+++ b/include/stc/cvec.h
@@ -186,7 +186,7 @@ _cx_memb(_erase_range)(_cx_self* self, _cx_iter it1, _cx_iter it2) {
     return _cx_memb(_erase_range_p)(self, it1.ref, it2.ref);

 }

 

-STC_INLINE _cx_value*

+STC_INLINE const _cx_value*

 _cx_memb(_at)(const _cx_self* self, size_t idx) {

     assert(idx < cvec_rep_(self)->size);

     return self->data + idx;

@@ -197,17 +197,21 @@ _cx_memb(_find)(const _cx_self* self, i_valraw raw) {
     return _cx_memb(_find_in)(_cx_memb(_begin)(self), _cx_memb(_end)(self), raw);

 }

 

-STC_INLINE _cx_value*

+STC_INLINE const _cx_value*

 _cx_memb(_get)(const _cx_self* self, i_valraw raw) {

     _cx_iter end = _cx_memb(_end)(self);

     _cx_value* val = _cx_memb(_find_in)(_cx_memb(_begin)(self), end, raw).ref;

     return val == end.ref ? NULL : val;

 }

 

+STC_INLINE _cx_value*

+_cx_memb(_mutget)(const _cx_self* self, i_valraw raw)

+    { return (_cx_value*) _cx_memb(_get)(self, raw); }

+

 STC_INLINE _cx_iter

-_cx_memb(_bsearch)(const _cx_self* self, i_valraw raw) {

-    return _cx_memb(_bsearch_in)(_cx_memb(_begin)(self), _cx_memb(_end)(self), raw);

-}

+_cx_memb(_bsearch)(const _cx_self* self, i_valraw raw)

+    { return _cx_memb(_bsearch_in)(_cx_memb(_begin)(self), _cx_memb(_end)(self), raw); }

+

 STC_INLINE void

 _cx_memb(_sort_range)(_cx_iter i1, _cx_iter i2,

                      int(*_cmp_)(const _cx_value*, const _cx_value*)) {