wstring.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_WSTRING_H
#define FENNEC_STRING_WSTRING_H
 
#include <fennec/string/detail/_ctype.h>
#include <fennec/string/wcstring.h>
 
#include <fennec/lang/assert.h>
 
#include <fennec/memory/allocator.h>
#include <fennec/memory/common.h>
 
#include <fennec/math/common.h>
 
namespace fennec
{
 
// Forward def
template<typename AllocT = allocator<wchar_t>> struct _wstring;
 
// Alias for default allocator
using wstring = _wstring<>;
 
template<typename AllocT>
struct _wstring
{
public:
    static constexpr size_t npos = -1;
    using char_t = wchar_t;
    using alloc_t = allocation<wchar_t, AllocT>;
 
 
// Constructors ========================================================================================================
 
    constexpr _wstring()
        : _str() {
    }
 
    constexpr _wstring(size_t n, wchar_t c = '\0')
        : _str(n + 1) {
        fennec::wmemset(_str, c, n);
    }
 
    constexpr _wstring(const alloc_t& alloc)
        : _str(alloc) {
    }
 
    constexpr _wstring(size_t n, wchar_t c, const alloc_t& alloc)
        : _str(n + 1, alloc) {
        fennec::wmemset(_str, c, n);
    }
 
    constexpr _wstring(const wcstring& cstr)
        : _str(cstr, cstr.size() + 1) {
    }
 
    template<size_t n>
    explicit constexpr _wstring(const wchar_t (&str)[n])
        : _str(str[n - 1] != '\0' ? n + 1 : n) {
        fennec::wmemcpy(_str, str, n);
        if (str[n - 1] != '\0') {
            _str[n] = '\0';
        }
    }
 
    constexpr _wstring(const wchar_t* buf, size_t n)
        : _str(buf[n - 1] != '\0' ? n + 1 : n) {
        fennec::wmemcpy(_str, buf, n);
        if (buf[n - 1] != '\0') {
            _str[n] = '\0';
        }
    }
 
    constexpr _wstring(const _wstring& str) = default;
 
    constexpr _wstring(_wstring&& str) noexcept = default;
 
    constexpr ~_wstring() = default;
 
// Assignment ==========================================================================================================
 
    constexpr _wstring& operator=(const wcstring& cstr) {
        _str.callocate(cstr.capacity());
        fennec::wmemcpy(_str, cstr, cstr.capacity());
        return *this;
    }
 
    constexpr _wstring& operator=(const _wstring& str) = default;
    constexpr _wstring& operator=(_wstring&& str) noexcept = default;
 
// 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 wchar_t& operator[](size_t i) {
        return _str[i];
    }
 
    constexpr const wchar_t& operator[](size_t i) const {
        return _str[i];
    }
 
    constexpr wchar_t* data() {
        return _str;
    }
 
    constexpr const wchar_t* data() const {
        return _str;
    }
 
    constexpr const wchar_t* cstr() const {
        return _str;
    }
 
// Examination =========================================================================================================
 
    constexpr size_t length() const {
        return find('\0');
    }
 
    constexpr int compare(const wcstring& str, size_t i = 0, size_t n = npos) const {
        if (i >= size()) { // bounds check
            return -1;
        }
        n = fennec::min(n, fennec::max(_str, str.size()) + 1);
 
        return ::wcsncmp(_str + i, str, n);
    }
 
    constexpr int compare(const _wstring& 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 ::wcsncmp(_str + i, str.data(), n);
    }
 
    constexpr bool operator==(const wcstring& str) const {
        return compare(str) == 0;
    }
 
    constexpr bool operator==(const _wstring& 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(wchar_t c, size_t i = 0) const {
        if (i >= size()) { // bounds check
            return size();
        }
 
        const wchar_t* loc = ::wcschr(_str + i, c); // get location using strchr
        return loc ? loc - _str : size(); // return size if not found
    }
 
    constexpr size_t find(const _wstring& str, size_t i = 0) const { // bounds check
        if (i >= size()) { // bounds check
            return size();
        }
 
        const wchar_t* loc = ::wcsstr(_str, str);
        return loc ? loc - _str : size();
    }
 
    constexpr size_t find(const wcstring& str, size_t i = 0) const {
        if (i + str.size() > size()) { // bounds check
            return size();
        }
 
        const wchar_t* loc = ::wcsstr(_str + i, str); // get location using strstr
        return loc ? loc - _str : size(); // return size if not found
    }
 
    constexpr size_t rfind(wchar_t 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 wcstring& str, size_t i = npos) const {
        if (size() == 0) {
            return size();
        }
        const wchar_t 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 wchar_t 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 _wstring substring(size_t i, size_t n = npos) const {
        if (i >= size()) {
            return _wstring("");
        }
        n = fennec::min(n, size() - i);
        _wstring res;
        res._str.callocate(n + 1);
        fennec::wmemcpy(res.data(), _str + i, n);
        return res;
    }
 
 
 
// Modifiers ===========================================================================================================
 
    constexpr void resize(size_t n) {
        _str.creallocate(n + 1);
        _str[size()] = '\0';
    }
 
    constexpr _wstring operator+(wchar_t c) const {
        if (_str == nullptr) {
            return _wstring(1, c);
        }
        _wstring res;
        res._str.callocate(capacity() + 1);
        fennec::wmemcpy(res.data(), _str, size());
        res[size()] = c;
        return res;
    }
 
    friend constexpr _wstring operator+(wchar_t c, const _wstring& str) {
        _wstring res(1, c);
        return res += str;
    }
 
    constexpr _wstring operator+(const wcstring& cstr) const {
        if (_str == nullptr) {
            return _wstring(cstr);
        }
        _wstring res;
        res._str.callocate(size() + cstr.size() + 1);
        fennec::wmemcpy(res.data(), _str, size());
        fennec::wmemcpy(res.data() + size(), cstr, cstr.size());
        return res;
    }
 
    constexpr _wstring operator+(const _wstring& str) const {
        if (_str == nullptr) {
            return _wstring(str);
        }
        if (str.data() == nullptr) {
            return _wstring(*this);
        }
        _wstring res;
        res._str.callocate(size() + str.size() + 1);
        fennec::wmemcpy(res.data(), _str, size());
        fennec::wmemcpy(res.data() + size(), str.data(), str.size());
        return res;
    }
 
    constexpr _wstring& operator+=(wchar_t c) {
        if (_str == nullptr) {
            _str.callocate(2);
            _str[0] = c;
            return *this;
        }
        _str.creallocate(capacity() + 1);
        _str[size() - 1] = c;
        return *this;
    }
 
    constexpr _wstring& operator+=(const wcstring& cstr) {
        if (_str == nullptr) {
            return *this = cstr;
        }
        size_t middle = size();
        _str.creallocate(middle + cstr.size() + 1);
        fennec::wmemcpy(_str + middle, cstr, cstr.size());
        return *this;
    }
 
    constexpr _wstring& operator+=(const _wstring& str) {
        if (_str == nullptr) {
            return *this = str;
        }
        if (str.data() == nullptr) {
            return *this;
        }
        size_t middle = size();
        _str.creallocate(middle + str.size() + 1);
        fennec::wmemcpy(_str + middle, str.data(), str.size());
        return *this;
    }
 
 
private:
    alloc_t _str;
};
 
template<>
struct hash<wstring> : 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_WSTRING_H