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_pals_in_primary(std::size_t value)
{
    num_pals_in_primary_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_num_pals_total(std::size_t value)
{
    num_pals_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_tiles_edit_mode(ArtifactEditMode value)
{
    tiles_edit_mode_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_pals_edit_mode(ArtifactEditMode value)
{
    pals_edit_mode_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_pal_hints_enabled(bool value)
{
    pal_hints_enabled_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_pal_hints(std::vector<PaletteHint> value)
{
    pal_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_pal_mode(TilesPalMode value)
{
    tiles_pal_mode_override_ = std::move(value);
}
 
void OverrideConfigProvider::set_global_anim_pal_resolution_strategy(AnimPalResolutionStrategy value)
{
    global_anim_pal_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_pal_subtile_resolution_strategy(AnimMultiPalSubtileResolutionStrategy value)
{
    global_anim_multi_pal_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_attr_size(std::size_t value)
{
    metatile_attr_size_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_pals_in_primary(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !num_pals_in_primary_override_.has_value()) {
        return LayerValue<std::size_t>::not_provided();
    }
    return LayerValue<std::size_t>::valid(
        num_pals_in_primary_override_.value(), "num_pals_in_primary", source_info_);
}
 
LayerValue<std::size_t>
OverrideConfigProvider::num_pals_total(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !num_pals_total_override_.has_value()) {
        return LayerValue<std::size_t>::not_provided();
    }
    return LayerValue<std::size_t>::valid(
        num_pals_total_override_.value(), "num_pals_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<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::pals_edit_mode(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !pals_edit_mode_override_.has_value()) {
        return LayerValue<ArtifactEditMode>::not_provided();
    }
    return LayerValue<ArtifactEditMode>::valid(
        pals_edit_mode_override_.value(), "pals_edit_mode", source_info_);
}
 
LayerValue<bool>
OverrideConfigProvider::pal_hints_enabled(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !pal_hints_enabled_override_.has_value()) {
        return LayerValue<bool>::not_provided();
    }
    return LayerValue<bool>::valid(
        pal_hints_enabled_override_.value(), "pal_hints_enabled", source_info_);
}
 
LayerValue<std::vector<PaletteHint>>
OverrideConfigProvider::pal_hints(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !pal_hints_override_.has_value()) {
        return LayerValue<std::vector<PaletteHint>>::not_provided();
    }
    return LayerValue<std::vector<PaletteHint>>::valid(
        pal_hints_override_.value(), "pal_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<TilesPalMode>
OverrideConfigProvider::tiles_pal_mode(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !tiles_pal_mode_override_.has_value()) {
        return LayerValue<TilesPalMode>::not_provided();
    }
    return LayerValue<TilesPalMode>::valid(
        tiles_pal_mode_override_.value(), "tiles_pal_mode", source_info_);
}
 
LayerValue<AnimPalResolutionStrategy>
OverrideConfigProvider::global_anim_pal_resolution_strategy(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !global_anim_pal_resolution_strategy_override_.has_value()) {
        return LayerValue<AnimPalResolutionStrategy>::not_provided();
    }
    return LayerValue<AnimPalResolutionStrategy>::valid(
        global_anim_pal_resolution_strategy_override_.value(), "global_anim_pal_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<AnimMultiPalSubtileResolutionStrategy>
OverrideConfigProvider::global_anim_multi_pal_subtile_resolution_strategy(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !global_anim_multi_pal_subtile_resolution_strategy_override_.has_value()) {
        return LayerValue<AnimMultiPalSubtileResolutionStrategy>::not_provided();
    }
    return LayerValue<AnimMultiPalSubtileResolutionStrategy>::valid(
        global_anim_multi_pal_subtile_resolution_strategy_override_.value(), "global_anim_multi_pal_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::size_t>
OverrideConfigProvider::metatile_attr_size(ConfigScopeType type, const std::string &scope) const
{
    if (!scope_matches(type, scope) || !metatile_attr_size_override_.has_value()) {
        return LayerValue<std::size_t>::not_provided();
    }
    return LayerValue<std::size_t>::valid(
        metatile_attr_size_override_.value(), "metatile_attr_size", 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