yaml_file_provider.cpp

Go to the documentation of this file.

#include "porytiles/infra/config/yaml_file_provider.hpp"
 
#include <cstdint>
#include <filesystem>
#include <fstream>
#include <map>
#include <sstream>
 
#include "yaml-cpp/yaml.h"
 
#include "porytiles/utilities/string_utils.hpp"
#include "porytiles/utilities/text/plain_text_formatter.hpp"
 
#include "./yaml_file_provider_impl.ipp"
 
namespace porytiles {
 
// 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
 
YamlFileProvider::YamlFileProvider(
    gsl::not_null<const TextFormatter *> format,
    const UserDiagnostics *diagnostics,
    const std::filesystem::path &project_root)
    : format_{format}, diagnostics_{diagnostics}, project_root_{project_root}
{
    // Config files are loaded lazily when first accessed via the anonymous namespace functions
}
 
YamlFileProvider::YamlFileProvider(const UserDiagnostics *diagnostics, const std::filesystem::path &project_root)
    : owned_format_{std::make_unique<PlainTextFormatter>()}, format_{owned_format_.get()}, diagnostics_{diagnostics},
      project_root_{project_root}
{
    // Config files are loaded lazily when first accessed via the anonymous namespace functions
}
 
std::string YamlFileProvider::name() const
{
    return "YamlFileProvider";
}
 
bool YamlFileProvider::preload_and_validate(ConfigScopeType type, const std::string &scope) const
{
    return preload_and_validate_yaml_files(format_, diagnostics_, project_root_, type, scope);
}
 
LayerValue<std::size_t> YamlFileProvider::num_tiles_in_primary(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<std::size_t>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<std::size_t>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["fieldmap"]["num_tiles_in_primary"]; },
        parse_size_t,
        "fieldmap.num_tiles_in_primary",
        "fieldmap.num_tiles_in_primary");
}
 
LayerValue<std::size_t> YamlFileProvider::num_tiles_total(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<std::size_t>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<std::size_t>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["fieldmap"]["num_tiles_total"]; },
        parse_size_t,
        "fieldmap.num_tiles_total",
        "fieldmap.num_tiles_total");
}
 
LayerValue<std::size_t> YamlFileProvider::num_metatiles_in_primary(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<std::size_t>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<std::size_t>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["fieldmap"]["num_metatiles_in_primary"]; },
        parse_size_t,
        "fieldmap.num_metatiles_in_primary",
        "fieldmap.num_metatiles_in_primary");
}
 
LayerValue<std::size_t> YamlFileProvider::num_metatiles_total(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<std::size_t>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<std::size_t>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["fieldmap"]["num_metatiles_total"]; },
        parse_size_t,
        "fieldmap.num_metatiles_total",
        "fieldmap.num_metatiles_total");
}
 
LayerValue<std::size_t> YamlFileProvider::num_palettes_in_primary(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<std::size_t>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<std::size_t>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["fieldmap"]["num_palettes_in_primary"]; },
        parse_size_t,
        "fieldmap.num_palettes_in_primary",
        "fieldmap.num_palettes_in_primary");
}
 
LayerValue<std::size_t> YamlFileProvider::num_palettes_total(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<std::size_t>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<std::size_t>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["fieldmap"]["num_palettes_total"]; },
        parse_size_t,
        "fieldmap.num_palettes_total",
        "fieldmap.num_palettes_total");
}
 
LayerValue<std::size_t> YamlFileProvider::max_map_data_size(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<std::size_t>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<std::size_t>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["fieldmap"]["max_map_data_size"]; },
        parse_size_t,
        "fieldmap.max_map_data_size",
        "fieldmap.max_map_data_size");
}
 
LayerValue<std::size_t> YamlFileProvider::num_tiles_per_metatile(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<std::size_t>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<std::size_t>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["fieldmap"]["num_tiles_per_metatile"]; },
        parse_size_t,
        "fieldmap.num_tiles_per_metatile",
        "fieldmap.num_tiles_per_metatile");
}
 
LayerValue<Rgba32> YamlFileProvider::extrinsic_transparency(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<Rgba32>::invalid(paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<Rgba32>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["tileset"]["extrinsic_transparency"]; },
        parse_rgba32,
        "tileset.extrinsic_transparency",
        "tileset.extrinsic_transparency");
}
 
LayerValue<bool> YamlFileProvider::ignore_triple_layer_content(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<bool>::invalid(paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<bool>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["tileset"]["ignore_triple_layer_content"]; },
        parse_bool,
        "tileset.ignore_triple_layer_content",
        "tileset.ignore_triple_layer_content");
}
 
LayerValue<ArtifactEditMode> YamlFileProvider::tiles_edit_mode(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<ArtifactEditMode>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<ArtifactEditMode>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["tileset"]["tiles"]["edit_mode"]; },
        parse_artifact_edit_mode,
        "tileset.tiles.edit_mode",
        "tileset.tiles.edit_mode");
}
 
LayerValue<ArtifactEditMode> YamlFileProvider::palettes_edit_mode(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<ArtifactEditMode>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<ArtifactEditMode>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["tileset"]["palettes"]["edit_mode"]; },
        parse_artifact_edit_mode,
        "tileset.palettes.edit_mode",
        "tileset.palettes.edit_mode");
}
 
LayerValue<bool> YamlFileProvider::palette_hints_enabled(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<bool>::invalid(paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<bool>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["tileset"]["palettes"]["packing"]["hints_enabled"]; },
        parse_bool,
        "tileset.palettes.packing.hints_enabled",
        "tileset.palettes.packing.hints_enabled");
}
 
LayerValue<std::vector<PaletteHint>>
YamlFileProvider::palette_hints(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<std::vector<PaletteHint>>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<std::vector<PaletteHint>>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["tileset"]["palettes"]["packing"]["hints"]; },
        parse_palette_hints,
        "tileset.palettes.packing.hints",
        "tileset.palettes.packing.hints");
}
 
LayerValue<PackingStrategyType> YamlFileProvider::packing_strategy(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<PackingStrategyType>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<PackingStrategyType>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["tileset"]["palettes"]["packing"]["strategy"]; },
        parse_packing_strategy_type,
        "tileset.palettes.packing.strategy",
        "tileset.palettes.packing.strategy");
}
 
LayerValue<PackingStrategyParams>
YamlFileProvider::packing_strategy_params(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<PackingStrategyParams>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<PackingStrategyParams>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["tileset"]["palettes"]["packing"]["strategy_params"]; },
        parse_packing_strategy_params,
        "tileset.palettes.packing.strategy_params",
        "tileset.palettes.packing.strategy_params");
}
 
LayerValue<TileSharingPacking>
YamlFileProvider::tile_sharing_packing(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<TileSharingPacking>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<TileSharingPacking>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["tileset"]["tiles"]["sharing"]["packing"]; },
        parse_tile_sharing_packing,
        "tileset.tiles.sharing.packing",
        "tileset.tiles.sharing.packing");
}
 
LayerValue<TileSharingAlignment>
YamlFileProvider::tile_sharing_alignment(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<TileSharingAlignment>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<TileSharingAlignment>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["tileset"]["tiles"]["sharing"]["alignment"]; },
        parse_tile_sharing_alignment,
        "tileset.tiles.sharing.alignment",
        "tileset.tiles.sharing.alignment");
}
 
LayerValue<TilesPaletteMode> YamlFileProvider::tiles_palette_mode(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<TilesPaletteMode>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<TilesPaletteMode>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["tileset"]["tiles"]["palette_mode"]; },
        parse_tiles_palette_mode,
        "tileset.tiles.palette_mode",
        "tileset.tiles.palette_mode");
}
 
LayerValue<AnimPaletteResolutionStrategy>
YamlFileProvider::global_anim_palette_resolution_strategy(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<AnimPaletteResolutionStrategy>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<AnimPaletteResolutionStrategy>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["tileset"]["animations"]["palette_resolution_strategy"]; },
        parse_anim_palette_resolution_strategy,
        "tileset.animations.palette_resolution_strategy",
        "tileset.animations.palette_resolution_strategy");
}
 
LayerValue<AnimKeyFrameResolutionStrategy>
YamlFileProvider::global_anim_key_frame_resolution_strategy(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<AnimKeyFrameResolutionStrategy>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<AnimKeyFrameResolutionStrategy>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["tileset"]["animations"]["key_frame_resolution_strategy"]; },
        parse_anim_key_frame_resolution_strategy,
        "tileset.animations.key_frame_resolution_strategy",
        "tileset.animations.key_frame_resolution_strategy");
}
 
LayerValue<AnimMultiPaletteSubtileResolutionStrategy>
YamlFileProvider::global_anim_multi_palette_subtile_resolution_strategy(
    ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<AnimMultiPaletteSubtileResolutionStrategy>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<AnimMultiPaletteSubtileResolutionStrategy>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["tileset"]["animations"]["multi_palette_subtile_resolution_strategy"]; },
        parse_anim_multi_palette_subtile_resolution_strategy,
        "tileset.animations.multi_palette_subtile_resolution_strategy",
        "tileset.animations.multi_palette_subtile_resolution_strategy");
}
 
LayerValue<FrameLinking> YamlFileProvider::global_frame_linking(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<FrameLinking>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<FrameLinking>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["tileset"]["animations"]["frame_linking"]; },
        parse_frame_linking,
        "tileset.animations.frame_linking",
        "tileset.animations.frame_linking");
}
 
LayerValue<PerAnimOverrides> YamlFileProvider::per_anim_overrides(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<PerAnimOverrides>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<PerAnimOverrides>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["tileset"]["animations"]["per_animation_overrides"]; },
        parse_per_anim_overrides,
        "tileset.animations.per_animation_overrides",
        "tileset.animations.per_animation_overrides");
}
 
LayerValue<bool> YamlFileProvider::cross_tileset_anim_linking(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<bool>::invalid(paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<bool>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["tileset"]["animations"]["cross_tileset_linking"]; },
        parse_bool,
        "tileset.animations.cross_tileset_linking",
        "tileset.animations.cross_tileset_linking");
}
 
LayerValue<bool> YamlFileProvider::verify_checksums(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<bool>::invalid(paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<bool>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["verify_checksums"]; },
        parse_bool,
        "verify_checksums",
        "verify_checksums");
}
 
LayerValue<PrimaryPairingMode>
YamlFileProvider::primary_pairing_mode(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<PrimaryPairingMode>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<PrimaryPairingMode>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["tileset"]["primary_pairing"]["mode"]; },
        parse_primary_pairing_mode,
        "tileset.primary_pairing.mode",
        "tileset.primary_pairing.mode");
}
 
LayerValue<std::vector<std::string>>
YamlFileProvider::primary_pairing_partners(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<std::vector<std::string>>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<std::vector<std::string>>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["tileset"]["primary_pairing"]["partners"]; },
        parse_string_vector,
        "tileset.primary_pairing.partners",
        "tileset.primary_pairing.partners");
}
 
LayerValue<std::vector<std::string>>
YamlFileProvider::diagnostic_warnings_exclude(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<std::vector<std::string>>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<std::vector<std::string>>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["diagnostics"]["warnings"]["exclude"]; },
        parse_string_vector,
        "diagnostics.warnings.exclude",
        "diagnostics.warnings.exclude");
}
 
LayerValue<std::vector<std::string>>
YamlFileProvider::diagnostic_warnings_include(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<std::vector<std::string>>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<std::vector<std::string>>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["diagnostics"]["warnings"]["include"]; },
        parse_string_vector,
        "diagnostics.warnings.include",
        "diagnostics.warnings.include");
}
 
LayerValue<std::vector<std::string>>
YamlFileProvider::diagnostic_remarks_exclude(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<std::vector<std::string>>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<std::vector<std::string>>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["diagnostics"]["remarks"]["exclude"]; },
        parse_string_vector,
        "diagnostics.remarks.exclude",
        "diagnostics.remarks.exclude");
}
 
LayerValue<std::vector<std::string>>
YamlFileProvider::diagnostic_remarks_include(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<std::vector<std::string>>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<std::vector<std::string>>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["diagnostics"]["remarks"]["include"]; },
        parse_string_vector,
        "diagnostics.remarks.include",
        "diagnostics.remarks.include");
}
 
LayerValue<std::string>
YamlFileProvider::tileset_paths_primary_src(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<std::string>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<std::string>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["tileset"]["paths"]["primary"]["src"]; },
        parse_string,
        "tileset.paths.primary.src",
        "tileset.paths.primary.src");
}
 
LayerValue<std::string>
YamlFileProvider::tileset_paths_primary_bin(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<std::string>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<std::string>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["tileset"]["paths"]["primary"]["bin"]; },
        parse_string,
        "tileset.paths.primary.bin",
        "tileset.paths.primary.bin");
}
 
LayerValue<std::string>
YamlFileProvider::tileset_paths_secondary_src(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<std::string>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<std::string>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["tileset"]["paths"]["secondary"]["src"]; },
        parse_string,
        "tileset.paths.secondary.src",
        "tileset.paths.secondary.src");
}
 
LayerValue<std::string>
YamlFileProvider::tileset_paths_secondary_bin(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<std::string>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<std::string>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["tileset"]["paths"]["secondary"]["bin"]; },
        parse_string,
        "tileset.paths.secondary.bin",
        "tileset.paths.secondary.bin");
}
 
LayerValue<std::optional<std::size_t>>
YamlFileProvider::metatile_attribute_size(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<std::optional<std::size_t>>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<std::optional<std::size_t>>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["fieldmap"]["metatile_attribute_size"]; },
        parse_optional_size_t,
        "fieldmap.metatile_attribute_size",
        "fieldmap.metatile_attribute_size");
}
 
LayerValue<std::optional<std::size_t>>
YamlFileProvider::metatile_attribute_declaration_size(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<std::optional<std::size_t>>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<std::optional<std::size_t>>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["fieldmap"]["metatile_attribute_declaration_size"]; },
        parse_optional_size_t,
        "fieldmap.metatile_attribute_declaration_size",
        "fieldmap.metatile_attribute_declaration_size");
}
 
LayerValue<MetatileAttributeFieldDefinitions>
YamlFileProvider::metatile_attribute_fields(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<MetatileAttributeFieldDefinitions>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<MetatileAttributeFieldDefinitions>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["fieldmap"]["metatile_attribute_fields"]; },
        parse_metatile_attribute_fields,
        "fieldmap.metatile_attribute_fields",
        "fieldmap.metatile_attribute_fields");
}
 
LayerValue<MetatileAttributeFieldOverrides>
YamlFileProvider::metatile_attribute_field_overrides(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<MetatileAttributeFieldOverrides>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<MetatileAttributeFieldOverrides>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["fieldmap"]["metatile_attribute_field_overrides"]; },
        parse_metatile_attribute_field_overrides,
        "fieldmap.metatile_attribute_field_overrides",
        "fieldmap.metatile_attribute_field_overrides");
}
 
LayerValue<RolePinDefinitions> YamlFileProvider::role_pins(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<RolePinDefinitions>::invalid(
            paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<RolePinDefinitions>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["fieldmap"]["role_pins"]; },
        parse_role_pins,
        "fieldmap.role_pins",
        "fieldmap.role_pins");
}
 
LayerValue<bool>
YamlFileProvider::tileset_animations_wire_anim_code(ConfigScopeType type, const std::string &scope) const
{
    auto paths_result = get_config_path_chain(project_root_, type, scope);
    if (!paths_result.has_value()) {
        return LayerValue<bool>::invalid(paths_result.error().join(PlainTextFormatter{}), "config path resolution");
    }
    return search_config_files<bool>(
        format_,
        paths_result.value(),
        [this](const std::filesystem::path &p) { return load_yaml_file(p, format_, diagnostics_); },
        [](const YAML::Node &doc) { return doc["tileset"]["animations"]["wire_anim_code"]; },
        parse_bool,
        "tileset.animations.wire_anim_code",
        "tileset.animations.wire_anim_code");
}
 
} // namespace porytiles