packing_strategy_params.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
#include <cstdint>
#include <format>
#include <ostream>
#include <string>
 
#include "porytiles/domain/config/search_algorithm.hpp"
#include "porytiles/domain/config/shuffle_strategy.hpp"
#include "porytiles/xcut/config/config_pod_field.hpp"
 
namespace porytiles {
 
struct BacktrackingParams {
    ConfigPODField<SearchAlgorithm> search_algorithm;
    ConfigPODField<std::size_t> node_cutoff;
    ConfigPODField<std::size_t> best_branches;
    ConfigPODField<bool> smart_prune;
 
    [[nodiscard]] bool has_any() const
    {
        return search_algorithm.has_value() || node_cutoff.has_value() || best_branches.has_value() ||
               smart_prune.has_value();
    }
};
 
struct OverloadAndRemoveParams {
    ConfigPODField<std::size_t> max_attempts;
    ConfigPODField<std::uint64_t> seed;
    ConfigPODField<ShuffleStrategy> shuffle_strategy;
 
    [[nodiscard]] bool has_any() const
    {
        return max_attempts.has_value() || seed.has_value() || shuffle_strategy.has_value();
    }
};
 
struct PackingStrategyParams {
    BacktrackingParams backtracking;
    OverloadAndRemoveParams overload_and_remove;
};
 
[[nodiscard]] inline std::string to_string(const PackingStrategyParams &params)
{
    std::string result = "{backtracking={";
    if (params.backtracking.has_any()) {
        bool first = true;
        if (params.backtracking.search_algorithm.has_value()) {
            result += "search_algorithm=" + to_string(*params.backtracking.search_algorithm);
            first = false;
        }
        if (params.backtracking.node_cutoff.has_value()) {
            if (!first) {
                result += ", ";
            }
            result += "node_cutoff=" + std::to_string(*params.backtracking.node_cutoff);
            first = false;
        }
        if (params.backtracking.best_branches.has_value()) {
            if (!first) {
                result += ", ";
            }
            result += "best_branches=" + std::to_string(*params.backtracking.best_branches);
            first = false;
        }
        if (params.backtracking.smart_prune.has_value()) {
            if (!first) {
                result += ", ";
            }
            result += "smart_prune=";
            result += (*params.backtracking.smart_prune ? "true" : "false");
        }
    }
    result += "}, overload_and_remove={";
    if (params.overload_and_remove.has_any()) {
        bool first = true;
        if (params.overload_and_remove.max_attempts.has_value()) {
            result += "max_attempts=" + std::to_string(*params.overload_and_remove.max_attempts);
            first = false;
        }
        if (params.overload_and_remove.seed.has_value()) {
            if (!first) {
                result += ", ";
            }
            result += "seed=" + std::to_string(*params.overload_and_remove.seed);
            first = false;
        }
        if (params.overload_and_remove.shuffle_strategy.has_value()) {
            if (!first) {
                result += ", ";
            }
            result += "shuffle_strategy=" + to_string(*params.overload_and_remove.shuffle_strategy);
        }
    }
    result += "}}";
    return result;
}
 
inline std::ostream &operator<<(std::ostream &os, const PackingStrategyParams &params)
{
    return os << to_string(params);
}
 
} // namespace porytiles
 
template <>
struct std::formatter<porytiles::PackingStrategyParams> {
    constexpr auto parse(std::format_parse_context &ctx)
    {
        return ctx.begin();
    }
 
    auto format(const porytiles::PackingStrategyParams &value, auto &ctx) const
    {
        return std::format_to(ctx.out(), "{}", porytiles::to_string(value));
    }
};