cli_option_provider_impl.ipp

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <cctype>
#include <charconv>
#include <cstdint>
#include <exception>
#include <format>
#include <optional>
#include <sstream>
#include <string>
#include <vector>
 
#include "porytiles/app/config/primary_pairing_mode.hpp"
#include "porytiles/domain/config/anim_key_frame_resolution_strategy.hpp"
#include "porytiles/domain/config/anim_multi_palette_subtile_resolution_strategy.hpp"
#include "porytiles/domain/config/anim_palette_resolution_strategy.hpp"
#include "porytiles/domain/config/artifact_edit_mode.hpp"
#include "porytiles/domain/config/frame_linking.hpp"
#include "porytiles/domain/config/packing_strategy_type.hpp"
#include "porytiles/domain/config/tile_sharing_alignment.hpp"
#include "porytiles/domain/config/tile_sharing_packing.hpp"
#include "porytiles/domain/config/tiles_palette_mode.hpp"
#include "porytiles/domain/models/rgba32.hpp"
#include "porytiles/infra/config/layer_value.hpp"
 
// The anonymous namespace ensures internal linkage per translation unit
// This file is intentionally included only in cli_option_provider.cpp
namespace {
 
using namespace porytiles;
 
LayerValue<std::size_t> parse_size_t(const std::optional<std::string> &raw_value, const std::string &option_name)
{
    if (!raw_value.has_value()) {
        return LayerValue<std::size_t>::not_provided();
    }
 
    const auto &str = raw_value.value();
 
    // Use std::from_chars for efficient, locale-independent parsing
    std::size_t value = 0;
    const auto *begin = str.data();
    const auto *end = str.data() + str.size();
    auto [ptr, ec] = std::from_chars(begin, end, value);
 
    if (ec == std::errc{} && ptr == end) {
        return LayerValue<std::size_t>::valid(value, option_name, "CLI");
    }
 
    if (ec == std::errc::result_out_of_range) {
        const auto error = std::format("Invalid value '{}' for '{}': value out of range.", str, option_name);
        return LayerValue<std::size_t>::invalid(error, option_name);
    }
 
    // Invalid argument or trailing characters
    const auto error = std::format("Invalid value '{}' for '{}': not a valid integer.", str, option_name);
    return LayerValue<std::size_t>::invalid(error, option_name);
}
 
LayerValue<std::optional<std::size_t>>
parse_optional_size_t(const std::optional<std::string> &raw_value, const std::string &option_name)
{
    if (!raw_value.has_value()) {
        return LayerValue<std::optional<std::size_t>>::not_provided();
    }
 
    const auto &str = raw_value.value();
 
    std::size_t value = 0;
    const auto *begin = str.data();
    const auto *end = str.data() + str.size();
    auto [ptr, ec] = std::from_chars(begin, end, value);
 
    if (ec == std::errc{} && ptr == end) {
        return LayerValue<std::optional<std::size_t>>::valid(std::optional<std::size_t>{value}, option_name, "CLI");
    }
 
    if (ec == std::errc::result_out_of_range) {
        const auto error = std::format("Invalid value '{}' for '{}': value out of range.", str, option_name);
        return LayerValue<std::optional<std::size_t>>::invalid(error, option_name);
    }
 
    const auto error = std::format("Invalid value '{}' for '{}': not a valid integer.", str, option_name);
    return LayerValue<std::optional<std::size_t>>::invalid(error, option_name);
}
 
LayerValue<bool> parse_bool(const std::optional<std::string> &raw_value, const std::string &option_name)
{
    if (!raw_value.has_value()) {
        return LayerValue<bool>::not_provided();
    }
 
    const auto &str = raw_value.value();
 
    if (str == "true") {
        return LayerValue<bool>::valid(true, option_name, "CLI");
    }
    if (str == "false") {
        return LayerValue<bool>::valid(false, option_name, "CLI");
    }
 
    const auto error = std::format("Invalid value '{}' for '{}': expected 'true' or 'false'.", str, option_name);
    return LayerValue<bool>::invalid(error, option_name);
}
 
LayerValue<Rgba32> parse_rgba32(const std::optional<std::string> &raw_value, const std::string &option_name)
{
    if (!raw_value.has_value()) {
        return LayerValue<Rgba32>::not_provided();
    }
 
    const auto &input = raw_value.value();
    std::istringstream iss{input};
    std::string token;
    std::vector<int> values;
 
    while (std::getline(iss, token, ',')) {
        // Use std::from_chars for robust integer parsing
        int val = 0;
        const auto *begin = token.data();
        const auto *end = token.data() + token.size();
        auto [ptr, ec] = std::from_chars(begin, end, val);
 
        if (ec != std::errc{} || ptr != end) {
            const auto error =
                std::format("Invalid value '{}' for '{}': '{}' is not a valid integer.", input, option_name, token);
            return LayerValue<Rgba32>::invalid(error, option_name);
        }
 
        if (val < 0 || val > 255) {
            const auto error = std::format(
                "Invalid value '{}' for '{}': component {} is out of range (must be 0-255).", input, option_name, val);
            return LayerValue<Rgba32>::invalid(error, option_name);
        }
 
        values.push_back(val);
    }
 
    if (values.size() == 3) {
        Rgba32 result{
            static_cast<std::uint8_t>(values[0]),
            static_cast<std::uint8_t>(values[1]),
            static_cast<std::uint8_t>(values[2]),
            255};
        return LayerValue<Rgba32>::valid(result, option_name, "CLI");
    }
 
    if (values.size() == 4) {
        Rgba32 result{
            static_cast<std::uint8_t>(values[0]),
            static_cast<std::uint8_t>(values[1]),
            static_cast<std::uint8_t>(values[2]),
            static_cast<std::uint8_t>(values[3])};
        return LayerValue<Rgba32>::valid(result, option_name, "CLI");
    }
 
    const auto error = std::format(
        "Invalid value '{}' for '{}': expected R,G,B or R,G,B,A format (got {} components).",
        input,
        option_name,
        values.size());
    return LayerValue<Rgba32>::invalid(error, option_name);
}
 
LayerValue<std::string> parse_string(const std::optional<std::string> &raw_value, const std::string &option_name)
{
    if (!raw_value.has_value()) {
        return LayerValue<std::string>::not_provided();
    }
 
    return LayerValue<std::string>::valid(raw_value.value(), option_name, "CLI");
}
 
LayerValue<std::vector<std::string>>
parse_string_vector(const std::vector<std::string> &raw_values, const std::string &option_name)
{
    if (raw_values.empty()) {
        return LayerValue<std::vector<std::string>>::not_provided();
    }
    return LayerValue<std::vector<std::string>>::valid(raw_values, option_name, "CLI");
}
 
LayerValue<ArtifactEditMode>
parse_artifact_edit_mode(const std::optional<std::string> &raw_value, const std::string &option_name)
{
    if (!raw_value.has_value()) {
        return LayerValue<ArtifactEditMode>::not_provided();
    }
 
    const auto &str = raw_value.value();
    const auto result = artifact_edit_mode_from_str(str);
 
    if (result.has_value()) {
        return LayerValue<ArtifactEditMode>::valid(result.value(), option_name, "CLI");
    }
 
    const auto error = std::format("Invalid value '{}' for '{}'.", str, option_name);
    return LayerValue<ArtifactEditMode>::invalid(error, option_name);
}
 
LayerValue<TilesPaletteMode>
parse_tiles_palette_mode(const std::optional<std::string> &raw_value, const std::string &option_name)
{
    if (!raw_value.has_value()) {
        return LayerValue<TilesPaletteMode>::not_provided();
    }
 
    const auto &str = raw_value.value();
    const auto result = tiles_palette_mode_from_str(str);
 
    if (result.has_value()) {
        return LayerValue<TilesPaletteMode>::valid(result.value(), option_name, "CLI");
    }
 
    const auto error = std::format("Invalid value '{}' for '{}'.", str, option_name);
    return LayerValue<TilesPaletteMode>::invalid(error, option_name);
}
 
LayerValue<AnimPaletteResolutionStrategy>
parse_anim_palette_resolution_strategy(const std::optional<std::string> &raw_value, const std::string &option_name)
{
    if (!raw_value.has_value()) {
        return LayerValue<AnimPaletteResolutionStrategy>::not_provided();
    }
 
    const auto &str = raw_value.value();
    const auto result = anim_palette_resolution_strategy_from_str(str);
 
    if (result.has_value()) {
        return LayerValue<AnimPaletteResolutionStrategy>::valid(result.value(), option_name, "CLI");
    }
 
    const auto error = std::format("Invalid value '{}' for '{}'.", str, option_name);
    return LayerValue<AnimPaletteResolutionStrategy>::invalid(error, option_name);
}
 
LayerValue<AnimKeyFrameResolutionStrategy>
parse_anim_key_frame_resolution_strategy(const std::optional<std::string> &raw_value, const std::string &option_name)
{
    if (!raw_value.has_value()) {
        return LayerValue<AnimKeyFrameResolutionStrategy>::not_provided();
    }
 
    const auto &str = raw_value.value();
    const auto result = anim_key_frame_resolution_strategy_from_str(str);
 
    if (result.has_value()) {
        return LayerValue<AnimKeyFrameResolutionStrategy>::valid(result.value(), option_name, "CLI");
    }
 
    const auto error = std::format("Invalid value '{}' for '{}'.", str, option_name);
    return LayerValue<AnimKeyFrameResolutionStrategy>::invalid(error, option_name);
}
 
LayerValue<AnimMultiPaletteSubtileResolutionStrategy> parse_anim_multi_palette_subtile_resolution_strategy(
    const std::optional<std::string> &raw_value, const std::string &option_name)
{
    if (!raw_value.has_value()) {
        return LayerValue<AnimMultiPaletteSubtileResolutionStrategy>::not_provided();
    }
 
    const auto &str = raw_value.value();
    const auto result = anim_multi_palette_subtile_resolution_strategy_from_str(str);
 
    if (result.has_value()) {
        return LayerValue<AnimMultiPaletteSubtileResolutionStrategy>::valid(result.value(), option_name, "CLI");
    }
 
    const auto error = std::format("Invalid value '{}' for '{}'.", str, option_name);
    return LayerValue<AnimMultiPaletteSubtileResolutionStrategy>::invalid(error, option_name);
}
 
LayerValue<FrameLinking>
parse_frame_linking(const std::optional<std::string> &raw_value, const std::string &option_name)
{
    if (!raw_value.has_value()) {
        return LayerValue<FrameLinking>::not_provided();
    }
 
    const auto &str = raw_value.value();
    const auto result = frame_linking_from_str(str);
 
    if (result.has_value()) {
        return LayerValue<FrameLinking>::valid(result.value(), option_name, "CLI");
    }
 
    const auto error = std::format("Invalid value '{}' for '{}'.", str, option_name);
    return LayerValue<FrameLinking>::invalid(error, option_name);
}
 
LayerValue<TileSharingPacking>
parse_tile_sharing_packing(const std::optional<std::string> &raw_value, const std::string &option_name)
{
    if (!raw_value.has_value()) {
        return LayerValue<TileSharingPacking>::not_provided();
    }
 
    const auto &str = raw_value.value();
    const auto result = tile_sharing_packing_from_str(str);
 
    if (result.has_value()) {
        return LayerValue<TileSharingPacking>::valid(result.value(), option_name, "CLI");
    }
 
    const auto error = std::format("Invalid value '{}' for '{}'.", str, option_name);
    return LayerValue<TileSharingPacking>::invalid(error, option_name);
}
 
LayerValue<TileSharingAlignment>
parse_tile_sharing_alignment(const std::optional<std::string> &raw_value, const std::string &option_name)
{
    if (!raw_value.has_value()) {
        return LayerValue<TileSharingAlignment>::not_provided();
    }
 
    const auto &str = raw_value.value();
    const auto result = tile_sharing_alignment_from_str(str);
 
    if (result.has_value()) {
        return LayerValue<TileSharingAlignment>::valid(result.value(), option_name, "CLI");
    }
 
    const auto error = std::format("Invalid value '{}' for '{}'.", str, option_name);
    return LayerValue<TileSharingAlignment>::invalid(error, option_name);
}
 
LayerValue<PackingStrategyType>
parse_packing_strategy_type(const std::optional<std::string> &raw_value, const std::string &option_name)
{
    if (!raw_value.has_value()) {
        return LayerValue<PackingStrategyType>::not_provided();
    }
 
    const auto &str = raw_value.value();
    const auto result = packing_strategy_type_from_str(str);
 
    if (result.has_value()) {
        return LayerValue<PackingStrategyType>::valid(result.value(), option_name, "CLI");
    }
 
    const auto error = std::format("Invalid value '{}' for '{}'.", str, option_name);
    return LayerValue<PackingStrategyType>::invalid(error, option_name);
}
 
LayerValue<PrimaryPairingMode>
parse_primary_pairing_mode(const std::optional<std::string> &raw_value, const std::string &option_name)
{
    if (!raw_value.has_value()) {
        return LayerValue<PrimaryPairingMode>::not_provided();
    }
 
    const auto &str = raw_value.value();
    const auto result = primary_pairing_mode_from_str(str);
 
    if (result.has_value()) {
        return LayerValue<PrimaryPairingMode>::valid(result.value(), option_name, "CLI");
    }
 
    const auto error = std::format("Invalid value '{}' for '{}'.", str, option_name);
    return LayerValue<PrimaryPairingMode>::invalid(error, option_name);
}
 
} // namespace