header_define_provider_impl.ipp

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <filesystem>
#include <optional>
#include <string>
#include <vector>
 
#include "porytiles/infra/config/config_provider.hpp"
#include "porytiles/utilities/c_parser/c_parser_facade.hpp"
#include "porytiles/utilities/c_parser/define_statement.hpp"
#include "porytiles/utilities/text/file_highlight_printer.hpp"
#include "porytiles/utilities/text/text_formatter.hpp"
 
// The anonymous namespace ensures internal linkage per translation unit
// This file is intentionally included only in header_define_provider.cpp
namespace {
 
using namespace porytiles;
 
std::string make_source_string(const TextFormatter *format, const std::string &file_path, const DefineStatement &define)
{
    return format->format("{}:{}", FormatParam{file_path}, FormatParam{define.position().line});
}
 
std::vector<std::string> make_source_details(
    const TextFormatter *format, const std::vector<std::string> &file_lines, const DefineStatement &define)
{
    if (file_lines.empty()) {
        return {};
    }
 
    // Convert 1-indexed line to 0-indexed for FileHighlightPrinter
    const std::size_t line_index = define.position().line - 1;
    if (line_index >= file_lines.size()) {
        return {};
    }
 
    const FileHighlightPrinter printer{format};
    return printer.print(file_lines, std::vector{line_index});
}
 
CParserFacade &get_parser_driver(
    std::optional<CParserFacade> &driver, const std::filesystem::path &header_path, const TextFormatter *format)
{
    if (!driver.has_value()) {
        driver.emplace(header_path, format);
    }
    return driver.value();
}
 
LayerValue<std::size_t> parse_size_t(
    const TextFormatter *format,
    const DefineStatement &define,
    const std::string &file_path,
    const std::vector<std::string> &file_lines,
    const std::string & /*key*/)
{
    const auto source = make_source_string(format, file_path, define);
    const auto details = make_source_details(format, file_lines, define);
 
    if (!define.has_int_value()) {
        const auto error = format->format(
            "'{}' is not an integer value (found {} define)",
            FormatParam{define.name(), Style::bold},
            FormatParam{define.is_flag() ? "flag" : "string"});
        return LayerValue<std::size_t>::invalid(error, source, details);
    }
 
    const auto value = define.int_value();
    if (value < 0) {
        const auto error =
            format->format("'{}' has negative value {}", FormatParam{define.name(), Style::bold}, FormatParam{value});
        return LayerValue<std::size_t>::invalid(error, source, details);
    }
 
    return LayerValue<std::size_t>::valid(value, define.name(), source, details);
}
 
template <typename T, typename ParseFunc>
LayerValue<T> search_header_define(
    std::optional<CParserFacade> &driver,
    const TextFormatter *format,
    const std::filesystem::path &header_path,
    const std::string &define_name,
    ParseFunc parse_func,
    const std::string &key,
    const std::string &provider_name)
{
    // Get or create the parser driver
    auto &parser = get_parser_driver(driver, header_path, format);
 
    // Search for the define
    auto result = parser.find_define(define_name);
 
    if (!result.has_value()) {
        // Parse error or file not found - check if it's a file-not-found case
        // File not found should return not_provided, parse errors return invalid
        if (!std::filesystem::exists(header_path)) {
            return LayerValue<T>::not_provided();
        }
        // Parse error - return invalid with error message
        const auto base_error_msg = format->format(
            "failed to parse '{}' from '{}':",
            FormatParam{define_name, Style::bold},
            FormatParam{header_path.string(), Style::bold});
        std::vector<std::string> details_err_msg{};
        for (const auto &err : result.chain()) {
            if (const auto &details = err->details(*format); !details.empty()) {
                details_err_msg.append_range(err->details(*format));
                details_err_msg.emplace_back();
            }
        }
        return LayerValue<T>::invalid(base_error_msg, header_path.string(), details_err_msg);
    }
 
    if (!result.value().has_value()) {
        // Define not found in file
        return LayerValue<T>::not_provided();
    }
 
    // Parse the value
    auto layer_result = parse_func(format, result.value().value(), header_path.string(), parser.file_lines(), key);
    layer_result.source_key = provider_name;
    return layer_result;
}
 
} // namespace