string.hpp

#pragma once
 
#include "terminalpp/element.hpp"
 
#include <boost/container_hash/hash.hpp>
 
#include <algorithm>
#include <concepts>  // IWYU pragma: keep
#include <initializer_list>
#include <string>
#include <vector>
#include <cstddef>
 
namespace terminalpp {
 
//* =========================================================================
//* =========================================================================
class TERMINALPP_EXPORT string
{
    using elements_storage = std::vector<element>;
 
public:
    //* =====================================================================
    //* =====================================================================
    using value_type = element;
    using reference = value_type &;
    using const_reference = value_type const &;
    using pointer = element *;
    using const_pointer = element const *;
    using iterator = elements_storage::iterator;
    using const_iterator = elements_storage::const_iterator;
    using reverse_iterator = elements_storage::reverse_iterator;
    using const_reverse_iterator = elements_storage::const_reverse_iterator;
    using difference_type = std::ptrdiff_t;
    using size_type = std::size_t;
 
    //* =====================================================================
    //* =====================================================================
    constexpr string() = default;
 
    //* =====================================================================
    //* =====================================================================
    template <std::forward_iterator ForwardIterator>
    constexpr string(ForwardIterator &&begin, ForwardIterator &&end)
      : elements_{begin, end}
    {
    }
 
    //* =====================================================================
    //* =====================================================================
    constexpr string(std::initializer_list<element> const &ilist)
      : string{ilist.begin(), ilist.end()}
    {
    }
 
    //* =====================================================================
    //* =====================================================================
    constexpr string(char const *text)  // NOLINT
      : string{text, std::char_traits<char>::length(text)}
    {
    }
 
    //* =====================================================================
    //* =====================================================================
    constexpr string(char const *text, size_type len)
      : elements_{text, text + len}
    {
    }
 
    //* =====================================================================
    //* =====================================================================
    constexpr string(std::string const &text)  // NOLINT
      : string{text.data(), text.size()}
    {
    }
 
    //* =====================================================================
    //* =====================================================================
    constexpr string(std::string const &text, terminalpp::attribute const &attr)
      : string{text}
    {
        std::ranges::for_each(
            elements_, [&attr](auto &elem) { elem.attribute_ = attr; });
    }
 
    //* =====================================================================
    //* =====================================================================
    constexpr string(size_type size, terminalpp::element const &elem)
      : elements_(size, elem)
    {
    }
 
    //* =====================================================================
    //* =====================================================================
    [[nodiscard]] constexpr size_type size() const noexcept
    {
        return elements_.size();
    }
 
    //* =====================================================================
    //* =====================================================================
    [[nodiscard]] constexpr iterator begin() noexcept
    {
        return elements_.begin();
    }
 
    //* =====================================================================
    //* =====================================================================
    [[nodiscard]] constexpr const_iterator begin() const noexcept
    {
        return elements_.begin();
    }
 
    //* =====================================================================
    //* =====================================================================
    [[nodiscard]] constexpr reverse_iterator rbegin() noexcept
    {
        return elements_.rbegin();
    }
 
    //* =====================================================================
    //* =====================================================================
    [[nodiscard]] constexpr const_reverse_iterator rbegin() const noexcept
    {
        return elements_.rbegin();
    }
 
    //* =====================================================================
    //* =====================================================================
    [[nodiscard]] constexpr iterator end() noexcept
    {
        return elements_.end();
    }
 
    //* =====================================================================
    //* =====================================================================
    [[nodiscard]] constexpr const_iterator end() const noexcept
    {
        return elements_.end();
    }
 
    //* =====================================================================
    //* =====================================================================
    [[nodiscard]] constexpr reverse_iterator rend() noexcept
    {
        return elements_.rend();
    }
 
    //* =====================================================================
    //* =====================================================================
    [[nodiscard]] constexpr const_reverse_iterator rend() const noexcept
    {
        return elements_.rend();
    }
 
    //* =====================================================================
    //* =====================================================================
    [[nodiscard]] constexpr const_iterator cbegin() noexcept
    {
        return elements_.cbegin();
    }
 
    //* =====================================================================
    //* =====================================================================
    [[nodiscard]] constexpr const_iterator cend() noexcept
    {
        return elements_.cend();
    }
 
    //* =====================================================================
    //* =====================================================================
    constexpr void swap(string &other) noexcept
    {
        std::swap(elements_, other.elements_);
    }
 
    //* =====================================================================
    //* =====================================================================
    [[nodiscard]] constexpr size_type max_size() const noexcept
    {
        return std::numeric_limits<size_type>::max();
    }
 
    //* =====================================================================
    //* =====================================================================
    [[nodiscard]] constexpr bool empty() const noexcept
    {
        return elements_.empty();
    }
 
    //* =====================================================================
    //* =====================================================================
    [[nodiscard]] constexpr reference operator[](size_type index) noexcept
    {
        return elements_[index];
    }
 
    //* =====================================================================
    //* =====================================================================
    [[nodiscard]] constexpr const_reference operator[](
        size_type index) const noexcept
    {
        return elements_[index];
    }
 
    //* =====================================================================
    //* =====================================================================
    constexpr string &operator+=(element const &elem)
    {
        elements_.insert(elements_.end(), elem);
        return *this;
    }
 
    //* =====================================================================
    //* =====================================================================
    [[nodiscard]] friend string operator+(string lhs, element const &rhs)
    {
        return lhs += rhs;
    }
 
    //* =====================================================================
    //* =====================================================================
    constexpr string &operator+=(string const &rhs)
    {
        elements_.insert(elements_.end(), rhs.begin(), rhs.end());
        return *this;
    }
 
    //* =====================================================================
    //* =====================================================================
    [[nodiscard]] friend string operator+(string lhs, string const &rhs)
    {
        return lhs += rhs;
    }
 
    //* =====================================================================
    //* =====================================================================
    constexpr void insert(iterator pos, element const &elem)
    {
        elements_.insert(pos, elem);
    }
 
    //* =====================================================================
    //* =====================================================================
    template <class InputIterator>
    constexpr void insert(
        iterator pos, InputIterator range_begin, InputIterator range_end)
    {
        elements_.insert(pos, range_begin, range_end);
    }
 
    //* =====================================================================
    //* =====================================================================
    constexpr void erase()
    {
        elements_.clear();
    }
 
    //* =====================================================================
    //* =====================================================================
    constexpr void erase(iterator range_begin)
    {
        elements_.erase(range_begin, elements_.end());
    }
 
    //* =====================================================================
    //* =====================================================================
    constexpr void erase(iterator range_begin, iterator range_end)
    {
        elements_.erase(range_begin, range_end);
    }
 
    //* =====================================================================
    //* =====================================================================
    [[nodiscard]] constexpr friend auto operator<=>(
        string const &lhs, string const &rhs) noexcept = default;
 
    //* =====================================================================
    //* =====================================================================
    TERMINALPP_EXPORT
    constexpr friend bool operator==(
        string const &lhs, string const &rhs) noexcept = default;
 
    //* =====================================================================
    //* =====================================================================
    [[nodiscard]] friend std::size_t hash_value(string const &str) noexcept
    {
        return boost::hash_range(str.elements_.begin(), str.elements_.end());
    }
 
private:
    elements_storage elements_;
};
 
//* =========================================================================
//* =========================================================================
TERMINALPP_EXPORT
std::ostream &operator<<(std::ostream &out, string const &text);
 
//* =========================================================================
//* =========================================================================
TERMINALPP_EXPORT
[[nodiscard]] constexpr ::std::string to_string(terminalpp::string const &tstr)
{
    std::string result;
 
    for (auto const &elem : tstr)
    {
        if (elem.glyph_.charset_ == charset::utf8)
        {
            for (auto const &ch : elem.glyph_.ucharacter_)
            {
                if (ch == 0)
                {
                    break;
                }
 
                result += static_cast<char>(ch);
            }
        }
        else
        {
            result += static_cast<char>(elem.glyph_.character_);
        }
    }
 
    return result;
}
 
//* =========================================================================
//* =========================================================================
TERMINALPP_EXPORT
constexpr terminalpp::string encode(std::span<char const> text)
{
    string result;
    element prev_element;
 
    while (!text.empty())
    {
        result += detail::parse_element(text, prev_element);
        prev_element = *result.rbegin();
    }
 
    return result;
}
 
inline namespace literals {
inline namespace string_literals {
 
//* =========================================================================
//* =========================================================================
TERMINALPP_EXPORT
[[nodiscard]] constexpr ::terminalpp::string operator""_ts(
    char const *text, ::terminalpp::string::size_type length)
{
    return {text, length};
}
 
//* =========================================================================
//* =========================================================================
TERMINALPP_EXPORT
[[nodiscard]] constexpr ::terminalpp::string operator""_ets(
    char const *text, ::terminalpp::string::size_type length)
{
    return encode(std::span{text, length});
}
 
}  // namespace string_literals
}  // namespace literals
}  // namespace terminalpp
 
namespace std {
 
template <>
struct hash<terminalpp::string>
{
    using argument_type = terminalpp::string;
    using result_type = std::size_t;
 
    [[nodiscard]] result_type operator()(
        argument_type const &str) const noexcept
    {
        return hash_value(str);
    }
};
 
}  // namespace std