text_formatter.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <functional>
#include <sstream>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace porytiles2 {
 
enum class Style : std::uint32_t {
    none = 0,        
    bold = 1 << 0,   
    italic = 1 << 1, 
    red = 1 << 2,    
    green = 1 << 3,  
    blue = 1 << 4,   
    yellow = 1 << 5, 
    cyan = 1 << 6,   
    magenta = 1 << 7 
};
 
[[nodiscard]] constexpr Style operator|(Style lhs, Style rhs)
{
    return static_cast<Style>(static_cast<std::uint32_t>(lhs) | static_cast<std::uint32_t>(rhs));
}
 
[[nodiscard]] constexpr Style operator&(Style lhs, Style rhs)
{
    return static_cast<Style>(static_cast<std::uint32_t>(lhs) & static_cast<std::uint32_t>(rhs));
}
 
constexpr Style &operator|=(Style &lhs, Style rhs)
{
    lhs = lhs | rhs;
    return lhs;
}
 
constexpr Style &operator&=(Style &lhs, Style rhs)
{
    lhs = lhs & rhs;
    return lhs;
}
 
[[nodiscard]] constexpr bool has_style(Style styles, Style flag)
{
    return (styles & flag) != Style::none;
}
 
class FormatParam {
  public:
    FormatParam(std::string text) : text_{std::move(text)}, styles_{Style::none} {}
 
    explicit FormatParam(std::string text, Style styles) : text_{std::move(text)}, styles_{styles} {}
 
    template <typename T>
        requires(
            !std::is_same_v<std::decay_t<T>, std::string> && !std::is_same_v<std::decay_t<T>, FormatParam> &&
            requires(std::ostringstream os, T val) { os << val; })
    FormatParam(T &&value) : FormatParam(to_string_impl(std::forward<T>(value)))
    {
    }
 
    template <typename T>
        requires(
            !std::is_same_v<std::decay_t<T>, std::string> && !std::is_same_v<std::decay_t<T>, FormatParam> &&
            requires(std::ostringstream os, T val) { os << val; })
    explicit FormatParam(T &&value, Style styles) : FormatParam(to_string_impl(std::forward<T>(value)), styles)
    {
    }
 
    [[nodiscard]] const std::string &text() const
    {
        return text_;
    }
 
    [[nodiscard]] Style styles() const
    {
        return styles_;
    }
 
  private:
    std::string text_; 
    Style styles_;     
 
    template <typename T>
    static std::string to_string_impl(T &&value)
    {
        std::ostringstream oss;
        oss << std::forward<T>(value);
        return oss.str();
    }
};
 
class TextFormatter {
  public:
    virtual ~TextFormatter() = default;
 
    [[nodiscard]] virtual std::string style(const std::string &text, Style styles) const = 0;
 
    [[nodiscard]] virtual std::string
    format(const std::string &format_str, const std::vector<FormatParam> &params) const;
 
    template <typename FirstParam, typename... RestParams>
        requires(
            !std::is_same_v<std::decay_t<FirstParam>, std::vector<FormatParam>> &&
            std::is_constructible_v<FormatParam, FirstParam> &&
            (std::is_constructible_v<FormatParam, RestParams> && ...))
    [[nodiscard]] std::string format(const std::string &format_str, FirstParam &&first, RestParams &&...rest) const
    {
        std::vector<FormatParam> param_vector;
        param_vector.reserve(1 + sizeof...(RestParams));
        param_vector.emplace_back(std::forward<FirstParam>(first));
        (param_vector.emplace_back(std::forward<RestParams>(rest)), ...);
        return this->format(format_str, param_vector);
    }
};
 
using FormattedMessageBuilder = std::function<std::vector<std::string>(const TextFormatter &)>;
 
} // namespace porytiles2