metatile_attribute_schema.hpp

Go to the documentation of this file.

#pragma once
 
#include <bit>
#include <cstddef>
#include <cstdint>
#include <filesystem>
#include <format>
#include <optional>
#include <ostream>
#include <string>
#include <string_view>
#include <unordered_set>
#include <utility>
#include <vector>
 
#include "porytiles/utilities/panic/panic.hpp"
#include "porytiles/utilities/result/chainable_result.hpp"
 
namespace porytiles {
 
enum class HeaderFormat { defines_only, enums_only, either };
 
[[nodiscard]] inline std::string to_string(HeaderFormat format)
{
    switch (format) {
    case HeaderFormat::defines_only:
        return "defines-only";
    case HeaderFormat::enums_only:
        return "enums-only";
    case HeaderFormat::either:
        return "either";
    }
    panic("unhandled HeaderFormat value");
}
 
inline std::ostream &operator<<(std::ostream &os, const HeaderFormat format)
{
    return os << to_string(format);
}
 
enum class FieldRole { layer_type };
 
[[nodiscard]] inline std::string to_string(FieldRole role)
{
    switch (role) {
    case FieldRole::layer_type:
        return "layer_type";
    }
    panic("unhandled FieldRole value");
}
 
[[nodiscard]] inline std::optional<FieldRole> field_role_from_string(const std::string &text)
{
    if (text == "layer_type") {
        return FieldRole::layer_type;
    }
    return std::nullopt;
}
 
inline std::ostream &operator<<(std::ostream &os, const FieldRole role)
{
    return os << to_string(role);
}
 
inline constexpr std::string_view pin_column_prefix = "pin::";
 
[[nodiscard]] inline std::string pin_column_name(FieldRole role)
{
    return std::string{pin_column_prefix} + to_string(role);
}
 
[[nodiscard]] inline bool is_pin_column_name(const std::string &name)
{
    return name.starts_with(pin_column_prefix);
}
 
[[nodiscard]] inline std::optional<FieldRole> role_from_pin_column_name(const std::string &name)
{
    if (!is_pin_column_name(name)) {
        return std::nullopt;
    }
    return field_role_from_string(name.substr(pin_column_prefix.size()));
}
 
struct EnumDefinition;
 
struct ProviderDefinition {
    std::filesystem::path header;
    std::string prefix;
    std::unordered_set<std::string> skipped{};
    HeaderFormat format{HeaderFormat::either};
 
    bool operator==(const ProviderDefinition &) const = default;
 
    [[nodiscard]] EnumDefinition to_enum_definition(std::string field_display_name, std::uint32_t max_value) const;
};
 
struct EnumDefinition {
    std::string prefix;
    std::uint32_t max_value;
    std::unordered_set<std::string> skipped{};
    HeaderFormat format{HeaderFormat::either};
    std::string field_display_name;
 
    bool operator==(const EnumDefinition &) const = default;
};
 
class Field {
  public:
    Field(
        std::string name,
        std::uint32_t mask,
        std::uint32_t default_value = 0,
        std::optional<ProviderDefinition> provider = std::nullopt,
        std::optional<FieldRole> role = std::nullopt)
        : name_{std::move(name)}, mask_{mask}, default_value_{default_value}, provider_{std::move(provider)},
          role_{role}
    {
    }
 
    [[nodiscard]] const std::string &name() const
    {
        return name_;
    }
 
    [[nodiscard]] std::uint32_t mask() const
    {
        return mask_;
    }
 
    [[nodiscard]] std::uint32_t default_value() const
    {
        return default_value_;
    }
 
    [[nodiscard]] std::uint32_t offset() const
    {
        return static_cast<std::uint32_t>(std::countr_zero(mask_));
    }
 
    [[nodiscard]] std::uint32_t width() const
    {
        return static_cast<std::uint32_t>(std::popcount(mask_));
    }
 
    [[nodiscard]] std::uint32_t max_value() const
    {
        return mask_ >> offset();
    }
 
    [[nodiscard]] bool has_provider() const
    {
        return provider_.has_value();
    }
 
    [[nodiscard]] const std::optional<FieldRole> &role() const
    {
        return role_;
    }
 
    [[nodiscard]] bool packs_layer_type() const
    {
        return role_ == FieldRole::layer_type;
    }
 
    [[nodiscard]] const ProviderDefinition &provider_definition() const
    {
        assert_or_panic(provider_.has_value(), "Field::provider_definition() called on a field with no provider");
        return provider_.value();
    }
 
  private:
    std::string name_;
    std::uint32_t mask_;
    std::uint32_t default_value_;
    std::optional<ProviderDefinition> provider_;
    std::optional<FieldRole> role_;
};
 
class Schema {
  public:
    [[nodiscard]] static ChainableResult<Schema> create(std::vector<Field> fields, std::size_t attribute_bytes);
 
    [[nodiscard]] const std::vector<Field> &fields() const
    {
        return fields_;
    }
 
    [[nodiscard]] const std::vector<Field> &value_fields() const
    {
        return value_fields_;
    }
 
    [[nodiscard]] std::size_t attribute_bytes() const
    {
        return attribute_bytes_;
    }
 
    [[nodiscard]] const Field *layer_type_field() const
    {
        return layer_type_index_.has_value() ? &fields_[layer_type_index_.value()] : nullptr;
    }
 
    [[nodiscard]] std::uint32_t layer_type_mask() const
    {
        return layer_type_mask_;
    }
 
    [[nodiscard]] std::uint32_t layer_type_offset() const
    {
        return static_cast<std::uint32_t>(std::countr_zero(layer_type_mask_));
    }
 
  private:
    Schema(std::vector<Field> fields, std::size_t attribute_bytes, std::optional<std::size_t> layer_type_index)
        : fields_{std::move(fields)}, attribute_bytes_{attribute_bytes}, layer_type_index_{layer_type_index},
          layer_type_mask_{layer_type_index.has_value() ? fields_[layer_type_index.value()].mask() : 0}
    {
        for (const Field &field : fields_) {
            if (!field.packs_layer_type()) {
                value_fields_.push_back(field);
            }
        }
    }
 
    std::vector<Field> fields_;
    // The non-role fields, materialized once at creation so CSV-facing consumers cannot forget to skip the
    // layer_type-role field. Safe to duplicate: a Schema is immutable after creation.
    std::vector<Field> value_fields_;
    std::size_t attribute_bytes_;
    // Index rather than pointer so the cache survives Schema copies and moves.
    std::optional<std::size_t> layer_type_index_;
    std::uint32_t layer_type_mask_;
};
 
} // namespace porytiles
 
template <>
struct std::formatter<porytiles::HeaderFormat> {
    constexpr auto parse(std::format_parse_context &ctx)
    {
        return ctx.begin();
    }
 
    auto format(const porytiles::HeaderFormat &value, auto &ctx) const
    {
        return std::format_to(ctx.out(), "{}", porytiles::to_string(value));
    }
};
 
template <>
struct std::formatter<porytiles::FieldRole> {
    constexpr auto parse(std::format_parse_context &ctx)
    {
        return ctx.begin();
    }
 
    auto format(const porytiles::FieldRole &value, auto &ctx) const
    {
        return std::format_to(ctx.out(), "{}", porytiles::to_string(value));
    }
};