string.hpp

#pragma once
 
#include <complex>
#include <cstring>
#include <functional>
#include <initializer_list>
#include <type_traits>
#include <utility>
 
#include <istream>
#include <ostream>
 
#include "../encoding.hpp"
#include "charFunctions.hpp"
#include "hash32.hpp"
#include "zstr.hpp"
 
#include "arrayLike.hpp"
#include "sizable.hpp"
 
#include "stringIterator.hpp"
 
#ifdef __has_include
#if __has_include(<cereal/cereal.hpp>)
#include <cereal/types/string.hpp>
#endif
#endif
 
namespace z {
namespace core {
template <encoding E = utf8>
class string final : public sizable, public arrayLike<uint32_t, stringIterator<E>> {
    friend string<ascii>;
    friend string<utf8>;
    friend string<utf16>;
    friend string<utf32>;
 
private:
    uint8_t *data;
    int data_len;
    int character_ct;
 
    void initChar(uint32_t, int) noexcept;
    int charSize() const noexcept;
 
    void initInt(long long, int, int) noexcept;
    void initFloat(double, int, int, bool, int) noexcept;
    void initPointer(void *) noexcept;
    void initComplex(const std::complex<double> &, int, int, bool, int) noexcept;
 
public:
    string() noexcept;
 
    explicit string(char chr) noexcept;
 
    explicit string(wchar_t chr) noexcept;
 
    string(const uint32_t &chr) noexcept;
 
    string(const char *str) noexcept;
 
    string(const char *str, size_t len) noexcept;
 
#if __cplusplus >= 202002L
    inline string(const char8_t *const str) noexcept : string((const char *)str) {}
    string(const char8_t *const str, size_t len) noexcept : string((const char *)str, len) {}
#endif
 
    string(const wchar_t *str) noexcept;
 
    string(const wchar_t *str, size_t len) noexcept;
 
    string(const std::string &str) noexcept : string(str.c_str(), str.size()) {}
 
    template <typename INT, typename = typename std::enable_if<std::is_integral<INT>::value && !std::is_same<INT, char>::value && !std::is_same<INT, wchar_t>::value, INT>::type>
    string(INT value, int base = 10, int padSize = 0) noexcept {
        this->initInt((long long)value, base, padSize);
    }
 
#if __cplusplus < 202002L
    template <typename PTR, typename = typename std::enable_if<std::is_pointer<PTR>::value && !std::is_same<PTR, char *>::value && !std::is_same<PTR, wchar_t *>::value, PTR>::type>
    string(PTR pointer) noexcept {
        this->initPointer((void *)pointer);
    }
#else
    template <typename PTR, typename = typename std::enable_if<std::is_pointer<PTR>::value && !std::is_same<PTR, char *>::value && !std::is_same<PTR, wchar_t *>::value && !std::is_same<PTR, char8_t *>::value, PTR>::type>
    string(PTR pointer) noexcept {
        this->initPointer((void *)pointer);
    }
#endif
 
    template <typename FLT, typename = typename std::enable_if<std::is_floating_point<FLT>::value, FLT>::type>
    string(FLT value, int base = 10, int precision = 0, bool scientific = true, int padSize = 0) noexcept {
        this->initFloat((double)value, base, precision, scientific, padSize);
    }
 
    template <typename T, typename = typename std::enable_if<std::is_arithmetic<T>::value, T>::type>
    string(const std::complex<T> &value, int base = 10, int precision = 0, bool scientific = true, int padSize = 0) noexcept {
        this->initComplex((std::complex<double>)value, base, precision, scientific, padSize);
    }
 
    string(const string<ascii> &other) noexcept;
 
    string(const string<utf8> &other) noexcept;
 
    string(const string<utf16> &other) noexcept;
 
    string(const string<utf32> &other) noexcept;
 
    string(string &&other) noexcept {
        data = other.data;
        data_len = other.data_len;
        character_ct = other.character_ct;
        other.data = NULL;
    }
 
    string &operator=(string &&other) noexcept {
        if (&other != this) {
            delete[] data;
            data = other.data;
            data_len = other.data_len;
            character_ct = other.character_ct;
            other.data = NULL;
        }
 
        return *this;
    }
 
    ~string() noexcept {
        if (data) {
            delete[] data;
        }
    }
 
    void increase(int charCount) noexcept;
 
    uint32_t at(int index) const noexcept override;
 
    size_t size() const noexcept override;
 
    int length() const noexcept override;
 
    int chars() const noexcept;
 
    const char *cstring() const noexcept;
 
    const uint16_t *nstring() const noexcept;
 
    const uint32_t *wstring() const noexcept;
 
    constexpr encoding format() const noexcept {
        return E;
    }
 
    long integer(int base = 10, uint32_t decimal = '.') const noexcept;
 
    template <typename INT, typename = typename std::enable_if<std::is_integral<INT>::value, INT>::type>
    explicit operator INT() const noexcept {
        return integer();
    }
 
    double floating(int base = 10, uint32_t decimal = '.') const noexcept;
 
    explicit operator double() const noexcept {
        return floating();
    }
 
    explicit operator float() const noexcept {
        return floating();
    }
 
    constexpr explicit operator bool() const noexcept {
        return length() > 0;
    }
 
    std::complex<double> complex(int base = 10, uint32_t decimal = '.') const noexcept;
 
    int count(const string &other) const noexcept;
 
    int find(const string &other, int occurrence = 1) const noexcept {
        return this->findAfter(other, 0, occurrence);
    }
 
    int found(const string &other, int occurrence = 1) const noexcept {
        return this->findAfter(other, 0, occurrence) >= 0;
    }
 
    int findLast(const string &other, int occurrence = 1) const noexcept {
        return this->findBefore(other, this->character_ct, occurrence);
    }
 
    int findAfter(const string &other, int index, int occurrence = 1) const noexcept {
        (void)occurrence;
        for (int i = index; i < character_ct; i++) {
            if (foundAt(other, i)) {
                return i;
            }
        }
 
        return -1;
    }
 
    int findBefore(const string &other, int index, int occurrence = 1) const noexcept;
 
    bool foundAt(const string &other, int index) const noexcept;
 
    bool foundEndAt(const string &other, int index) const noexcept;
 
    bool beginsWith(const string &other) const noexcept {
        return this->foundAt(other, 0);
    }
 
    bool endsWith(const string &other) const noexcept {
        return this->foundEndAt(other, character_ct - 1);
    }
 
    bool isInteger(int base = 10) const noexcept {
        return type(base) & (zstr::integer);
    }
 
    bool isFloating(int base = 10, uint32_t decimal = '.') const noexcept {
        return type(base, decimal) & (zstr::integer | zstr::floating);
    }
 
    bool isComplex(int base = 10, uint32_t decimal = '.') const noexcept {
        return type(base, decimal) & (zstr::integer | zstr::floating | zstr::complex);
    }
 
    int type(int base = 10, uint32_t decimal = '.') const noexcept;
 
    string substr(int index, int count) const noexcept;
 
    inline string substr(int index) const noexcept {
        return substr(index, character_ct - index);
    }
 
    string &append(const string &other) noexcept {
        return operator+=(other);
    }
 
    string &append(uint32_t chr) noexcept;
 
    string &insert(const string &other, int index) noexcept;
 
    string &remove(const string &other, int occurrence = 0) noexcept;
 
    string &remove(int index, int count) noexcept;
 
    string &truncate(int index) noexcept;
 
    string &replace(const string &findStr, const string &replStr, int occurrence = 0) noexcept;
 
    string &replace(int index, int count, const string &other) noexcept;
 
    string padLeft(const string &other, int padSize) const noexcept {
        string newString = *this;
        return newString.padLeftIn(other, padSize);
    }
 
    string &padLeftIn(const string &other, int padSize) noexcept;
 
    string padRight(const string &other, int padSize) const noexcept {
        string newString = *this;
        return newString.padRightIn(other, padSize);
    }
 
    string &padRightIn(const string &other, int padSize) noexcept;
 
    string repeat(int count) const noexcept {
        string value;
        value.increase(character_ct * count);
        for (int i = 0; i < count; ++i) {
            value.append(*this);
        }
        return value;
    }
 
    string trimLeft(const string &other = "") const noexcept {
        if ((character_ct < other.character_ct) || !character_ct) {
            return *this;
        }
 
        int index = 0;
        if (other.length()) {
            while (foundAt(other, index)) {
                index += other.character_ct;
            }
        } else {
            while (isWhiteSpace(at(index))) {
                ++index;
            }
        }
 
        return substr(index, character_ct - index);
    }
 
    string trimRight(const string &other = "") const noexcept {
        if ((character_ct < other.character_ct) || !character_ct) {
            return *this;
        }
 
        int index = character_ct - 1;
        if (other.length()) {
            while (foundEndAt(other, index)) {
                index -= other.character_ct;
            }
        } else {
            while (isWhiteSpace(at(index))) {
                --index;
            }
        }
 
        return substr(0, index + 1);
    }
 
    string &trimLeftIn(const string &other = "") noexcept {
        if ((character_ct < other.character_ct) || !character_ct) {
            return *this;
        }
 
        int index = 0;
        if (other.length()) {
            while (foundAt(other, index)) {
                index += other.character_ct;
            }
        } else {
            while (isWhiteSpace(this->at(index))) {
                ++index;
            }
        }
 
        return remove(0, index);
    }
 
    string &trimRightIn(const string &other = "") noexcept {
        if ((character_ct < other.character_ct) || !character_ct) {
            return *this;
        }
 
        int index = character_ct - 1;
        if (other.length()) {
            while (foundEndAt(other, index)) {
                index -= other.character_ct;
            }
        } else {
            while (isWhiteSpace(at(index))) {
                --index;
            }
        }
 
        return remove(index + 1, character_ct);
    }
 
    string trim(const string &other = "") const noexcept {
        auto result = trimLeft(other);
        return result.trimRightIn(other);
    }
 
    string &trimIn(const string &other = "") noexcept {
        trimLeftIn(other);
        return trimRightIn(other);
    }
 
    void clear() noexcept;
 
    string &cutDuplicates(const string &other) noexcept;
 
    string upper() const noexcept {
        return string(*this).toUpper();
    }
 
    string lower() const noexcept {
        return string(*this).toLower();
    }
 
    string camel() const noexcept {
        return string(*this).toCamel();
    }
 
    string &toUpper() noexcept;
 
    string &toLower() noexcept;
 
    string &toCamel() noexcept;
 
    string filter(uint32_t first, uint32_t last, bool invert = false) const noexcept {
        return filter({first, last}, invert);
    }
 
    string filter(const std::pair<uint32_t, uint32_t> &range, bool invert = false) const noexcept {
        return filter({range}, invert);
    }
 
    string filter(const std::initializer_list<const std::pair<uint32_t, uint32_t>> &list, bool invert = false) const noexcept;
 
    string filter(const string &list, bool invert = false) const noexcept;
 
    string filter(std::function<bool(uint32_t)> lambda) const noexcept;
 
    bool contains(uint32_t first, uint32_t last, bool exclusive = false) const noexcept {
        return contains({first, last}, exclusive);
    }
 
    bool contains(const std::pair<uint32_t, uint32_t> &range, bool exclusive = false) const noexcept {
        return contains({range}, exclusive);
    }
 
    bool contains(const std::initializer_list<const std::pair<uint32_t, uint32_t>> &list, bool exclusive = false) const noexcept;
 
    bool contains(const string &list, bool exclusive = false) const noexcept;
 
    string cipher(const string &keys, const string &values) const noexcept;
 
    string cipher(std::function<uint32_t(uint32_t)> lambda) const noexcept;
 
    static string words(long long value, bool ordinal = false) noexcept;
 
    static string ordinal(long long value) noexcept;
 
    static inline string precision(double value, int precision, bool forcePrecision = false) noexcept {
        return string(value, 10, precision, false, forcePrecision ? precision : 0);
    }
 
    static string numberFormat(double value, int precision = 0, bool forcePrecision = false, char decimal = '.', char thousands = ',') noexcept;
 
    string concat(const string &other) const noexcept {
        return *this + other;
    }
 
    string operator+(const string &other) const noexcept;
 
    string &operator+=(const string &other) noexcept;
 
    string &operator=(const string &other) noexcept;
 
    bool operator==(const string &other) const noexcept;
 
    bool operator!=(const string &other) const noexcept {
        return !operator==(other);
    }
 
    bool operator>(const string &other) const noexcept;
 
    bool operator>=(const string &other) const noexcept {
        return !operator<(other);
    }
 
    bool operator<(const string &other) const noexcept;
 
    bool operator<=(const string &other) const noexcept {
        return !operator>(other);
    }
 
    string &read(std::istream &stream, uint32_t delim = 0) noexcept;
 
    string &readln(std::istream &stream) noexcept;
 
    string &readall(std::istream &stream) noexcept;
 
    void write(std::ostream &stream) const noexcept {
        stream << *this << std::flush;
    }
 
    void writeln(std::ostream &stream) const noexcept {
        stream << *this << std::endl;
    }
 
    stringIterator<E> begin() const noexcept override {
        return stringIterator<E>(data, 0);
    }
 
    stringIterator<E> end() const noexcept override {
        return stringIterator<E>(data, character_ct);
    }
 
#ifdef __has_include
#if __has_include(<cereal/cereal.hpp>)
 
    template <class archive>
    std::string save_minimal(archive &ar) const {
        (void)ar;
        return string<utf8>(*this).cstring();
    }
 
    template <class archive>
    void load_minimal(archive const &ar, std::string const &value) {
        (void)ar;
        operator=(value.c_str());
    }
#endif
#endif
 
    friend std::ostream &operator<<(std::ostream &ostr, const z::core::string<E> &str) {
        return ostr << string<utf8>(str).cstring();
    }
 
    friend std::istream &operator>>(std::istream &istr, z::core::string<E> &str) {
        std::string s;
        istr >> s;
 
        if (s.length()) {
            str = s.c_str(); // not efficient to cast strings back & forth, but it works for now.
        }
        return istr;
    }
 
    inline std::string str() const noexcept {
        return string<utf8>(*this).cstring();
    }
 
    hash32 hash() const noexcept;
};
} // namespace core
} // namespace z
 
typedef z::core::string<> zstring;
typedef z::core::string<z::utf8> zpath;
 
// Custom literals for simple string construction
z::core::string<z::utf32> operator""_u32(char value);
z::core::string<z::utf32> operator""_u32(wchar_t value);
z::core::string<z::utf32> operator""_u32(const char *value);
z::core::string<z::utf32> operator""_u32(const char *value, size_t);
z::core::string<z::utf32> operator""_u32(const wchar_t *value, size_t);
 
z::core::string<z::utf16> operator""_u16(char value);
z::core::string<z::utf16> operator""_u16(wchar_t value);
z::core::string<z::utf16> operator""_u16(const char *value);
z::core::string<z::utf16> operator""_u16(const char *value, size_t);
z::core::string<z::utf16> operator""_u16(const wchar_t *value, size_t);
 
z::core::string<z::utf8> operator""_u8(char value);
z::core::string<z::utf8> operator""_u8(wchar_t value);
z::core::string<z::utf8> operator""_u8(const char *value);
z::core::string<z::utf8> operator""_u8(const char *value, size_t);
z::core::string<z::utf8> operator""_u8(const wchar_t *value, size_t);
 
z::core::string<z::ascii> operator""_asc(char value);
z::core::string<z::ascii> operator""_asc(wchar_t value);
z::core::string<z::ascii> operator""_asc(const char *value);
z::core::string<z::ascii> operator""_asc(const char *value, size_t);
z::core::string<z::ascii> operator""_asc(const wchar_t *value, size_t);
 
zstring operator""_zs(char value);
zstring operator""_zs(wchar_t value);
zstring operator""_zs(const char *value);
zstring operator""_zs(const char *value, size_t);
zstring operator""_zs(const wchar_t *value, size_t);