config_value.hpp

Go to the documentation of this file.

#pragma once
 
#include <ranges>
#include <string>
#include <utility>
#include <vector>
 
#include "porytiles/utilities/text/text_formatter.hpp"
#include "porytiles/xcut/config/config_pod_field.hpp"
 
namespace porytiles {
 
template <typename T>
class ConfigValue {
  public:
    ConfigValue() = default;
 
    ConfigValue(
        T value,
        std::string canonical_name,
        std::string source_key,
        std::string source,
        const std::vector<std::string> &source_details)
        : value_{std::move(value)}, canonical_name_{std::move(canonical_name)}, source_key_{std::move(source_key)},
          source_{std::move(source)}, source_details_{source_details}
    {
    }
 
    // NOLINTNEXTLINE
    operator const T &() const &
    {
        return value_;
    }
 
    // NOLINTNEXTLINE
    operator T &&() &&
    {
        return std::move(value_);
    }
 
    [[nodiscard]] const T &value() const &
    {
        return value_;
    }
 
    [[nodiscard]] T &&value() &&
    {
        return std::move(value_);
    }
 
    [[nodiscard]] const std::string &canonical_name() const
    {
        return canonical_name_;
    }
 
    [[nodiscard]] const std::string &source_key() const
    {
        return source_key_;
    }
 
    [[nodiscard]] const std::string &source() const
    {
        return source_;
    }
 
    [[nodiscard]] const std::vector<std::string> &source_details() const
    {
        return source_details_;
    }
 
    template <typename U>
    [[nodiscard]] ConfigValue<U> derive(const ConfigPODField<U> &override) const
    {
        return ConfigValue<U>{
            *override,
            override.canonical_name,
            override.source_key,
            override.source_info.empty() ? source() : override.source_info,
            override.source_details.empty() ? source_details() : override.source_details};
    }
 
    [[nodiscard]] std::pair<std::vector<std::string>, std::vector<std::vector<FormatParam>>> format_data() const
    {
        // foo = 3
        // Source: ./porytiles.yaml:12
        // ... details here
 
        std::vector<std::string> err_text{};
        std::vector<std::vector<FormatParam>> params{};
 
        err_text.emplace_back("{} = {}");
        params.push_back(
            std::vector{
                FormatParam{source_key(), Style::bold},
                FormatParam{value(), Style::bold | Style::italic | Style::yellow}});
        err_text.emplace_back("Source: {}");
        params.push_back(std::vector{FormatParam{source(), Style::italic}});
 
        // Add source details if available
        if (!source_details().empty()) {
            err_text.emplace_back("");
            params.emplace_back();
            err_text.append_range(source_details());
            for (const auto &_ : source_details()) {
                params.emplace_back();
            }
        }
 
        return {err_text, params};
    }
 
    [[nodiscard]] std::vector<std::string> prettify(const TextFormatter &formatter) const
    {
        const auto [format_strings, param_vectors] = format_data();
 
        std::vector<std::string> result;
        result.reserve(format_strings.size());
 
        for (const auto &[text, params] : std::views::zip(format_strings, param_vectors)) {
            result.push_back(formatter.format(text, params));
        }
 
        return result;
    }
 
  private:
    T value_;
    std::string canonical_name_;
    std::string source_key_;
    std::string source_;
    std::vector<std::string> source_details_;
};
 
} // namespace porytiles