layer.hpp

Go to the documentation of this file.

#pragma once
 
#include <cctype>
#include <cstdint>
#include <format>
#include <optional>
#include <ostream>
#include <string>
 
#include "porytiles/utilities/panic/panic.hpp"
#include "porytiles/utilities/result/chainable_result.hpp"
 
namespace porytiles {
 
enum class LayerMode { dual, triple };
 
[[nodiscard]] inline LayerMode layer_mode_from_val(std::size_t s)
{
    if (s == 8) {
        return LayerMode::dual;
    }
    if (s == 12) {
        return LayerMode::triple;
    }
    panic("invalid LayerMode integer: " + std::to_string(s));
}
 
[[nodiscard]] inline std::optional<LayerMode> layer_mode_from_str(const std::string &s)
{
    if (s == "dual") {
        return LayerMode::dual;
    }
    if (s == "triple") {
        return LayerMode::triple;
    }
    return std::nullopt;
}
 
[[nodiscard]] inline std::string to_string(LayerMode mode)
{
    switch (mode) {
    case LayerMode::dual:
        return "dual";
    case LayerMode::triple:
        return "triple";
    }
    panic("unhandled LayerMode value");
}
 
inline std::ostream &operator<<(std::ostream &os, const LayerMode mode)
{
    return os << to_string(mode);
}
 
enum class LayerType : unsigned int { normal = 0, covered = 1, split = 2 };
 
[[nodiscard]] inline std::string to_string(LayerType layer_type)
{
    switch (layer_type) {
    case LayerType::normal:
        return "Normal - Middle/Top";
    case LayerType::covered:
        return "Covered - Bottom/Middle";
    case LayerType::split:
        return "Split - Bottom/Top";
    default:
        panic("to_string(LayerType) unknown LayerType");
    }
}
 
[[nodiscard]] inline ChainableResult<LayerType> layer_type_from_int(unsigned int i)
{
    if (i > static_cast<unsigned int>(LayerType::split)) {
        return FormattableError{
            "invalid layer type integer value '{}': must be 0, 1, or 2", FormatParam{i, Style::bold}};
    }
    return static_cast<LayerType>(i);
}
 
[[nodiscard]] inline std::string layer_type_csv_token(LayerType layer_type)
{
    switch (layer_type) {
    case LayerType::normal:
        return "normal";
    case LayerType::covered:
        return "covered";
    case LayerType::split:
        return "split";
    default:
        panic("layer_type_csv_token unknown LayerType");
    }
}
 
[[nodiscard]] inline ChainableResult<LayerType> layer_type_from_csv_token(const std::string &token)
{
    std::string lower;
    lower.reserve(token.size());
    for (const unsigned char c : token) {
        lower.push_back(static_cast<char>(std::tolower(c)));
    }
 
    if (lower == "normal") {
        return LayerType::normal;
    }
    if (lower == "covered") {
        return LayerType::covered;
    }
    if (lower == "split") {
        return LayerType::split;
    }
    return FormattableError{
        "invalid layer_type token '{}': must be 'normal', 'covered', or 'split'", FormatParam{token, Style::bold}};
}
 
} // namespace porytiles
 
template <>
struct std::formatter<porytiles::LayerMode> {
    constexpr auto parse(std::format_parse_context &ctx)
    {
        return ctx.begin();
    }
 
    auto format(const porytiles::LayerMode &value, auto &ctx) const
    {
        return std::format_to(ctx.out(), "{}", porytiles::to_string(value));
    }
};
 
template <>
struct std::formatter<porytiles::LayerType> {
    constexpr auto parse(std::format_parse_context &ctx)
    {
        return ctx.begin();
    }
 
    auto format(const porytiles::LayerType &value, auto &ctx) const
    {
        return std::format_to(ctx.out(), "{}", porytiles::to_string(value));
    }
};