glyph_string.hpp

#ifndef TERMOX_PAINTER_GLYPH_STRING_HPP
#define TERMOX_PAINTER_GLYPH_STRING_HPP
#include <string>
#include <string_view>
#include <vector>
 
#include <termox/common/mb_to_u32.hpp>
#include <termox/painter/brush.hpp>
#include <termox/painter/color.hpp>
#include <termox/painter/glyph.hpp>
#include <termox/painter/trait.hpp>
 
namespace ox {
 
// TODO hold a vector instead of inherit from one, explicitly defer to vector
// methods instead of using = statements.
 
class Glyph_string : private std::vector<Glyph> {
   public:
    static constexpr auto npos = -1;
 
   public:
    Glyph_string() = default;
 
    explicit Glyph_string(Glyph glyph, int count = 1);
 
 
    template <typename... Attributes>
    Glyph_string(std::u32string_view symbols, Attributes... attrs)
    {
        for (char32_t c : symbols)
            this->append(Glyph{c, Brush{attrs...}});
    }
 
    template <typename... Attributes>
    Glyph_string(char32_t const* symbols, Attributes... attrs)
        : Glyph_string{std::u32string_view{symbols}, attrs...}
    {}
 
    template <typename... Attributes>
    Glyph_string(std::u32string const& symbols, Attributes... attrs)
        : Glyph_string{std::u32string_view{symbols}, attrs...}
    {}
 
 
    template <typename... Attributes>
    Glyph_string(std::string_view symbols, Attributes... attrs)
        : Glyph_string{mb_to_u32(symbols), attrs...}
    {}
 
    template <typename... Attributes>
    Glyph_string(char const* symbols, Attributes... attrs)
        : Glyph_string{std::string_view{symbols}, attrs...}
    {}
 
    template <typename... Attributes>
    Glyph_string(std::string const& symbols, Attributes... attrs)
        : Glyph_string{std::string_view{symbols}, attrs...}
    {}
 
 
    template <typename InputIterator>
    Glyph_string(InputIterator first, InputIterator last)
        : vector<Glyph>::vector(first, last)
    {}
 
   public:
    auto append(Glyph g) -> Glyph_string&;
 
    auto append(Glyph_string const& gs) -> Glyph_string&;
 
   public:
 
    [[nodiscard]] auto length() const -> int;
 
 
    [[nodiscard]] auto size() const -> int;
 
   public:
 
    [[nodiscard]] auto u32str() const -> std::u32string;
 
 
    [[nodiscard]] auto str() const -> std::string;
 
   public:
    void add_traits(Traits traits);
 
    void clear_traits();
 
    void add_color(Background_color bg);
 
    void add_color(Foreground_color fg);
 
    void remove_traits(Traits traits);
 
    void remove_background();
 
    void remove_foreground();
 
   public:
    using size_type = int;
    using std::vector<Glyph>::value_type;
    using std::vector<Glyph>::allocator_type;
    using std::vector<Glyph>::difference_type;
    using std::vector<Glyph>::reference;
    using std::vector<Glyph>::const_reference;
    using std::vector<Glyph>::pointer;
    using std::vector<Glyph>::const_pointer;
    using std::vector<Glyph>::iterator;
    using std::vector<Glyph>::const_iterator;
    using std::vector<Glyph>::reverse_iterator;
    using std::vector<Glyph>::const_reverse_iterator;
 
    using std::vector<Glyph>::operator[];
    using std::vector<Glyph>::size;
    using std::vector<Glyph>::assign;
    using std::vector<Glyph>::get_allocator;
    using std::vector<Glyph>::at;
    using std::vector<Glyph>::front;
    using std::vector<Glyph>::back;
    using std::vector<Glyph>::data;
    using std::vector<Glyph>::begin;
    using std::vector<Glyph>::cbegin;
    using std::vector<Glyph>::end;
    using std::vector<Glyph>::cend;
    using std::vector<Glyph>::rbegin;
    using std::vector<Glyph>::crbegin;
    using std::vector<Glyph>::rend;
    using std::vector<Glyph>::crend;
    using std::vector<Glyph>::empty;
    using std::vector<Glyph>::max_size;
    using std::vector<Glyph>::reserve;
    using std::vector<Glyph>::capacity;
    using std::vector<Glyph>::shrink_to_fit;
    using std::vector<Glyph>::clear;
    using std::vector<Glyph>::insert;
    using std::vector<Glyph>::erase;
    using std::vector<Glyph>::push_back;
    using std::vector<Glyph>::pop_back;
    using std::vector<Glyph>::resize;
    using std::vector<Glyph>::swap;
};
 
// Traits ----------------------------------------------------------------------
 
auto operator|=(Glyph_string& gs, Traits ts) -> Glyph_string&;
 
[[nodiscard]] auto operator|(Glyph_string gs, Traits ts) -> Glyph_string;
 
}  // namespace ox
 
namespace esc {  // For ADL; Trait(s) is really in namespace::esc.
 
[[nodiscard]] auto operator|(char32_t const* gs, Trait t) -> ox::Glyph_string;
 
[[nodiscard]] auto operator|(char32_t const* gs, Traits ts) -> ox::Glyph_string;
 
[[nodiscard]] auto operator|(char const* gs, Trait t) -> ox::Glyph_string;
 
[[nodiscard]] auto operator|(char const* gs, Traits ts) -> ox::Glyph_string;
 
}  // namespace esc
 
namespace ox {
 
// Background_color ------------------------------------------------------------
auto operator|=(Glyph_string& gs, Background_color c) -> Glyph_string&;
 
[[nodiscard]] auto operator|(Glyph_string gs, Background_color c)
    -> Glyph_string;
 
[[nodiscard]] auto operator|(char32_t const* gs, Background_color c)
    -> Glyph_string;
 
// Foreground_color ------------------------------------------------------------
auto operator|=(Glyph_string& gs, Foreground_color c) -> Glyph_string&;
 
[[nodiscard]] auto operator|(Glyph_string gs, Foreground_color c)
    -> Glyph_string;
 
[[nodiscard]] auto operator|(char32_t const* gs, Foreground_color c)
    -> Glyph_string;
 
// Brush -----------------------------------------------------------------------
auto operator|=(Glyph_string& gs, Brush b) -> Glyph_string&;
 
[[nodiscard]] auto operator|(Glyph_string gs, Brush b) -> Glyph_string;
 
[[nodiscard]] auto operator|(char32_t const* gs, Brush b) -> Glyph_string;
 
// Comparison ------------------------------------------------------------------
 
[[nodiscard]] auto operator==(Glyph_string const& x, Glyph_string const& y)
    -> bool;
 
[[nodiscard]] auto operator!=(Glyph_string const& x, Glyph_string const& y)
    -> bool;
 
}  // namespace ox
#endif  // TERMOX_PAINTER_GLYPH_STRING_HPP