override_config_provider.cpp

Go to the documentation of this file.

#include "porytiles/infra/config/override_config_provider.hpp"
 
#include <string>
#include <utility>
 
// NOTE: DO NOT EDIT THIS FILE DIRECTLY. It is AUTO-GENERATED from config_schema.yaml.
// To add new config values or make other changes, edit config_schema.yaml and regenerate via:
//
//   uv run scripts/generate_config.py
 
namespace porytiles {
 
OverrideConfigProvider::OverrideConfigProvider(ConfigScopeType scope_type, std::string scope, std::string source_info)
    : scope_type_{scope_type}, scope_{std::move(scope)}, source_info_{std::move(source_info)}
{
}
 
std::string OverrideConfigProvider::name() const
{
    return "OverrideConfigProvider(" + source_info_ + ")";
}
 
bool OverrideConfigProvider::scope_matches(ConfigScopeType type, const std::string &scope) const
{
    return type == scope_type_ && scope == scope_;
}
 
void OverrideConfigProvider::set_num_tiles_in_primary(std::size_t value)
{
    num_tiles_in_primary_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_num_tiles_total(std::size_t value)
{
    num_tiles_total_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_num_metatiles_in_primary(std::size_t value)
{
    num_metatiles_in_primary_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_num_metatiles_total(std::size_t value)
{
    num_metatiles_total_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_num_palettes_in_primary(std::size_t value)
{
    num_palettes_in_primary_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_num_palettes_total(std::size_t value)
{
    num_palettes_total_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_max_map_data_size(std::size_t value)
{
    max_map_data_size_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_num_tiles_per_metatile(std::size_t value)
{
    num_tiles_per_metatile_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_extrinsic_transparency(Rgba32 value)
{
    extrinsic_transparency_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_ignore_triple_layer_content(bool value)
{
    ignore_triple_layer_content_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_tiles_edit_mode(ArtifactEditMode value)
{
    tiles_edit_mode_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_palettes_edit_mode(ArtifactEditMode value)
{
    palettes_edit_mode_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_palette_hints_enabled(bool value)
{
    palette_hints_enabled_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_palette_hints(std::vector<PaletteHint> value)
{
    palette_hints_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_packing_strategy(PackingStrategyType value)
{
    packing_strategy_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_packing_strategy_params(PackingStrategyParams value)
{
    packing_strategy_params_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_tile_sharing_packing(TileSharingPacking value)
{
    tile_sharing_packing_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_tile_sharing_alignment(TileSharingAlignment value)
{
    tile_sharing_alignment_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_tiles_palette_mode(TilesPaletteMode value)
{
    tiles_palette_mode_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_global_anim_palette_resolution_strategy(AnimPaletteResolutionStrategy value)
{
    global_anim_palette_resolution_strategy_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_global_anim_key_frame_resolution_strategy(AnimKeyFrameResolutionStrategy value)
{
    global_anim_key_frame_resolution_strategy_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_global_anim_multi_palette_subtile_resolution_strategy(
    AnimMultiPaletteSubtileResolutionStrategy value)
{
    global_anim_multi_palette_subtile_resolution_strategy_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_global_frame_linking(FrameLinking value)
{
    global_frame_linking_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_per_anim_overrides(PerAnimOverrides value)
{
    per_anim_overrides_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_cross_tileset_anim_linking(bool value)
{
    cross_tileset_anim_linking_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_verify_checksums(bool value)
{
    verify_checksums_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_primary_pairing_mode(PrimaryPairingMode value)
{
    primary_pairing_mode_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_primary_pairing_partners(std::vector<std::string> value)
{
    primary_pairing_partners_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_diagnostic_warnings_exclude(std::vector<std::string> value)
{
    diagnostic_warnings_exclude_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_diagnostic_warnings_include(std::vector<std::string> value)
{
    diagnostic_warnings_include_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_diagnostic_remarks_exclude(std::vector<std::string> value)
{
    diagnostic_remarks_exclude_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_diagnostic_remarks_include(std::vector<std::string> value)
{
    diagnostic_remarks_include_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_tileset_paths_primary_src(std::string value)
{
    tileset_paths_primary_src_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_tileset_paths_primary_bin(std::string value)
{
    tileset_paths_primary_bin_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_tileset_paths_secondary_src(std::string value)
{
    tileset_paths_secondary_src_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_tileset_paths_secondary_bin(std::string value)
{
    tileset_paths_secondary_bin_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_metatile_attribute_size(std::optional<std::size_t> value)
{
    metatile_attribute_size_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_metatile_attribute_declaration_size(std::optional<std::size_t> value)
{
    metatile_attribute_declaration_size_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_metatile_attribute_fields(MetatileAttributeFieldDefinitions value)
{
    metatile_attribute_fields_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_metatile_attribute_field_overrides(MetatileAttributeFieldOverrides value)
{
    metatile_attribute_field_overrides_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_role_pins(RolePinDefinitions value)
{
    role_pins_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_tileset_animations_wire_anim_code(bool value)
{
    tileset_animations_wire_anim_code_override_ = std::move(value);
}
 
LayerValue<std::size_t>
OverrideConfigProvider::num_tiles_in_primary(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !num_tiles_in_primary_override_.has_value()) {
        return LayerValue<std::size_t>::not_provided();
    }
    return LayerValue<std::size_t>::valid(num_tiles_in_primary_override_.value(), "num_tiles_in_primary", source_info_);
}
 
LayerValue<std::size_t> OverrideConfigProvider::num_tiles_total(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !num_tiles_total_override_.has_value()) {
        return LayerValue<std::size_t>::not_provided();
    }
    return LayerValue<std::size_t>::valid(num_tiles_total_override_.value(), "num_tiles_total", source_info_);
}
 
LayerValue<std::size_t>
OverrideConfigProvider::num_metatiles_in_primary(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !num_metatiles_in_primary_override_.has_value()) {
        return LayerValue<std::size_t>::not_provided();
    }
    return LayerValue<std::size_t>::valid(
        num_metatiles_in_primary_override_.value(), "num_metatiles_in_primary", source_info_);
}
 
LayerValue<std::size_t>
OverrideConfigProvider::num_metatiles_total(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !num_metatiles_total_override_.has_value()) {
        return LayerValue<std::size_t>::not_provided();
    }
    return LayerValue<std::size_t>::valid(num_metatiles_total_override_.value(), "num_metatiles_total", source_info_);
}
 
LayerValue<std::size_t>
OverrideConfigProvider::num_palettes_in_primary(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !num_palettes_in_primary_override_.has_value()) {
        return LayerValue<std::size_t>::not_provided();
    }
    return LayerValue<std::size_t>::valid(
        num_palettes_in_primary_override_.value(), "num_palettes_in_primary", source_info_);
}
 
LayerValue<std::size_t> OverrideConfigProvider::num_palettes_total(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !num_palettes_total_override_.has_value()) {
        return LayerValue<std::size_t>::not_provided();
    }
    return LayerValue<std::size_t>::valid(num_palettes_total_override_.value(), "num_palettes_total", source_info_);
}
 
LayerValue<std::size_t> OverrideConfigProvider::max_map_data_size(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !max_map_data_size_override_.has_value()) {
        return LayerValue<std::size_t>::not_provided();
    }
    return LayerValue<std::size_t>::valid(max_map_data_size_override_.value(), "max_map_data_size", source_info_);
}
 
LayerValue<std::size_t>
OverrideConfigProvider::num_tiles_per_metatile(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !num_tiles_per_metatile_override_.has_value()) {
        return LayerValue<std::size_t>::not_provided();
    }
    return LayerValue<std::size_t>::valid(
        num_tiles_per_metatile_override_.value(), "num_tiles_per_metatile", source_info_);
}
 
LayerValue<Rgba32> OverrideConfigProvider::extrinsic_transparency(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !extrinsic_transparency_override_.has_value()) {
        return LayerValue<Rgba32>::not_provided();
    }
    return LayerValue<Rgba32>::valid(extrinsic_transparency_override_.value(), "extrinsic_transparency", source_info_);
}
 
LayerValue<bool>
OverrideConfigProvider::ignore_triple_layer_content(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !ignore_triple_layer_content_override_.has_value()) {
        return LayerValue<bool>::not_provided();
    }
    return LayerValue<bool>::valid(
        ignore_triple_layer_content_override_.value(), "ignore_triple_layer_content", source_info_);
}
 
LayerValue<ArtifactEditMode>
OverrideConfigProvider::tiles_edit_mode(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !tiles_edit_mode_override_.has_value()) {
        return LayerValue<ArtifactEditMode>::not_provided();
    }
    return LayerValue<ArtifactEditMode>::valid(tiles_edit_mode_override_.value(), "tiles_edit_mode", source_info_);
}
 
LayerValue<ArtifactEditMode>
OverrideConfigProvider::palettes_edit_mode(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !palettes_edit_mode_override_.has_value()) {
        return LayerValue<ArtifactEditMode>::not_provided();
    }
    return LayerValue<ArtifactEditMode>::valid(
        palettes_edit_mode_override_.value(), "palettes_edit_mode", source_info_);
}
 
LayerValue<bool> OverrideConfigProvider::palette_hints_enabled(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !palette_hints_enabled_override_.has_value()) {
        return LayerValue<bool>::not_provided();
    }
    return LayerValue<bool>::valid(palette_hints_enabled_override_.value(), "palette_hints_enabled", source_info_);
}
 
LayerValue<std::vector<PaletteHint>>
OverrideConfigProvider::palette_hints(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !palette_hints_override_.has_value()) {
        return LayerValue<std::vector<PaletteHint>>::not_provided();
    }
    return LayerValue<std::vector<PaletteHint>>::valid(palette_hints_override_.value(), "palette_hints", source_info_);
}
 
LayerValue<PackingStrategyType>
OverrideConfigProvider::packing_strategy(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !packing_strategy_override_.has_value()) {
        return LayerValue<PackingStrategyType>::not_provided();
    }
    return LayerValue<PackingStrategyType>::valid(packing_strategy_override_.value(), "packing_strategy", source_info_);
}
 
LayerValue<PackingStrategyParams>
OverrideConfigProvider::packing_strategy_params(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !packing_strategy_params_override_.has_value()) {
        return LayerValue<PackingStrategyParams>::not_provided();
    }
    return LayerValue<PackingStrategyParams>::valid(
        packing_strategy_params_override_.value(), "packing_strategy_params", source_info_);
}
 
LayerValue<TileSharingPacking>
OverrideConfigProvider::tile_sharing_packing(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !tile_sharing_packing_override_.has_value()) {
        return LayerValue<TileSharingPacking>::not_provided();
    }
    return LayerValue<TileSharingPacking>::valid(
        tile_sharing_packing_override_.value(), "tile_sharing_packing", source_info_);
}
 
LayerValue<TileSharingAlignment>
OverrideConfigProvider::tile_sharing_alignment(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !tile_sharing_alignment_override_.has_value()) {
        return LayerValue<TileSharingAlignment>::not_provided();
    }
    return LayerValue<TileSharingAlignment>::valid(
        tile_sharing_alignment_override_.value(), "tile_sharing_alignment", source_info_);
}
 
LayerValue<TilesPaletteMode>
OverrideConfigProvider::tiles_palette_mode(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !tiles_palette_mode_override_.has_value()) {
        return LayerValue<TilesPaletteMode>::not_provided();
    }
    return LayerValue<TilesPaletteMode>::valid(
        tiles_palette_mode_override_.value(), "tiles_palette_mode", source_info_);
}
 
LayerValue<AnimPaletteResolutionStrategy>
OverrideConfigProvider::global_anim_palette_resolution_strategy(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !global_anim_palette_resolution_strategy_override_.has_value()) {
        return LayerValue<AnimPaletteResolutionStrategy>::not_provided();
    }
    return LayerValue<AnimPaletteResolutionStrategy>::valid(
        global_anim_palette_resolution_strategy_override_.value(),
        "global_anim_palette_resolution_strategy",
        source_info_);
}
 
LayerValue<AnimKeyFrameResolutionStrategy>
OverrideConfigProvider::global_anim_key_frame_resolution_strategy(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !global_anim_key_frame_resolution_strategy_override_.has_value()) {
        return LayerValue<AnimKeyFrameResolutionStrategy>::not_provided();
    }
    return LayerValue<AnimKeyFrameResolutionStrategy>::valid(
        global_anim_key_frame_resolution_strategy_override_.value(),
        "global_anim_key_frame_resolution_strategy",
        source_info_);
}
 
LayerValue<AnimMultiPaletteSubtileResolutionStrategy>
OverrideConfigProvider::global_anim_multi_palette_subtile_resolution_strategy(
    ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !global_anim_multi_palette_subtile_resolution_strategy_override_.has_value()) {
        return LayerValue<AnimMultiPaletteSubtileResolutionStrategy>::not_provided();
    }
    return LayerValue<AnimMultiPaletteSubtileResolutionStrategy>::valid(
        global_anim_multi_palette_subtile_resolution_strategy_override_.value(),
        "global_anim_multi_palette_subtile_resolution_strategy",
        source_info_);
}
 
LayerValue<FrameLinking>
OverrideConfigProvider::global_frame_linking(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !global_frame_linking_override_.has_value()) {
        return LayerValue<FrameLinking>::not_provided();
    }
    return LayerValue<FrameLinking>::valid(
        global_frame_linking_override_.value(), "global_frame_linking", source_info_);
}
 
LayerValue<PerAnimOverrides>
OverrideConfigProvider::per_anim_overrides(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !per_anim_overrides_override_.has_value()) {
        return LayerValue<PerAnimOverrides>::not_provided();
    }
    return LayerValue<PerAnimOverrides>::valid(
        per_anim_overrides_override_.value(), "per_anim_overrides", source_info_);
}
 
LayerValue<bool>
OverrideConfigProvider::cross_tileset_anim_linking(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !cross_tileset_anim_linking_override_.has_value()) {
        return LayerValue<bool>::not_provided();
    }
    return LayerValue<bool>::valid(
        cross_tileset_anim_linking_override_.value(), "cross_tileset_anim_linking", source_info_);
}
 
LayerValue<bool> OverrideConfigProvider::verify_checksums(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !verify_checksums_override_.has_value()) {
        return LayerValue<bool>::not_provided();
    }
    return LayerValue<bool>::valid(verify_checksums_override_.value(), "verify_checksums", source_info_);
}
 
LayerValue<PrimaryPairingMode>
OverrideConfigProvider::primary_pairing_mode(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !primary_pairing_mode_override_.has_value()) {
        return LayerValue<PrimaryPairingMode>::not_provided();
    }
    return LayerValue<PrimaryPairingMode>::valid(
        primary_pairing_mode_override_.value(), "primary_pairing_mode", source_info_);
}
 
LayerValue<std::vector<std::string>>
OverrideConfigProvider::primary_pairing_partners(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !primary_pairing_partners_override_.has_value()) {
        return LayerValue<std::vector<std::string>>::not_provided();
    }
    return LayerValue<std::vector<std::string>>::valid(
        primary_pairing_partners_override_.value(), "primary_pairing_partners", source_info_);
}
 
LayerValue<std::vector<std::string>>
OverrideConfigProvider::diagnostic_warnings_exclude(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !diagnostic_warnings_exclude_override_.has_value()) {
        return LayerValue<std::vector<std::string>>::not_provided();
    }
    return LayerValue<std::vector<std::string>>::valid(
        diagnostic_warnings_exclude_override_.value(), "diagnostic_warnings_exclude", source_info_);
}
 
LayerValue<std::vector<std::string>>
OverrideConfigProvider::diagnostic_warnings_include(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !diagnostic_warnings_include_override_.has_value()) {
        return LayerValue<std::vector<std::string>>::not_provided();
    }
    return LayerValue<std::vector<std::string>>::valid(
        diagnostic_warnings_include_override_.value(), "diagnostic_warnings_include", source_info_);
}
 
LayerValue<std::vector<std::string>>
OverrideConfigProvider::diagnostic_remarks_exclude(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !diagnostic_remarks_exclude_override_.has_value()) {
        return LayerValue<std::vector<std::string>>::not_provided();
    }
    return LayerValue<std::vector<std::string>>::valid(
        diagnostic_remarks_exclude_override_.value(), "diagnostic_remarks_exclude", source_info_);
}
 
LayerValue<std::vector<std::string>>
OverrideConfigProvider::diagnostic_remarks_include(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !diagnostic_remarks_include_override_.has_value()) {
        return LayerValue<std::vector<std::string>>::not_provided();
    }
    return LayerValue<std::vector<std::string>>::valid(
        diagnostic_remarks_include_override_.value(), "diagnostic_remarks_include", source_info_);
}
 
LayerValue<std::string>
OverrideConfigProvider::tileset_paths_primary_src(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !tileset_paths_primary_src_override_.has_value()) {
        return LayerValue<std::string>::not_provided();
    }
    return LayerValue<std::string>::valid(
        tileset_paths_primary_src_override_.value(), "tileset_paths_primary_src", source_info_);
}
 
LayerValue<std::string>
OverrideConfigProvider::tileset_paths_primary_bin(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !tileset_paths_primary_bin_override_.has_value()) {
        return LayerValue<std::string>::not_provided();
    }
    return LayerValue<std::string>::valid(
        tileset_paths_primary_bin_override_.value(), "tileset_paths_primary_bin", source_info_);
}
 
LayerValue<std::string>
OverrideConfigProvider::tileset_paths_secondary_src(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !tileset_paths_secondary_src_override_.has_value()) {
        return LayerValue<std::string>::not_provided();
    }
    return LayerValue<std::string>::valid(
        tileset_paths_secondary_src_override_.value(), "tileset_paths_secondary_src", source_info_);
}
 
LayerValue<std::string>
OverrideConfigProvider::tileset_paths_secondary_bin(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !tileset_paths_secondary_bin_override_.has_value()) {
        return LayerValue<std::string>::not_provided();
    }
    return LayerValue<std::string>::valid(
        tileset_paths_secondary_bin_override_.value(), "tileset_paths_secondary_bin", source_info_);
}
 
LayerValue<std::optional<std::size_t>>
OverrideConfigProvider::metatile_attribute_size(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !metatile_attribute_size_override_.has_value()) {
        return LayerValue<std::optional<std::size_t>>::not_provided();
    }
    return LayerValue<std::optional<std::size_t>>::valid(
        metatile_attribute_size_override_.value(), "metatile_attribute_size", source_info_);
}
 
LayerValue<std::optional<std::size_t>>
OverrideConfigProvider::metatile_attribute_declaration_size(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !metatile_attribute_declaration_size_override_.has_value()) {
        return LayerValue<std::optional<std::size_t>>::not_provided();
    }
    return LayerValue<std::optional<std::size_t>>::valid(
        metatile_attribute_declaration_size_override_.value(), "metatile_attribute_declaration_size", source_info_);
}
 
LayerValue<MetatileAttributeFieldDefinitions>
OverrideConfigProvider::metatile_attribute_fields(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !metatile_attribute_fields_override_.has_value()) {
        return LayerValue<MetatileAttributeFieldDefinitions>::not_provided();
    }
    return LayerValue<MetatileAttributeFieldDefinitions>::valid(
        metatile_attribute_fields_override_.value(), "metatile_attribute_fields", source_info_);
}
 
LayerValue<MetatileAttributeFieldOverrides>
OverrideConfigProvider::metatile_attribute_field_overrides(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !metatile_attribute_field_overrides_override_.has_value()) {
        return LayerValue<MetatileAttributeFieldOverrides>::not_provided();
    }
    return LayerValue<MetatileAttributeFieldOverrides>::valid(
        metatile_attribute_field_overrides_override_.value(), "metatile_attribute_field_overrides", source_info_);
}
 
LayerValue<RolePinDefinitions> OverrideConfigProvider::role_pins(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !role_pins_override_.has_value()) {
        return LayerValue<RolePinDefinitions>::not_provided();
    }
    return LayerValue<RolePinDefinitions>::valid(role_pins_override_.value(), "role_pins", source_info_);
}
 
LayerValue<bool>
OverrideConfigProvider::tileset_animations_wire_anim_code(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !tileset_animations_wire_anim_code_override_.has_value()) {
        return LayerValue<bool>::not_provided();
    }
    return LayerValue<bool>::valid(
        tileset_animations_wire_anim_code_override_.value(), "tileset_animations_wire_anim_code", source_info_);
}
 
} // namespace porytiles