AString.h

/*
 * AUI Framework - Declarative UI toolkit for modern C++20
 * Copyright (C) 2020-2024 Alex2772 and Contributors
 *
 * SPDX-License-Identifier: MPL-2.0
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
 
#pragma once
 
#include <string>
#include <iostream>
#include "AUI/Core.h"
#include "AUI/Traits/values.h"
#include <AUI/Common/ASet.h>
#include <optional>
#include <AUI/Common/AOptional.h>
#include <fmt/core.h>
 
class API_AUI_CORE AStringVector;
class API_AUI_CORE AByteBuffer;
class API_AUI_CORE AByteBufferView;
 
class API_AUI_CORE AString: std::u16string
{
private:
    friend struct std::hash<AString>;
    using super = std::u16string;
 
public:
 
    using iterator = super::iterator;
    using value_type = super::value_type;
    using const_iterator = super::const_iterator;
    using reverse_iterator = super::reverse_iterator;
    using const_reverse_iterator = super::const_reverse_iterator;
    auto constexpr static NPOS = super::npos;
 
 
    AString(AString&& other) noexcept
            : std::u16string(static_cast<basic_string&&>(other))
    {
    }
 
    AString(const basic_string& other) noexcept
            : basic_string<char16_t>(other)
    {
    }
 
    AString(const std::string& utf8) noexcept;
 
    AString(const AString& other) noexcept
            : super(other.c_str())
    {
    }
 
    AString(const basic_string& rhs, const std::allocator<char16_t>& allocator) noexcept
            : basic_string<char16_t>(rhs, allocator)
    {
    }
 
    template <class Iterator>
    AString(Iterator first, Iterator last) noexcept : super(first, last) {}
 
    AString() noexcept
    {
    }
 
    AString(char16_t c) noexcept : super(&c, &c + 1)
    {
 
    }
 
    AString(const char* utf8) noexcept;
 
    AString(std::string_view utf8) noexcept;
 
    explicit AString(const std::allocator<char16_t>& allocator) noexcept
            : basic_string<char16_t>(allocator)
    {
    }
 
    AString(const basic_string& rhs, size_type offset, const std::allocator<char16_t>& allocator) noexcept
            : basic_string<char16_t>(rhs, offset, allocator)
    {
    }
 
    AString(const basic_string& rhs, size_type offset, size_type count, const std::allocator<char16_t>& allocator) noexcept
            : basic_string<char16_t>(rhs, offset, count, allocator)
    {
    }
 
    AString(const char16_t* cStyleString, size_type count) noexcept
            : basic_string<char16_t>(cStyleString, count)
    {
    }
 
    AString(const char16_t* cStyleString, size_type count, const std::allocator<char16_t>& allocator) noexcept
            : basic_string<char16_t>(cStyleString, count, allocator)
    {
    }
 
    AString(const char16_t* cStyleString) noexcept
            : basic_string<char16_t>(cStyleString)
    {
    }
 
    AString(const char16_t* cStyleString, const std::allocator<char16_t>& allocator) noexcept
            : basic_string<char16_t>(cStyleString, allocator)
    {
    }
 
    AString(size_type count, char16_t _Ch) noexcept
            : basic_string<char16_t>(count, _Ch)
    {
    }
 
    AString(size_type count, char16_t _Ch, const std::allocator<char16_t>& allocator) noexcept
            : basic_string<char16_t>(count, _Ch, allocator)
    {
    }
 
    AString(basic_string&& rhs) noexcept
            : basic_string<char16_t>(std::move(rhs))
    {
    }
 
    AString(basic_string&& rhs, const std::allocator<char16_t>& allocator) noexcept
            : basic_string<char16_t>(std::move(rhs), allocator)
    {
    }
 
    AString(std::initializer_list<char16_t> _Ilist) noexcept
            : basic_string<char16_t>(_Ilist)
    {
    }
 
    ~AString() = default;
 
 
    void push_back(char16_t c) noexcept
    {
        super::push_back(c);
    }
    void pop_back() noexcept
    {
        super::pop_back();
    }
 
    AString uppercase() const;
    AString lowercase() const;
 
    bool startsWith(const AString& other) const noexcept
    {
        return rfind(other, 0) == 0;
    }
    bool startsWith(char16_t c) const noexcept
    {
        return rfind(c, 0) == 0;
    }
    bool endsWith(const AString& other) const noexcept
    {
        if (length() < other.length())
        {
            return false;
        }
        size_t offset = length() - other.length();
        return super::find(other, offset) == offset;
    }
    bool endsWith(char16_t c) const noexcept
    {
        size_t offset = length() - 1;
        return super::find(c, offset) == offset;
    }
 
    AStringVector split(char16_t c) const noexcept;
 
    size_type find(char c, size_type offset = 0) const noexcept
    {
        return super::find(c, offset);
    }
    size_type find(char16_t c, size_type offset = 0) const noexcept
    {
        return super::find(c, offset);
    }
    size_type find(const AString& str, size_type offset = 0) const noexcept
    {
        return super::find(str, offset);
    }
    size_type rfind(char c, size_type offset = NPOS) const noexcept
    {
        return super::rfind(c, offset);
    }
    size_type rfind(char16_t c, size_type offset = NPOS) const noexcept
    {
        return super::rfind(c, offset);
    }
    size_type rfind(const AString& str, size_type offset = NPOS) const noexcept
    {
        return super::rfind(str, offset);
    }
    size_type length() const noexcept
    {
        return super::length();
    }
    AString trimLeft(char16_t symbol = ' ') const noexcept;
    AString trimRight(char16_t symbol = ' ') const noexcept;
 
    AString trim(char16_t symbol = ' ') const noexcept
    {
        return trimRight(symbol).trimLeft(symbol);
    }
 
    void reserve(size_t s)
    {
        super::reserve(s);
    }
    void resize(size_t s)
    {
        super::resize(s);
    }
 
    AString restrictLength(size_t s, const AString& stringAtEnd = "...") const;
 
    char16_t* data() noexcept
    {
        return super::data();
    }
 
    const char16_t* data() const noexcept
    {
        return super::data();
    }
    AString& replaceAll(const AString& from, const AString& to);
    [[nodiscard]] AString replacedAll(const AString& from, const AString& to) const;
    [[nodiscard]] inline AString replacedAll(char16_t from, char16_t to) const noexcept {
        AString copy;
        copy.reserve(length() + 10);
        for (auto c : *this) {
            if (c == from) {
                copy << to;
            } else {
                copy << c;
            }
        }
        return copy;
    }
    [[nodiscard]] inline AString replacedAll(const ASet<char16_t>& from, char16_t to) const noexcept {
        AString copy;
        copy.reserve(length() + 10);
        for (auto c : *this) {
            if (from.contains(c)) {
                copy << to;
            } else {
                copy << c;
            }
        }
        return copy;
    }
    AString& replaceAll(char16_t from, char16_t to) noexcept;
 
 
    template<typename OtherContainer>
    void insertAll(const OtherContainer& c) noexcept {
        super::insert(super::end(), c.begin(), c.end());
    }
 
    [[nodiscard]]
    AOptional<float> toFloat() const noexcept;
 
    [[nodiscard]]
    AOptional<double> toDouble() const noexcept;
 
    [[nodiscard]]
    double toDoubleOrException() const noexcept {
        return toDouble().valueOrException(fmt::format("bad double: {}", toStdString()).c_str());
    }
 
    [[nodiscard]]
    AOptional<int> toInt() const noexcept;
 
    [[nodiscard]]
    int toIntOrException() const {
        return toInt().valueOrException(fmt::format("bad int: {}", toStdString()).c_str());
    }
 
    [[nodiscard]]
    AOptional<int64_t> toLongInt() const noexcept;
 
    [[nodiscard]]
    int64_t toLongIntOrException() const {
        return toLongInt().valueOrException(fmt::format("bad to number conversion: {}", toStdString()).c_str());
    }
 
    [[nodiscard]]
    AOptional<unsigned> toUInt() const noexcept;
 
    [[nodiscard]]
    unsigned toUIntOrException() const {
        return toUInt().valueOrException(fmt::format("bad to number conversion: {}", toStdString()).c_str());
    }
 
    [[nodiscard]]
    bool toBool() const noexcept {
        return *this == "true";
    }
 
    [[nodiscard]]
    bool contains(char16_t c) const noexcept
    {
        return find(c) != npos;
    }
    [[nodiscard]]
    bool contains(const AString& other) const noexcept
    {
        return find(other) != npos;
    }
 
    static AString fromLatin1(const AByteBuffer& buffer);
    static AString fromUtf8(const AByteBufferView& buffer);
    static AString fromUtf8(const char* buffer, size_t length);
    static AString fromLatin1(const char* buffer);
 
    static AString numberHex(int i) noexcept;
 
    template<typename T, std::enable_if_t<std::is_integral_v<std::decay_t<T>> || std::is_floating_point_v<std::decay_t<T>>, int> = 0>
    static AString number(T i) noexcept {
        if constexpr (std::is_same_v<bool, std::decay_t<T>>) {
            if (i)
                return "true";
            return "false";
        } else {
            auto v = std::to_string(i);
            if constexpr (std::is_floating_point_v<T>) {
                // remove trailing zeros
                v.erase(v.find_last_not_of('0') + 1, std::u16string::npos);
                v.erase(v.find_last_not_of('.') + 1, std::u16string::npos);
            }
            return v;
        }
    }
 
    static constexpr auto TO_NUMBER_BASE_BIN = 2;
    static constexpr auto TO_NUMBER_BASE_OCT = 8;
    static constexpr auto TO_NUMBER_BASE_DEC = 10;
    static constexpr auto TO_NUMBER_BASE_HEX = 16;
 
 
    AOptional<int> toNumber(aui::ranged_number<int, 2, 36> base = TO_NUMBER_BASE_DEC) const noexcept;
 
    int toNumberOrException(aui::ranged_number<int, 2, 36> base = TO_NUMBER_BASE_DEC) const {
        return toNumber(base).valueOrException(fmt::format("bad to number conversion: {}", toStdString()).c_str());
    }
 
 
    std::string toStdString() const noexcept;
 
    void resizeToNullTerminator();
 
    iterator erase(const_iterator begin, const_iterator end) noexcept
    {
        return super::erase(begin, end);
    }
    iterator erase(const_iterator begin) noexcept
    {
        return super::erase(begin);
    }
 
    AString& erase(size_type offset) noexcept
    {
        super::erase(offset);
        return *this;
    }
    AString& erase(size_type offset, size_type count) noexcept
    {
        super::erase(offset, count);
        return *this;
    }
 
    AByteBuffer toUtf8() const noexcept;
 
    void removeAt(unsigned at) noexcept
    {
        AUI_ASSERT(at <= length());
        erase(begin() + at);
    }
    AString excessSpacesRemoved() const noexcept;
 
    iterator insert(size_type at, char16_t c) noexcept
    {
        AUI_ASSERT(at <= length());
        return super::insert(begin() + at, 1, c);
    }
    iterator insert(size_type at, const AString& c) noexcept
    {
        AUI_ASSERT(at <= length());
        return super::insert(begin() + at, c.begin(), c.end());
    }
 
    template<typename Iterator>
    iterator insert(const_iterator at, Iterator begin, Iterator end) noexcept
    {
        AUI_ASSERT(std::distance(super::cbegin(), at) <= length());
        return super::insert(at, begin, end);
    }
 
    AString& operator<<(char c) noexcept
    {
        append(1, c);
        return *this;
    }
    AString& operator<<(char16_t c) noexcept
    {
        append(1, c);
        return *this;
    }
 
    inline ::AString& operator+=(const AString& str) noexcept
    {
        append(str);
        return *this;
    }
    inline ::AString& operator+=(const char* str) noexcept
    {
        *this += AString(str);
        return *this;
    }
 
    [[nodiscard]] bool empty() const noexcept {
        return super::empty();
    }
    [[nodiscard]] size_type size() const noexcept {
        return super::size();
    }
    char16_t operator[](size_type index) const
    {
        return super::at(index);
    }
    char16_t& operator[](size_type index)
    {
        return super::at(index);
    }
    bool operator<(const AString& other) const noexcept
    {
        return compare(other) < 0;
    }
 
    void clear() noexcept
    {
        super::clear();
    }
 
    char16_t& front() noexcept
    {
        return super::front();
    }
    char16_t& back() noexcept
    {
        return super::back();
    }
    const char16_t& front() const noexcept
    {
        return super::front();
    }
    const char16_t& back() const noexcept
    {
        return super::back();
    }
    char16_t& first() noexcept
    {
        return super::front();
    }
    char16_t& last() noexcept
    {
        return super::back();
    }
    const char16_t& first() const noexcept
    {
        return super::front();
    }
    const char16_t& last() const noexcept
    {
        return super::back();
    }
 
    const char16_t* c_str() const
    {
        return super::c_str();
    }
 
    iterator begin() noexcept
    {
        return super::begin();
    }
    iterator end() noexcept
    {
        return super::end();
    }
 
    const_iterator begin() const noexcept
    {
        return super::begin();
    }
    const_iterator end() const noexcept
    {
        return super::end();
    }
 
    reverse_iterator rbegin() noexcept
    {
        return super::rbegin();
    }
    reverse_iterator rend() noexcept
    {
        return super::rend();
    }
 
    const_reverse_iterator rbegin() const noexcept
    {
        return super::rbegin();
    }
    const_reverse_iterator rend() const noexcept
    {
        return super::rend();
    }
 
    AString& append(const AString& s) noexcept
    {
        super::append(s);
        return *this;
    }
 
    AString& append(size_t count, char16_t ch) noexcept
    {
        super::append(count, ch);
        return *this;
    }
 
    const AString& operator=(const AString& value) noexcept
    {
        super::operator=(value);
        return *this;
    }
 
    const AString& operator=(AString&& value) noexcept
    {
        super::operator=(value);
        return *this;
    }
 
    bool operator==(const AString& other) const noexcept
    {
        if (size() != other.size()) {
            return false;
        }
        return std::memcmp(data(), other.data(), sizeInBytes()) == 0;
    }
    bool operator==(const char16_t* other) const noexcept
    {
        auto it = begin();
        for (; it != end(); ++it, ++other) {
            if (*it != *other) {
                return false;
            }
            if (*other == '\0') {
                return false;
            }
        }
        return *other == '\0';
    }
 
    [[nodiscard]]
    size_t sizeInBytes() const noexcept {
        return size() * sizeof(super::value_type);
    }
 
    bool operator!=(const AString& other) const noexcept
    {
        return !operator==(other);
    }
    bool operator!=(const char16_t* other) const noexcept
    {
        return !operator==(other);
    }
 
    bool operator==(const char* other) const noexcept
    {
        return *this == AString(other);
    }
 
    bool operator!=(const char* other) const noexcept
    {
        return *this != AString(other);
    }
 
    template<typename... Args>
    inline AString format(Args&&... args) const;
 
    AString processEscapes() const;
 
    AString& removeAll(char16_t c) noexcept {
        erase(std::remove(begin(), end(), c));
        return *this;
    }
 
    [[nodiscard]]
    AString substr(std::size_t offset, std::size_t count = npos) const {
        return super::substr(offset, count);
    }
 
private:
    template<typename T>
    AOptional<T> toNumberImpl() const noexcept;
};
 
inline AString operator+(const AString& l, const AString& r) noexcept
{
    auto x = l;
    x.append(r);
    return x;
}
inline AString operator+(const AString& l, char16_t r) noexcept
{
    auto x = l;
    x.append(r);
    return x;
}
inline AString operator+(const AString& one, const char* other) noexcept
{
    return one + AString(other);
}
 
inline AString operator+(const char* other, const AString& one) noexcept {
    return AString(other) + one;
}
 
inline AString operator+(char lhs, const AString& cs) noexcept
{
    AString s(lhs);
    s += cs;
    return s;
}
 
inline AString operator""_as(const char* str, size_t len)
{
    return {str};
}
 
inline std::ostream& operator<<(std::ostream& o, const AString& s)
{
    o << s.toStdString();
    return o;
}
 
template<>
struct std::hash<AString>
{
    size_t operator()(const AString& t) const
    {
        return std::hash<std::u16string>()(t);
    }
};
 
#if AUI_PLATFORM_WIN
namespace aui::win32 {
    /*
     * On Windows, char16_t == wchar_t. WinAPI interfaces use wchar_t widely, so we have some handy functions to
     * convert AString to wchar_t* and back.
     */
 
    inline const wchar_t* toWchar(const AString& string) {
        // NOLINTNEXTLINE(*-pro-type-reinterpret-cast)
        return reinterpret_cast<const wchar_t *const>(string.data());
    }
 
    inline wchar_t* toWchar(AString& string) {
        // NOLINTNEXTLINE(*-pro-type-reinterpret-cast)
        return reinterpret_cast<wchar_t*>(string.data());
    }
 
    inline std::wstring_view toWcharView(const AString& string) {
        return {toWchar(string), string.length() };
    }
 
    inline AString fromWchar(std::wstring_view string) {
        // NOLINTNEXTLINE(*-pro-type-reinterpret-cast)
        return {reinterpret_cast<const char16_t *>(string.data()), string.size()};
    }
}
#endif
 
template <> struct fmt::detail::is_string<AString>: std::false_type {};
 
template <> struct fmt::formatter<AString>: fmt::formatter<std::string> {
    auto format(const AString& s, format_context& ctx) const {
        return fmt::formatter<std::string>::format(s.toStdString(), ctx);
    }
};
 
 
// gtest printer for AString
inline void PrintTo(const AString& s, std::ostream* stream) {
    *stream << s.toStdString();
}