Fixed some doc errors in csmap and cmap. Added some inline funcs to cstr. Added read.c example.

7 files changed, 75 insertions, 20 deletions

diff --git a/examples/csmap_v1.h b/benchmarks/others/csmap_v1.h
index ec63c021..b81d7554 100644
--- a/examples/csmap_v1.h
+++ b/benchmarks/others/csmap_v1.h
@@ -385,11 +385,11 @@ int main(void) {
         while (it->level) { \

             up[top++] = it; \

             C##X##_rawkey_t r = keyToRaw(KEY_REF_##C(&it->value)); \

-            if ((c = keyCompareRaw(&r, rkey)) == 0) {res->first = &it->value; return tn;} \

+            if ((c = keyCompareRaw(&r, rkey)) == 0) {res->ref = &it->value; return tn;} \

             it = it->link[(dir = (c == -1))]; \

         } \

         tn = c_new_1(C##X##_node_t); \

-        res->first = &tn->value, res->second = true; \

+        res->ref = &tn->value, res->inserted = true; \

         tn->link[0] = tn->link[1] = (C##X##_node_t*) &aatree_nil, tn->level = 1; \

         if (top == 0) return tn; \

         up[top - 1]->link[dir] = tn; \

diff --git a/docs/cmap_api.md b/docs/cmap_api.md
index 0bbc76c7..9ae72e44 100644
--- a/docs/cmap_api.md
+++ b/docs/cmap_api.md
@@ -64,7 +64,7 @@ bool                cmap_X_contains(const cmap_X* self, RawKey rkey);
 
 cmap_X_result_t     cmap_X_insert(cmap_X* self, Key key, Mapped mapped);                     // no change if key in map
 cmap_X_result_t     cmap_X_insert_or_assign(cmap_X* self, Key key, Mapped mapped);           // always update mapped
-cmap_X_result_t     cmap_X_put(cmap_X* self, RawKey rkey, RawMapped rmapped);                // alias for insert_or_assign
+cmap_X_result_t     cmap_X_put(cmap_X* self, Key key, Mapped mapped);                        // alias for insert_or_assign
 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);
diff --git a/docs/csmap_api.md b/docs/csmap_api.md
index 72688c26..d314958e 100644
--- a/docs/csmap_api.md
+++ b/docs/csmap_api.md
@@ -60,7 +60,7 @@ bool                csmap_X_contains(const csmap_X* self, RawKey rkey);
 
 csmap_X_result_t    csmap_X_insert(csmap_X* self, Key key, Mapped mapped);                    // no change if key in map
 csmap_X_result_t    csmap_X_insert_or_assign(csmap_X* self, Key key, Mapped mapped);          // always update mapped
-csmap_X_result_t    csmap_X_put(csmap_X* self, RawKey rkey, RawMapped rmapped);               // alias for insert_or_assign
+csmap_X_result_t    csmap_X_put(csmap_X* self, Key key, Mapped mapped);                       // alias for insert_or_assign
 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);
diff --git a/docs/cstr_api.md b/docs/cstr_api.md
index 9f26187b..7a483370 100644
--- a/docs/cstr_api.md
+++ b/docs/cstr_api.md
@@ -23,6 +23,8 @@ cstr         cstr_from_n(const char* str, size_t n);
 cstr         cstr_from_fmt(const char* fmt, ...);                     // printf() formatting
 
 cstr         cstr_clone(cstr s);
+cstr*        cstr_take(cstr* self, cstr s);                           // take the constructed or moved string
+cstr         cstr_move(cstr* self);                                   // move string to caller, leave empty string
 void         cstr_del(cstr *self);                                    // destructor
 
 size_t       cstr_size(cstr s);
@@ -33,21 +35,24 @@ bool         cstr_empty(cstr s);
 size_t       cstr_reserve(cstr* self, size_t capacity);
 void         cstr_resize(cstr* self, size_t len, char fill);
 void         cstr_clear(cstr* self);
+
 cstr*        cstr_assign(cstr* self, const char* str);
+cstr*        cstr_assign_s(cstr* self, cstr s);
 cstr*        cstr_assign_n(cstr* self, const char* str, size_t n);
-cstr*        cstr_take(cstr* self, cstr s);                           // take the constructed or moved string
-cstr         cstr_move(cstr* self);                                   // move string to caller, leave empty string
 
 cstr*        cstr_append(cstr* self, const char* str);
+cstr*        cstr_append_s(cstr* self, cstr s);
 cstr*        cstr_append_n(cstr* self, const char* str, size_t n);  // appends len characters
-void         cstr_push_back(cstr* self, char ch);
-void         cstr_pop_back(cstr* self);
+
 void         cstr_insert(cstr* self, size_t pos, const char* str);
+void         cstr_insert_s(cstr* self, size_t pos, cstr s);
 void         cstr_insert_n(cstr* self, size_t pos, const char* str, size_t n);
-void         cstr_erase(cstr* self, size_t pos);
-void         cstr_erase_n(cstr* self, size_t pos, size_t n);
+
 void         cstr_replace(cstr* self, size_t pos, size_t len, const char* str);
+void         cstr_replace_s(cstr* self, size_t pos, size_t len, cstr s);
 void         cstr_replace_n(cstr* self, size_t pos, size_t len, const char* str, size_t n);
+void         cstr_erase(cstr* self, size_t pos);
+void         cstr_erase_n(cstr* self, size_t pos, size_t n);
 
 int          cstr_compare(const cstr *s1, const cstr *s2);
 bool         cstr_equals(cstr s, const char* str);
@@ -63,6 +68,8 @@ bool         cstr_ibegins_with(cstr s, const char* substr);
 bool         cstr_ends_with(cstr s, const char* substr);
 bool         cstr_iends_with(cstr s, const char* substr);
 
+void         cstr_push_back(cstr* self, char ch);
+void         cstr_pop_back(cstr* self);
 char*        cstr_front(cstr* self);
 char*        cstr_back(cstr* self);
 
diff --git a/examples/mapmap.c b/examples/mapmap.c
index e22ac80c..fc6c8a79 100644
--- a/examples/mapmap.c
+++ b/examples/mapmap.c
@@ -3,24 +3,26 @@
 #include <stc/cmap.h>

 #include <stc/cstr.h>

 

+// unordered_map<string, unordered_map<string, string>>: 

+

 using_cmap_str();

 using_cmap_strkey(cfg, cmap_str, cmap_str_del, c_no_clone);

 

 int main(void) {

-    cmap_cfg config = cmap_cfg_init();

+    cmap_cfg cfg = cmap_cfg_init();

     cmap_str init = cmap_str_init();

-    cmap_str_emplace(&cmap_cfg_insert(&config, cstr_from("user"), init).ref->second, "name", "Joe");

-    cmap_str_emplace(&cmap_cfg_insert(&config, cstr_from("user"), init).ref->second, "groups", "proj1,proj3");

-    cmap_str_emplace(&cmap_cfg_insert(&config, cstr_from("group"), init).ref->second, "proj1", "Energy");

-    cmap_str_emplace(&cmap_cfg_insert(&config, cstr_from("group"), init).ref->second, "proj2", "Windy");

-    cmap_str_emplace(&cmap_cfg_insert(&config, cstr_from("group"), init).ref->second, "proj3", "Oil");

-    cmap_str_emplace(&cmap_cfg_insert(&config, cstr_from("admin"), init).ref->second, "employees", "2302");

+    cmap_str_emplace(&cmap_cfg_insert(&cfg, cstr_from("user"), init).ref->second, "name", "Joe");

+    cmap_str_emplace(&cmap_cfg_insert(&cfg, cstr_from("user"), init).ref->second, "groups", "proj1,proj3");

+    cmap_str_emplace(&cmap_cfg_insert(&cfg, cstr_from("group"), init).ref->second, "proj1", "Energy");

+    cmap_str_emplace(&cmap_cfg_insert(&cfg, cstr_from("group"), init).ref->second, "proj2", "Windy");

+    cmap_str_emplace(&cmap_cfg_insert(&cfg, cstr_from("group"), init).ref->second, "proj3", "Oil");

+    cmap_str_emplace(&cmap_cfg_insert(&cfg, cstr_from("admin"), init).ref->second, "employees", "2302");

 

-    cmap_str_emplace_or_assign(&cmap_cfg_insert(&config, cstr_from("group"), init).ref->second, "proj2", "Wind"); // Update

+    cmap_str_emplace_or_assign(&cmap_cfg_insert(&cfg, cstr_from("group"), init).ref->second, "proj2", "Wind"); // Update

 

-    c_foreach (i, cmap_cfg, config)

+    c_foreach (i, cmap_cfg, cfg)

         c_foreach (j, cmap_str, i.ref->second)

             printf("%s: %s - %s (%u)\n", i.ref->first.str, j.ref->first.str, j.ref->second.str, i.ref->second.bucket_count);

 

-    cmap_cfg_del(&config);

+    cmap_cfg_del(&cfg);

 }
\ No newline at end of file
diff --git a/examples/read.c b/examples/read.c
new file mode 100644
index 00000000..b3ddcc00
--- /dev/null
+++ b/examples/read.c
@@ -0,0 +1,27 @@
+#include <errno.h>

+#include <stc/cstr.h>

+#include <stc/cvec.h>

+

+using_cvec_str();

+

+cvec_str read_file(const char* name) {

+    cvec_str vec = cvec_str_init();

+    c_withfile (f, fopen(name, "r")) {

+        cstr line = cstr_init();

+        while (cstr_getline(&line, f))

+            cvec_str_emplace_back(&vec, line.str);

+        cstr_del(&line);

+    }

+    return vec;

+}

+

+int main() {

+    cvec_str vec = read_file("read.c");

+    if (errno) printf("errno: %d\n", errno);

+

+    int n = 0;

+    c_foreach (i, cvec_str, vec)

+        printf("%5d: %s\n", ++n, i.ref->str);

+

+    cvec_str_del(&vec);

+}
\ No newline at end of file
diff --git a/stc/cstr.h b/stc/cstr.h
index b0267ae2..88fc71a4 100644
--- a/stc/cstr.h
+++ b/stc/cstr.h
@@ -116,6 +116,10 @@ STC_INLINE cstr_t*
 cstr_assign(cstr_t* self, const char* str) {

     return cstr_assign_n(self, str, strlen(str));

 }

+STC_INLINE cstr_t*

+cstr_assign_s(cstr_t* self, cstr s) {

+    return cstr_assign_n(self, s.str, _cstr_rep(&s)->size);

+}

 

 STC_INLINE cstr_t*

 cstr_take(cstr_t* self, cstr_t s) {

@@ -135,6 +139,11 @@ STC_INLINE cstr_t*
 cstr_append(cstr_t* self, const char* str) {

     return cstr_append_n(self, str, strlen(str));

 }

+STC_INLINE cstr_t*

+cstr_append_s(cstr_t* self, cstr s) {

+    return cstr_append_n(self, s.str, _cstr_rep(&s)->size);

+}

+

 STC_INLINE void

 cstr_push_back(cstr_t* self, char value) {

     cstr_append_n(self, &value, 1);

@@ -153,10 +162,20 @@ cstr_insert(cstr_t* self, size_t pos, const char* str) {
     cstr_replace_n(self, pos, 0, str, strlen(str));

 }

 STC_INLINE void

+cstr_insert_s(cstr_t* self, size_t pos, cstr s) {

+    cstr_replace_n(self, pos, 0, s.str, _cstr_rep(&s)->size);

+}

+

+STC_INLINE void

 cstr_replace(cstr_t* self, size_t pos, size_t len, const char* str) {

     cstr_replace_n(self, pos, len, str, strlen(str));

 }

 STC_INLINE void

+cstr_replace_s(cstr_t* self, size_t pos, size_t len, cstr s) {

+    cstr_replace_n(self, pos, len, s.str, _cstr_rep(&s)->size);

+}

+

+STC_INLINE void

 cstr_erase(cstr_t* self, size_t pos) {cstr_erase_n(self, pos, 1);}

 

 STC_INLINE bool