string.h

// =====================================================================================================================
//  fennec, a free and open source game engine
//  Copyright © 2025  Medusa Slockbower
//
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
 
#ifndef FENNEC_STRING_STRING_H
#define FENNEC_STRING_STRING_H
 
#include <fennec/string/cstring.h>
 
#include <fennec/memory/allocator.h>
#include <fennec/memory/common.h>
 
#include <fennec/math/common.h>
 
namespace fennec
{
 
// Forward def
template<typename AllocT = allocator<char>> struct _string;
 
// Alias for default allocator
using string = _string<>;
 
template<typename AllocT>
struct _string
{
public:
    static constexpr size_t npos = -1;
    using char_t = char;
    using alloc_t = allocation<char, AllocT>;
 
 
// Constructors ========================================================================================================
 
    constexpr _string()
        : _str() {
    }
 
    constexpr _string(size_t n, char c = '\0')
        : _str(n + 1) {
        fennec::memset(_str, c, n);
    }
 
    constexpr _string(const alloc_t& alloc)
        : _str(alloc) {
    }
 
    constexpr _string(size_t n, char c, const alloc_t& alloc)
        : _str(n + 1, alloc) {
        fennec::memset(_str, c, n);
    }
 
    constexpr _string(const cstring& cstr)
        : _str(cstr, cstr.size() + 1) {
    }
 
    template<size_t n>
    explicit constexpr _string(const char (&str)[n])
        : _str(str[n - 1] != '\0' ? n + 1 : n) {
        fennec::memcpy(_str, str, n);
        if (str[n - 1] != '\0') {
            _str[n] = '\0';
        }
    }
 
    constexpr _string(const char* buf, size_t n)
        : _str(buf[n - 1] != '\0' ? n + 1 : n) {
        fennec::memcpy(_str, buf, n);
        if (buf[n - 1] != '\0') {
            _str[n] = '\0';
        }
    }
 
    constexpr _string(const string_view& view)
        : _string(view.str, view.len) {
    }
 
    constexpr _string(const _string& str) = default;
 
    constexpr _string(_string&& str) noexcept = default;
 
    constexpr ~_string() = default;
 
// Assignment ==========================================================================================================
 
    constexpr _string& operator=(const cstring& cstr) {
        _str.callocate(cstr.capacity());
        fennec::memcpy(_str, cstr, cstr.capacity());
        return *this;
    }
 
    constexpr _string& operator=(const _string& str) {
        _str = str._str;
        return *this;
    }
    constexpr _string& operator=(_string&& str) noexcept {
        _str = fennec::move(str._str);
        return *this;
    }
 
// Properties ==========================================================================================================
 
    constexpr size_t size() const {
        return _str.capacity() > 0 ? _str.capacity() - 1 : 0;
    }
 
    constexpr size_t capacity() const {
        return _str.capacity();
    }
 
    constexpr bool empty() const {
        return size() == 0;
    }
 
// Access ==============================================================================================================
 
    constexpr char& operator[](size_t i) {
        return _str[i];
    }
 
    constexpr const char& operator[](size_t i) const {
        return _str[i];
    }
 
    constexpr char* data() {
        return _str;
    }
 
    constexpr const char* data() const {
        return _str;
    }
 
    constexpr const char* cstr() const {
        return _str;
    }
 
// Examination =========================================================================================================
 
    constexpr size_t length() const {
        return find('\0');
    }
 
    constexpr int compare(const cstring& str, size_t i = 0, size_t n = npos) const {
        if (i >= size()) { // bounds check
            return -1;
        }
        n = fennec::min(n, fennec::max(size(), str.size()) + 1);
 
        return ::strncmp(_str + i, str, n);
    }
 
    constexpr int compare(const string& str, size_t i = 0, size_t n = npos) const {
        if (i >= size()) { // bounds check
            return -1;
        }
        n = min(n, max(size(), str.size()) + 1);
 
        return ::strncmp(_str + i, str.data(), n);
    }
 
    constexpr bool operator==(const cstring& str) const {
        return compare(str) == 0;
    }
 
    constexpr bool operator==(const _string& str) const {
        return compare(str) == 0;
    }
 
    constexpr bool contains(char c, size_t i = 0) const {
        return find(c, i) != size();
    }
 
    constexpr size_t find(char c, size_t i = 0) const {
        if (i >= size()) { // bounds check
            return size();
        }
 
        const char* loc = ::strchr(_str + i, c); // get location using strchr
        return loc ? loc - _str : size(); // return size if not found
    }
 
    constexpr size_t find(const string& str, size_t i = 0) const { // bounds check
        if (i >= size()) { // bounds check
            return size();
        }
 
        const char* loc = ::strstr(_str, str._str);
        return loc ? loc - _str : size();
    }
 
    constexpr size_t find(const cstring& str, size_t i = 0) const {
        if (i + str.size() > size()) { // bounds check
            return size();
        }
 
        const char* loc = ::strstr(_str + i, str); // get location using strstr
        return loc ? loc - _str : size(); // return size if not found
    }
 
    constexpr size_t rfind(char c, size_t i = npos) const {
        if (size() == 0) {
            return size();
        }
        i = min(i, size() - 1); // clamp i to bounds
        do {
            if (_str[i] == c) { // loop backwards looking for c
                return i;
            }
        } while (i--);
        return size(); // base case
    }
 
    constexpr size_t rfind(const cstring& str, size_t i = npos) const {
        if (size() == 0) {
            return size();
        }
        const char first = str[0];
        i = min(i, size() - str.size());
        do {
            if(_str[i] == first) {
                if (compare(str, i) == 0) {
                    return i;
                }
            }
        } while (i--);
        return size(); // base case
    }
 
    constexpr size_t rfind(const string& str, size_t i = npos) const {
        if (size() == 0) {
            return size();
        }
        const char first = str[0];
        i = min(i, size() - str.size());
        do {
            if(_str[i] == first) {
                if (compare(str, i) == 0) { // loop backwards looking for str
                    return i;
                }
            }
        } while (i--);
        return size(); // base case
    }
 
    constexpr _string substring(size_t i, size_t n = npos) const {
        if (i >= size() || n == 0) {
            return _string("");
        }
        n = fennec::min(n, size() - i);
        _string res;
        res._str.callocate(n + 1);
        fennec::memcpy(res.data(), _str + i, n);
        return res;
    }
 
 
 
// Modifiers ===========================================================================================================
 
    constexpr void resize(size_t n) {
        _str.creallocate(n + 1);
        _str[size()] = '\0';
    }
 
    constexpr _string operator+(char c) const {
        if (_str == nullptr) {
            return _string(1, c);
        }
        _string res;
        res._str.callocate(capacity() + 1);
        fennec::memcpy(res.data(), _str, size());
        res[size()] = c;
        return res;
    }
 
    friend constexpr _string operator+(char c, const _string& str) {
        _string res(1, c);
        return res += str;
    }
 
    constexpr _string operator+(const cstring& cstr) const {
        if (_str == nullptr) {
            return _string(cstr);
        }
        _string res;
        res._str.callocate(size() + cstr.size() + 1);
        fennec::memcpy(res.data(), _str, size());
        fennec::memcpy(res.data() + size(), cstr, cstr.size());
        return res;
    }
 
    constexpr _string operator+(const _string& str) const {
        if (_str == nullptr) {
            return _string(str);
        }
        if (str.data() == nullptr) {
            return _string(*this);
        }
        _string res;
        res._str.callocate(size() + str.size() + 1);
        fennec::memcpy(res.data(), _str, size());
        fennec::memcpy(res.data() + size(), str.data(), str.size());
        return res;
    }
 
    constexpr _string& operator+=(char c) {
        if (_str == nullptr) {
            _str.callocate(2);
            _str[0] = c;
            return *this;
        }
        _str.creallocate(capacity() + 1);
        _str[size() - 1] = c;
        return *this;
    }
 
    constexpr _string& operator+=(const cstring& cstr) {
        if (_str == nullptr) {
            return *this = cstr;
        }
        size_t middle = size();
        _str.creallocate(middle + cstr.size() + 1);
        fennec::memcpy(_str + middle, cstr, cstr.size());
        return *this;
    }
 
    constexpr _string& operator+=(const _string& str) {
        if (_str == nullptr) {
            return *this = str;
        }
        if (str.data() == nullptr) {
            return *this;
        }
        size_t middle = size();
        _str.creallocate(middle + str.size() + 1);
        fennec::memcpy(_str + middle, str.data(), str.size());
        return *this;
    }
 
 
// Iteration ===========================================================================================================
 
    constexpr char* begin() {
        return _str.data();
    }
 
    constexpr const char* begin() const {
        return _str.data();
    }
 
    constexpr char* end() {
        return _str.data() + _str.capacity();
    }
 
    constexpr const char* end() const {
        return _str.data() + _str.capacity();
    }
 
 
private:
    alloc_t _str;
};
 
template<>
struct hash<string> : hash<byte_array> {
    constexpr size_t operator()(const string& str) const {
        return hash<byte_array>::operator()(byte_array(str.data(), str.size()));
    }
};
 
}
 
 
#endif // FENNEC_STRING_STRING_H