cstr V4: Changed cstr functions to take pointers to self, not values. This is consistent with the rest of the containers. csview will still use values, as it is designed to be passed by value.

1 files changed, 28 insertions, 26 deletions

diff --git a/docs/cstr_api.md b/docs/cstr_api.md
index fffec64c..f5414f1b 100644
--- a/docs/cstr_api.md
+++ b/docs/cstr_api.md
@@ -30,16 +30,16 @@ cstr         cstr_clone(cstr s);
 
 cstr*        cstr_take(cstr* self, cstr s);                           // take ownership of s, i.e. don't drop s.
 cstr         cstr_move(cstr* self);                                   // move string to caller, leave self empty
-void         cstr_drop(cstr *self);                                   // destructor
+void         cstr_drop(cstr* self);                                   // destructor
 
 const char*  cstr_str(const cstr* self);                              // cast to const char*
 char*        cstr_data(cstr* self);                                   // cast to mutable char*
 csview       cstr_sv(const cstr* self);                               // cast to string view
 cstr_buf     cstr_buffer(cstr* self);                                 // cast to mutable buffer (with capacity)
 
-size_t       cstr_size(cstr s);
-size_t       cstr_capacity(cstr s);
-bool         cstr_empty(cstr s);
+size_t       cstr_size(const cstr* self);
+size_t       cstr_capacity(const cstr* self);
+bool         cstr_empty(const cstr* self);
 
 char*        cstr_reserve(cstr* self, size_t capacity);               // return pointer to buffer
 void         cstr_resize(cstr* self, size_t len, char fill);
@@ -57,7 +57,7 @@ char*        cstr_append(cstr* self, const char* str);
 char*        cstr_append_n(cstr* self, const char* str, size_t n);    // append n first bytes of str
 char*        cstr_append_sv(cstr* self, csview str);
 char*        cstr_append_s(cstr* self, cstr str);
-char*        cstr_append_uninit(cstr *self, size_t len);              // append len uninitialized bytes
+char*        cstr_append_uninit(cstr* self, size_t len);              // append len uninitialized bytes
 
 void         cstr_insert(cstr* self, size_t pos, const char* ins);
 void         cstr_insert_sv(cstr* self, size_t pos, csview ins);
@@ -72,19 +72,21 @@ void         cstr_replace_at(cstr* self, size_t pos, size_t len, const char* rep
 void         cstr_replace_at_sv(cstr* self, size_t pos, size_t len, const csview repl);
 void         cstr_replace_at_s(cstr* self, size_t pos, size_t len, cstr repl);
 
-bool         cstr_equals(cstr s, const char* str);
-bool         cstr_equals_s(cstr s, cstr s2);
-size_t       cstr_find(cstr s, const char* search);
-size_t       cstr_find_at(cstr s, size_t pos, const char* search);                           // search from pos
-bool         cstr_contains(cstr s, const char* search);
+bool         cstr_equals(const cstr* self, const char* str);
+bool         cstr_equals_s(const cstr* self, cstr s);
+bool         cstr_equals_sv(const cstr* self, csview sv);
 
-bool         cstr_starts_with(cstr s, const char* str);
-bool         cstr_starts_with_sv(cstr s, csview sv);
-bool         cstr_starts_with_s(cstr s, cstr s);
+size_t       cstr_find(const cstr* self, const char* search);
+size_t       cstr_find_at(const cstr* self, size_t pos, const char* search);                 // search from pos
+bool         cstr_contains(const cstr* self, const char* search);
 
-bool         cstr_ends_with(cstr s, const char* str);
-bool         cstr_ends_with_sv(cstr s, csview sv);
-bool         cstr_ends_with_s(cstr s, cstr s);
+bool         cstr_starts_with(const cstr* self, const char* str);
+bool         cstr_starts_with_sv(const cstr* self, csview sv);
+bool         cstr_starts_with_s(const cstr* self, cstr s);
+
+bool         cstr_ends_with(const cstr* self, const char* str);
+bool         cstr_ends_with_sv(const cstr* self, csview sv);
+bool         cstr_ends_with_s(const cstr* self, cstr s);
 
 bool         cstr_getline(cstr *self, FILE *stream);                  // cstr_getdelim(self, '\n', stream)
 bool         cstr_getdelim(cstr *self, int delim, FILE *stream);      // does not append delim to result
@@ -92,9 +94,9 @@ bool         cstr_getdelim(cstr *self, int delim, FILE *stream);      // does no
 
 #### UTF8 methods
 ```c
-size_t       cstr_u8_size(cstr s);                                    // number of utf8 codepoints
-size_t       cstr_u8_size_n(cstr s, size_t nbytes);                   // utf8 size within n bytes  
-size_t       cstr_u8_to_pos(cstr s, size_t u8idx);                    // byte pos offset at utf8 codepoint index
+size_t       cstr_u8_size(const cstr* self);                          // number of utf8 codepoints
+size_t       cstr_u8_size_n(const cstr self, size_t nbytes);          // utf8 size within n bytes  
+size_t       cstr_u8_to_pos(const cstr* self, size_t u8idx);          // byte pos offset at utf8 codepoint index
 const char*  cstr_u8_at(const cstr* self, size_t u8idx);              // char* position at utf8 codepoint index
 csview       cstr_u8_chr(const cstr* self, size_t u8idx);             // get utf8 character as a csview
 void         cstr_u8_replace_at(cstr* self, size_t u8pos, size_t u8len, csview repl); // replace at utf8 indices
@@ -117,18 +119,18 @@ cstr         cstr_toupper_sv(csview sv);                              // returns
 void         cstr_uppercase(cstr* self);                              // transform cstr to uppercase utf8
 
 int          cstr_icmp(const cstr* s1, const cstr* s2);               // utf8 case-insensitive comparison
-bool         cstr_iequals(cstr s, const char* str);                   //   "
-bool         cstr_istarts_with(cstr s, const char* str);              //   "
-bool         cstr_iends_with(cstr s, const char* str);                //   "
+bool         cstr_iequals(const cstr* self, const char* str);                   //   "
+bool         cstr_istarts_with(const cstr* self, const char* str);              //   "
+bool         cstr_iends_with(const cstr* self, const char* str);                //   "
 ```
 
 Note that all methods with arguments `(..., const char* str, size_t n)`, `n` must be within the range of `str` length.
 
 #### Helper methods:
 ```c
-int          cstr_cmp(const cstr *s1, const cstr *s2);
-bool         cstr_eq(const cstr *s1, const cstr *s2);
-bool         cstr_hash(const cstr *s);
+int          cstr_cmp(const cstr* s1, const cstr* s2);
+bool         cstr_eq(const cstr* s1, const cstr* s2);
+bool         cstr_hash(const cstr* self);
 
 char*        c_strnstrn(const char* str, const char* search, size_t slen, size_t nlen);
 ```
@@ -155,7 +157,7 @@ char*        c_strnstrn(const char* str, const char* search, size_t slen, size_t
 
 int main() {
     cstr s0 = cstr_new("Initialization without using strlen().");
-    printf("%s\nLength: %" PRIuMAX "\n\n", cstr_str(&s0), cstr_size(s0));
+    printf("%s\nLength: %" PRIuMAX "\n\n", cstr_str(&s0), cstr_size(&s0));
 
     cstr s1 = cstr_new("one-nine-three-seven-five.");
     printf("%s\n", cstr_str(&s1));