styler.hpp

#pragma once
 
#include "fly/concepts/concepts.hpp"
#include "fly/fly.hpp"
#include "fly/logger/detail/styler_proxy.hpp"
#include "fly/types/numeric/literals.hpp"
 
#include <cstdint>
#include <memory>
#include <ostream>
#include <stack>
#include <utility>
 
namespace fly::logger {
 
enum class Style : std::uint8_t
{
    Default,
    Blink,
    Bold,
    Dim,
    Italic,
    Strike,
    Underline,
};
 
struct Color
{
    enum StandardColor
    {
        Black,
        Red,
        Green,
        Yellow,
        Blue,
        Magenta,
        Cyan,
        White,
    };
 
    enum Plane
    {
        Foreground,
        Background,
    };
 
    explicit constexpr Color(std::uint8_t color, Plane plane = Foreground) noexcept :
        m_color(color),
        m_plane(plane)
    {
    }
 
    const std::uint8_t m_color;
    const Plane m_plane;
};
 
struct Cursor
{
    enum Direction
    {
        Up,
        Down,
        Forward,
        Backward,
    };
 
    constexpr Cursor(Direction direction, std::uint8_t distance = 1) noexcept :
        m_direction(direction),
        m_distance(distance > 0 ? distance : 1)
    {
    }
 
    const Direction m_direction;
    const std::uint8_t m_distance;
};
 
template <typename T>
concept Modifier = fly::SameAsAny<T, Style, Color, Color::StandardColor, Cursor, Cursor::Direction>;
 
class Styler
{
public:
    template <Modifier ModifierType>
    explicit Styler(ModifierType &&modifier) noexcept
    {
        set_modifier(modifier);
    }
 
    template <Modifier ModifierType, Modifier... ModifierTypes>
    Styler(ModifierType &&modifier, ModifierTypes &&...modifiers) noexcept :
        Styler(std::forward<ModifierTypes>(modifiers)...)
    {
        set_modifier(modifier);
    }
 
    friend detail::StylerProxy &operator<<(std::ostream &stream, const Styler &styler);
 
private:
    template <Modifier ModifierType>
    void set_modifier(ModifierType &&modifier)
    {
        if constexpr (fly::SameAs<ModifierType, Style>)
        {
            m_styles.emplace(std::move(modifier));
        }
        else if constexpr (fly::SameAsAny<ModifierType, Color, Color::StandardColor>)
        {
            m_colors.emplace(std::move(modifier));
        }
        else if constexpr (fly::SameAsAny<ModifierType, Cursor, Cursor::Direction>)
        {
            m_cursors.emplace(std::move(modifier));
        }
    }
 
    // Store modifier instances in a stack because the variadic constructor processes parameters
    // from right-to-left (due to the delegating constructor invocation).
    std::stack<Style> m_styles;
    std::stack<Color> m_colors;
    std::stack<Cursor> m_cursors;
 
    std::unique_ptr<detail::StylerProxy> m_proxy;
};
 
} // namespace fly::logger
 
namespace fly {
inline namespace literals {
    inline namespace styler_literals {
 
        template <char... Literals>
        FLY_CONSTEVAL inline fly::logger::Color operator"" _c()
        {
            // Convert to std::uint8_t via numeric literal to ensure the provided color is valid.
            const std::uint8_t validated_color = operator"" _u8<Literals...>();
            return fly::logger::Color(validated_color);
        }
 
    } // namespace styler_literals
} // namespace literals
} // namespace fly