metatile_attribute_schema.cpp

Go to the documentation of this file.

#include "porytiles/domain/models/metatile_attribute_schema.hpp"
 
#include <bit>
#include <cstddef>
#include <cstdint>
#include <format>
#include <optional>
#include <string>
#include <unordered_set>
#include <utility>
#include <vector>
 
#include "porytiles/utilities/panic/panic.hpp"
#include "porytiles/utilities/result/chainable_result.hpp"
#include "porytiles/utilities/text/text_formatter.hpp"
 
namespace porytiles {
 
namespace {
 
std::string hex_string(std::uint32_t mask)
{
    return std::format("0x{:X}", mask);
}
 
bool is_contiguous(std::uint32_t mask)
{
    return std::popcount(mask) == std::bit_width(mask) - std::countr_zero(mask);
}
 
} // namespace
 
EnumDefinition ProviderDefinition::to_enum_definition(std::string field_display_name, std::uint32_t max_value) const
{
    return EnumDefinition{
        .prefix = prefix,
        .max_value = max_value,
        .skipped = skipped,
        .format = format,
        .field_display_name = std::move(field_display_name)};
}
 
ChainableResult<Schema> Schema::create(std::vector<Field> fields, std::size_t attribute_bytes)
{
    assert_or_panic(
        attribute_bytes == 1 || attribute_bytes == 2 || attribute_bytes == 4,
        "Schema::create requires a 1-byte, 2-byte, or 4-byte attribute size");
 
    std::unordered_set<std::string> seen_names;
    std::optional<std::size_t> layer_type_index;
 
    for (std::size_t i = 0; i < fields.size(); ++i) {
        const Field &field = fields[i];
        const std::uint32_t mask = field.mask();
 
        if (seen_names.contains(field.name())) {
            return FormattableError{
                "Field '{}' is defined more than once in the schema.", FormatParam{field.name(), Style::bold}};
        }
 
        // The attributes CSV header partitions its columns by name: pin_column_prefix marks a role pin column,
        // everything else is a value column. That partition is a property of the schema, so the schema is where it is
        // enforced. This is not the old rule that reserved the bare name "layer_type": that one blocked a name
        // Porytiles' own inference produces, on behalf of a CSV detail the domain layer could not see. This one
        // reserves a namespace no C macro suffix can reach, and every field name outside it stays available.
        if (is_pin_column_name(field.name())) {
            return FormattableError{
                "Field '{}' starts with '{}', which is reserved for the attributes.csv role pin columns. Choose a "
                "field name outside that namespace.",
                FormatParam{field.name(), Style::bold},
                FormatParam{std::string{pin_column_prefix}, Style::bold}};
        }
 
        if (mask == 0) {
            return FormattableError{
                "Field '{}' has a zero mask: a field must occupy at least one bit.",
                FormatParam{field.name(), Style::bold}};
        }
 
        if (!is_contiguous(mask)) {
            return FormattableError{
                "Field '{}' has mask '{}': a field mask must be a single contiguous run of bits.",
                FormatParam{field.name(), Style::bold},
                FormatParam{hex_string(mask), Style::bold}};
        }
 
        if (static_cast<std::size_t>(std::bit_width(mask)) > attribute_bytes * 8) {
            return FormattableError{
                "Field '{}' has mask '{}', which extends beyond the '{}'-byte metatile attribute size.",
                FormatParam{field.name(), Style::bold},
                FormatParam{hex_string(mask), Style::bold},
                FormatParam{attribute_bytes, Style::bold}};
        }
 
        if (field.default_value() > field.max_value()) {
            return FormattableError{
                "Field '{}' has default value '{}', which does not fit in its {}-bit mask '{}'.",
                FormatParam{field.name(), Style::bold},
                FormatParam{field.default_value(), Style::bold},
                FormatParam{field.width()},
                FormatParam{hex_string(mask), Style::bold}};
        }
 
        // The layer_type role marks the one field whose values Porytiles manages (compile-time inference or a CSV
        // pin), so a provider or a default on it can never take effect and a second role field would be ambiguous.
        if (field.packs_layer_type()) {
            if (layer_type_index.has_value()) {
                return FormattableError{
                    "Field '{}' carries the layer_type role, but field '{}' already carries it. Only one field may "
                    "pack the layer type.",
                    FormatParam{field.name(), Style::bold},
                    FormatParam{fields[layer_type_index.value()].name(), Style::bold}};
            }
            if (field.has_provider()) {
                return FormattableError{
                    "Field '{}' carries the layer_type role, so it cannot have a value provider: its values are "
                    "managed by Porytiles.",
                    FormatParam{field.name(), Style::bold}};
            }
            if (field.default_value() != 0) {
                return FormattableError{
                    "Field '{}' carries the layer_type role, so it cannot have a default value: its values are "
                    "managed by Porytiles.",
                    FormatParam{field.name(), Style::bold}};
            }
            layer_type_index = i;
        }
 
        for (std::size_t j = 0; j < i; ++j) {
            const Field &prior = fields[j];
            if ((prior.mask() & mask) != 0) {
                return FormattableError{
                    "Field '{}' has mask '{}', which overlaps mask '{}' of field '{}'.",
                    FormatParam{field.name(), Style::bold},
                    FormatParam{hex_string(mask), Style::bold},
                    FormatParam{hex_string(prior.mask()), Style::bold},
                    FormatParam{prior.name(), Style::bold}};
            }
        }
 
        seen_names.insert(field.name());
    }
 
    return Schema{std::move(fields), attribute_bytes, layer_type_index};
}
 
} // namespace porytiles