new StringBuilder functions

include/tlibc/collections/Array.h

@@ -27,9 +27,10 @@ static inline void Array_realloc_size(Array_* ar, u32 new_size){
     ar->size = new_size;
 }
 
-static inline Array_ Array_copy(Array_ src){
+static inline Array_ Array_copy(const Array_ src){
     Array_ copy = Array_alloc_size(src.size);
-    memcpy(copy.data, src.data, src.size);
+    if(copy.data != NULL)
+        memcpy(copy.data, src.data, src.size);
     return copy;
 }
 
@@ -39,11 +40,11 @@ static inline Array_ Array_copy(Array_ src){
 #define struct_castTo_Array(STRUCT_PTR) Array_construct_size((STRUCT_PTR), sizeof(*STRUCT_PTR))
 
 ///@return a[0..i-1]
-static inline Array(u8) Array_sliceTo(Array(u8) a, u32 i){
+static inline Array(u8) Array_sliceTo(const Array(u8) a, u32 i){
     return Array_construct_size(a.data, i);
 }
 
 ///@return a[i...]
-static inline Array(u8) Array_sliceFrom(Array(u8) a, u32 i){
+static inline Array(u8) Array_sliceFrom(const Array(u8) a, u32 i){
     return Array_construct_size((u8*)a.data + i, a.size - i);
 }

include/tlibc/collections/List.h

@@ -19,7 +19,9 @@ static inline List_ List_construct_size(void* data_ptr, u32 occupied_size, u32 a
 #define List_alloc(T, INITIAL_COUNT) List_alloc_size((INITIAL_COUNT) * sizeof(T))
 List_ List_alloc_size(u32 initial_size);
 
-void* List_expand_size(List_* ptr, u32 expansion_size);
+List_ List_copy(List_ src);
+
+void* List_expand_size(List_* ptr, u32 size_to_add);
 #define List_push(L, T, VALUE) *(T*)(List_expand_size(L, sizeof(T))) = VALUE
 #define List_pushMany(L, T, VALUES_PTR, COUNT) List_push_size(L, VALUES_PTR, (COUNT) * sizeof(T))
 void List_push_size(List_* ptr, void* values, u32 size);

include/tlibc/string/StringBuilder.h

@@ -13,6 +13,14 @@ static inline StringBuilder StringBuilder_alloc(u32 initial_size) {
 }
 void StringBuilder_destroy(StringBuilder* b);
 
+static inline StringBuilder StringBuilder_copy(const StringBuilder* b){
+    return (StringBuilder) { .buffer = List_copy(b->buffer) };
+}
+static inline void StringBuilder_expand(StringBuilder* b, u32 size_to_add){
+    List_expand_size(&b->buffer, size_to_add);
+}
+
+
 /// @param count set to -1 to clear StringBuilder
 void StringBuilder_removeFromEnd(StringBuilder* b, u32 count);
 void StringBuilder_append_char(StringBuilder* b, char c);
@@ -25,3 +33,5 @@ void StringBuilder_append_memory(StringBuilder* b, Array(u8) mem, bool uppercase
 
 // adds '\0' to the buffer and returns pointer to buffer content
 str StringBuilder_getStr(StringBuilder* b);
+
+bool StringBuilder_equals(const StringBuilder* a, const StringBuilder* b);

include/tlibc/string/str.h

@@ -20,6 +20,10 @@ static inline str str_from_cstr(cstr s_ptr){
     return str_construct((void*)s_ptr, strlen(s_ptr), true);
 }
 
+static inline void str_destroy(str s){
+    free(s.data);
+}
+
 static inline Array_ str_castTo_Array(str s) {
     return Array_construct_size(s.data, s.size);
 }
@@ -31,29 +35,29 @@ static inline str Array_castTo_str(Array_ a, bool isZeroTerminated) {
 static const str str_null = str_construct(NULL, 0, 0);
 
 /// copies src content to new string and adds \0 at the end
-str str_copy(str src);
+str str_copy(const str self);
 
 /// compares two strings, NullPtr-friendly
-bool str_equals(str str0, str str1);
+bool str_equals(const str self, const str other);
 
 /// allocates new string which is reversed variant of <s>
 str str_reverse(str s);
 
-i32 str_seek(str src, str fragment, u32 startIndex);
-i32 str_seekReverse(str src, str fragment, u32 startIndex);
+i32 str_seek(const str src, const str fragment, u32 startIndex);
+i32 str_seekReverse(const str src, const str fragment, u32 startIndex);
 
-i32 str_seekChar(str src, char c, u32 startIndex);
-i32 str_seekCharReverse(str src, char c, u32 startIndex);
+i32 str_seekChar(const str src, char c, u32 startIndex);
+i32 str_seekCharReverse(const str src, char c, u32 startIndex);
 
-bool str_startsWith(str src, str fragment);
-bool str_endsWith(str src, str fragment);
+bool str_startsWith(const str src, const str fragment);
+bool str_endsWith(const str src, const str fragment);
 
 /// @brief calculates string hash using sdbm32 algorythm (something like lightweight crc32)
 /// @return non-cryptografic hash of the string
-u32 str_hash32(str s);
+u32 str_hash32(const str s);
 
-str str_toUpper(str src);
-str str_toLower(str src);
+str str_toUpper(const str src);
+str str_toLower(const str src);
 
 str hex_to_str(Array(u8) buf, bool uppercase);