colour.hpp

#pragma once
 
#include "terminalpp/graphics.hpp"
 
#include <boost/container_hash/hash.hpp>
 
#include <iosfwd>
#include <variant>
 
namespace terminalpp {
 
//* =========================================================================
//* =========================================================================
struct TERMINALPP_EXPORT low_colour
{
    //* =====================================================================
    //* =====================================================================
    constexpr low_colour() noexcept
      : low_colour(terminalpp::graphics::colour::default_)
    {
    }
 
    //* =====================================================================
    //* =====================================================================
    constexpr low_colour(  // NOLINT
        terminalpp::graphics::colour colour) noexcept
      : value_(colour){};
 
    //* =====================================================================
    //* =====================================================================
    [[nodiscard]] friend std::size_t hash_value(low_colour const &col) noexcept
    {
        std::size_t seed = 0;
        boost::hash_combine(
            seed,
            static_cast<std::underlying_type_t<decltype(col.value_)>>(
                col.value_));
        return seed;
    }
 
    //* =====================================================================
    //* =====================================================================
    [[nodiscard]] constexpr friend auto operator<=>(
        low_colour const &lhs, low_colour const &rhs) noexcept = default;
 
    terminalpp::graphics::colour value_;
};
 
//* =========================================================================
//* =========================================================================
TERMINALPP_EXPORT
std::ostream &operator<<(std::ostream &out, low_colour const &col);
 
//* =========================================================================
//* =========================================================================
struct TERMINALPP_EXPORT high_colour
{
    //* =====================================================================
    //* =====================================================================
    constexpr high_colour() noexcept : high_colour(0, 0, 0)
    {
    }
 
    //* =====================================================================
    //* =====================================================================
    constexpr high_colour(byte red, byte green, byte blue) noexcept
      : value_(ansi::graphics::encode_high_components(red, green, blue))
    {
    }
 
    //* =====================================================================
    //* =====================================================================
    [[nodiscard]] friend std::size_t hash_value(high_colour const &col) noexcept
    {
        std::size_t seed = 0;
        boost::hash_combine(seed, col.value_);
        return seed;
    }
 
    //* =====================================================================
    //* =====================================================================
    [[nodiscard]] constexpr friend auto operator<=>(
        high_colour const &lhs, high_colour const &rhs) noexcept = default;
 
    byte value_;
};
 
//* =========================================================================
//* =========================================================================
TERMINALPP_EXPORT
std::ostream &operator<<(std::ostream &out, high_colour const &col);
 
//* =========================================================================
//* =========================================================================
struct TERMINALPP_EXPORT greyscale_colour
{
    //* =====================================================================
    //* =====================================================================
    constexpr greyscale_colour() noexcept : shade_(0)
    {
    }
 
    //* =====================================================================
    //* =====================================================================
    constexpr explicit greyscale_colour(byte shade) noexcept
      : shade_(ansi::graphics::encode_greyscale_component(shade))
    {
    }
 
    //* =====================================================================
    //* =====================================================================
    [[nodiscard]] friend std::size_t hash_value(
        greyscale_colour const &col) noexcept
    {
        std::size_t seed = 0;
        boost::hash_combine(seed, col.shade_);
        return seed;
    }
 
    //* =====================================================================
    //* =====================================================================
    [[nodiscard]] constexpr friend auto operator<=>(
        greyscale_colour const &lhs,
        greyscale_colour const &rhs) noexcept = default;
 
    byte shade_;
};
 
//* =========================================================================
//* =========================================================================
TERMINALPP_EXPORT
std::ostream &operator<<(std::ostream &out, greyscale_colour const &col);
 
//* =========================================================================
//* =========================================================================
struct TERMINALPP_EXPORT true_colour
{
    //* =====================================================================
    //* =====================================================================
    constexpr true_colour() noexcept : true_colour(0, 0, 0)
    {
    }
 
    //* =====================================================================
    //* =====================================================================
    constexpr true_colour(
        byte const red, byte const green, byte const blue) noexcept  // NOLINT
      : red_(red), green_(green), blue_(blue)
    {
    }
 
    //* =====================================================================
    //* =====================================================================
    [[nodiscard]] friend std::size_t hash_value(true_colour const &col) noexcept
    {
        std::size_t seed = 0;
        boost::hash_combine(seed, col.red_);
        boost::hash_combine(seed, col.green_);
        boost::hash_combine(seed, col.blue_);
        return seed;
    }
 
    //* =====================================================================
    //* =====================================================================
    [[nodiscard]] constexpr friend auto operator<=>(
        true_colour const &lhs, true_colour const &rhs) noexcept = default;
 
    byte red_;
    byte green_;
    byte blue_;
};
 
//* =========================================================================
//* =========================================================================
TERMINALPP_EXPORT
std::ostream &operator<<(std::ostream &out, true_colour const &col);
 
//* =========================================================================
//* =========================================================================
struct TERMINALPP_EXPORT colour
{
    //* =====================================================================
    //* =====================================================================
    constexpr colour() noexcept : colour{terminalpp::low_colour()}
    {
    }
 
    //* =====================================================================
    //* =====================================================================
    constexpr colour(terminalpp::low_colour col) noexcept  // NOLINT
      : value_{std::move(col)}
    {
    }
 
    //* =====================================================================
    //* =====================================================================
    constexpr colour(terminalpp::graphics::colour col) noexcept  // NOLINT
      : colour{terminalpp::low_colour(col)}
    {
    }
 
    //* =====================================================================
    //* =====================================================================
    constexpr colour(terminalpp::high_colour col) noexcept  // NOLINT
      : value_{high_colour{std::move(col)}}
    {
    }
 
    //* =====================================================================
    //* =====================================================================
    constexpr colour(terminalpp::greyscale_colour col) noexcept  // NOLINT
      : value_{greyscale_colour{std::move(col)}}
    {
    }
 
    //* =====================================================================
    //* =====================================================================
    constexpr colour(terminalpp::true_colour col) noexcept  // NOLINT
      : value_{true_colour{std::move(col)}}
    {
    }
 
    //* =====================================================================
    //* =====================================================================
    [[nodiscard]] friend std::size_t hash_value(colour const &col) noexcept
    {
        return std::visit(
            [](auto const &val) { return hash_value(val); }, col.value_);
    }
 
    //* =====================================================================
    //* =====================================================================
    [[nodiscard]] constexpr friend auto operator<=>(
        colour const &lhs, colour const &rhs) noexcept = default;
 
    std::variant<low_colour, high_colour, greyscale_colour, true_colour> value_;
};
 
//* =========================================================================
//* =========================================================================
TERMINALPP_EXPORT
std::ostream &operator<<(std::ostream &out, colour const &col);
 
}  // namespace terminalpp
 
namespace std {
 
template <>
struct hash<terminalpp::low_colour>
{
    using argument_type = terminalpp::low_colour;
    using result_type = std::size_t;
 
    [[nodiscard]] result_type operator()(
        argument_type const &col) const noexcept
    {
        return hash_value(col);
    }
};
 
template <>
struct hash<terminalpp::high_colour>
{
    using argument_type = terminalpp::high_colour;
    using result_type = std::size_t;
 
    [[nodiscard]] result_type operator()(
        argument_type const &col) const noexcept
    {
        return hash_value(col);
    }
};
 
template <>
struct hash<terminalpp::greyscale_colour>
{
    using argument_type = terminalpp::greyscale_colour;
    using result_type = std::size_t;
 
    [[nodiscard]] result_type operator()(
        argument_type const &col) const noexcept
    {
        return hash_value(col);
    }
};
 
template <>
struct hash<terminalpp::true_colour>
{
    using argument_type = terminalpp::true_colour;
    using result_type = std::size_t;
 
    [[nodiscard]] result_type operator()(
        argument_type const &col) const noexcept
    {
        return hash_value(col);
    }
};
 
template <>
struct hash<terminalpp::colour>
{
    using argument_type = terminalpp::colour;
    using result_type = std::size_t;
 
    [[nodiscard]] result_type operator()(
        argument_type const &col) const noexcept
    {
        return hash_value(col);
    }
};
 
}  // namespace std