string.c

Go to the documentation of this file.

 
#include <kiba/core/string.h>
 
#include <kiba/core/log.h>
#include <kiba/core/memory.h>
 
#include <string.h>
 
string string_from_raw(const char *raw) { return string_from_raw_n(raw, strlen(raw)); }
 
KB_API string string_copy_raw(const char *raw, allocator *alloc) {
    string base = string_from_raw(raw);
    string res  = {0};
    res.data    = allocator_allocate(alloc, base.length);
    if (res.data != KB_NULL) {
        memory_copy(res.data, base.data, base.length * sizeof(char));
        res.length = base.length;
        res.alloc  = alloc;
    }
    return res;
}
 
string string_from_raw_n(const char *raw, usize n) {
    return (string){
        .data   = (char *) raw,
        .length = n,
        .alloc  = KB_NULL,
    };
}
 
string string_join_views(const array_of(string_view) views, const char sep, allocator *alloc) {
    KB_ASSERT(views != KB_NULL, "input views must be a valid array pointer");
    KB_ASSERT(alloc != KB_NULL, "allocator to use must be a valid pointer");
    usize length = array_size(views) - 1;
    array_for_each(const string_view, view, views) { length += view->length; }
    char *new_data = allocator_allocate(alloc, sizeof(char) * length);
 
    usize i = 0;
    if (new_data != KB_NULL) {
        array_for_each(const string_view, view, views) {
            if (view->is_valid && memory_copy(new_data + i, string_view_data(*view), sizeof(char) * view->length)) {
                i += view->length;
                if (i < length) {
                    new_data[i++] = sep;
                }
            }
        }
    }
 
    return (string){
        .data   = new_data,
        .length = i == length ? length : 0,
        .alloc  = alloc,
    };
}
 
string string_from_view(const string_view src, allocator *alloc) {
    KB_ASSERT(alloc != KB_NULL, "allocator to use must be a valid pointer");
    char *new_data = KB_NULL;
    if (src.is_valid && src.length > 0) {
        new_data = allocator_allocate(alloc, sizeof(char) * src.length);
        if (new_data != KB_NULL) {
            memory_copy(new_data, string_view_data(src), src.length);
        }
    }
    return (string){
        .data   = new_data,
        .length = new_data != KB_NULL ? src.length : 0,
        .alloc  = alloc,
    };
}
 
string string_from_views(const array_of(string_view) views, allocator *alloc) {
    KB_ASSERT(views != KB_NULL, "input views must be a valid array pointer");
    KB_ASSERT(alloc != KB_NULL, "allocator to use must be a valid pointer");
    usize length = 0;
    array_for_each(const string_view, view, views) { length += view->length; }
    char *new_data = allocator_allocate(alloc, sizeof(char) * length);
 
    usize i = 0;
    if (new_data != KB_NULL) {
        array_for_each(const string_view, view, views) {
            if (view->is_valid
                && memory_copy(new_data + i, string_view_data(*view), sizeof(char) * view->length) != KB_NULL) {
                i += view->length;
            }
        }
    }
 
    return (string){
        .data   = new_data,
        .length = i == length ? length : 0,
        .alloc  = alloc,
    };
}
 
void string_destroy(string *str) {
    if (string_is_valid(*str) && str->alloc != KB_NULL) {
        allocator_free(str->alloc, str->data);
    }
    str->data   = KB_NULL;
    str->length = 0;
}
 
b8 string_is_valid(const string str) { return string_view_from_string(str).is_valid; }
 
usize string_index_of(const string str, const char c) { return string_view_index_of(string_view_from_string(str), c); }
 
string string_clone(const string str, allocator *alloc) {
    KB_ASSERT(alloc != KB_NULL, "allocator to use must be a valid pointer");
    return string_from_view(string_view_from_string(str), alloc);
}
 
b8 string_equal(const string lhs, const string rhs) {
    return string_view_equal(string_view_from_string(lhs), string_view_from_string(rhs));
}
 
b8 string_n_equal(const string lhs, const string rhs, usize n) {
    return string_view_n_equal(string_view_from_string(lhs), string_view_from_string(rhs), n);
}
 
string_view string_view_from_string(const string str) {
    return (string_view){
        .str      = str,
        .length   = str.length,
        .offset   = 0,
        .is_valid = str.data != KB_NULL && str.length != 0,
    };
}
 
const char *string_view_data(const string_view view) { return view.is_valid ? view.str.data + view.offset : KB_NULL; }
 
b8 string_view_equal(const string_view lhs, const string_view rhs) {
    if (!lhs.is_valid || !rhs.is_valid || lhs.length != rhs.length) {
        return false;
    }
    for (usize i = 0; i < lhs.length; ++i) {
        if (lhs.str.data[lhs.offset + i] != rhs.str.data[rhs.offset + i]) {
            return false;
        }
    }
    return true;
}
 
b8 string_view_n_equal(const string_view lhs, const string_view rhs, usize n) {
    // lhs and rhs must have at least length n
    if (KB_MIN(n, KB_MIN(lhs.length, rhs.length)) != n) {
        return false;
    }
    if (!lhs.is_valid || !rhs.is_valid) {
        return false;
    }
    for (usize i = 0; i < n; ++i) {
        if (lhs.str.data[lhs.offset + i] != rhs.str.data[rhs.offset + i]) {
            return false;
        }
    }
    return true;
}
 
string_view string_view_at_offset(const string_view src, usize offset) {
    return (string_view){
        .str      = src.str,
        .length   = src.length - offset,
        .offset   = src.offset + offset,
        .is_valid = src.is_valid && offset < src.length,
    };
}
 
string_view string_view_subview(const string_view view, usize start, usize length) {
    return (string_view){
        .str      = view.str,
        .offset   = view.offset + start,
        .length   = length,
        .is_valid = view.is_valid && view.length > start && view.length >= start + length,
    };
}
 
char string_view_char_at(const string_view view, usize index) {
    if (view.is_valid && index < view.length) {
        return view.str.data[view.offset + index];
    }
    return -1;
}
 
usize string_view_index_of(const string_view view, const char c) {
    if (view.is_valid) {
        for (usize i = 0; i < view.length; ++i) {
            if (view.str.data[view.offset + i] == c) {
                return i;
            }
        }
    }
    return USIZE_MAX;
}
 
string_view string_view_after_next_char(const string_view view, const char c) {
    usize index = string_view_index_of(view, c);
    return (string_view){
        .str      = view.str,
        .length   = view.length - index - 1,
        .offset   = view.offset + index + 1,
        .is_valid = view.is_valid && index != USIZE_MAX,
    };
}
 
string_view string_view_until_next_char(const string_view view, const char c) {
    usize index = string_view_index_of(view, c);
    return (string_view){
        .str      = view.str,
        .length   = index,
        .offset   = view.offset,
        .is_valid = view.is_valid && index != USIZE_MAX,
    };
}
 
string_view string_view_trim(const string_view src) {
    usize new_offset = src.offset;
    usize new_length = src.length;
    if (src.is_valid) {
        while (new_offset < src.offset + src.length && character_is_whitespace(src.str.data[new_offset])) {
            ++new_offset;
            --new_length;
        }
        while (new_length > 0 && character_is_whitespace(src.str.data[new_offset + new_length - 1])) {
            --new_length;
        }
    }
    return (string_view){
        .str      = src.str,
        .length   = new_length,
        .offset   = new_offset,
        .is_valid = src.is_valid,
    };
}
 
b8 string_view_split(const string_view view, const char sep, array_of(string_view) * arr) {
    KB_ASSERT(arr, "provided array must be valid");
    usize       end         = string_view_index_of(view, sep);
    string_view window_view = view;
    while (end != USIZE_MAX) {
        string_view cur_view = string_view_subview(window_view, 0, end);
        if (!cur_view.is_valid || !array_push_checked(arr, &cur_view)) {
            return false;
        }
        window_view = string_view_at_offset(window_view, end + 1);
        end         = string_view_index_of(window_view, sep);
    }
    // pick up remainder if string does not end in separator
    if (window_view.is_valid && window_view.offset < view.length) {
        string_view remaining_view = string_view_subview(window_view, 0, view.length - window_view.offset);
        if (!remaining_view.is_valid || !array_push_checked(arr, &remaining_view)) {
            return false;
        }
    }
    return true;
}