flags.hpp

 
#ifndef UFO_VISION_COLOR_FLAGS_HPP
#define UFO_VISION_COLOR_FLAGS_HPP
 
// STL
#include <cstdint>
#include <format>
#include <ostream>
#include <string_view>
#include <utility>
 
namespace ufo
{
enum class ColorFlags : std::uint8_t {
    None   = 0,              
    Alpha  = 1 << 0,         
    Weight = 1 << 1,         
    All    = Alpha | Weight  
};
 
[[nodiscard]] constexpr ColorFlags operator|(ColorFlags a, ColorFlags b) noexcept
{
    return static_cast<ColorFlags>(std::to_underlying(a) | std::to_underlying(b));
}
 
[[nodiscard]] constexpr ColorFlags operator&(ColorFlags a, ColorFlags b) noexcept
{
    return static_cast<ColorFlags>(std::to_underlying(a) & std::to_underlying(b));
}
 
[[nodiscard]] constexpr ColorFlags operator~(ColorFlags a) noexcept
{
    // Mask to the two defined bits so the result is always a valid combination.
    return static_cast<ColorFlags>(~std::to_underlying(a) &
                                   std::to_underlying(ColorFlags::All));
}
 
[[nodiscard]] consteval bool alphaset(ColorFlags flags) noexcept
{
    return (flags & ColorFlags::Alpha) != ColorFlags::None;
}
 
[[nodiscard]] consteval bool weightset(ColorFlags flags) noexcept
{
    return (flags & ColorFlags::Weight) != ColorFlags::None;
}
 
[[nodiscard]] constexpr std::string_view toString(ColorFlags flags) noexcept
{
    using enum ColorFlags;
    switch (flags) {
        case None: return "None";
        case Alpha: return "Alpha";
        case Weight: return "Weight";
        case (Alpha | Weight): return "Alpha|Weight";
    }
    std::unreachable();
}
 
inline std::ostream& operator<<(std::ostream& os, ColorFlags flags)
{
    return os << toString(flags);
}
 
}  // namespace ufo
 
template <>
struct std::formatter<ufo::ColorFlags> : std::formatter<std::string_view> {
    auto format(ufo::ColorFlags flags, std::format_context& ctx) const
    {
        return std::formatter<std::string_view>::format(ufo::toString(flags), ctx);
    }
};
 
#endif  // UFO_VISION_COLOR_FLAGS_HPP