configuration.h

Go to the documentation of this file.

#ifndef CONFIGURATION_H
#define CONFIGURATION_H
 
#include "pogosim.h"
#include "geometry.h"
 
#include <yaml-cpp/yaml.h>
#include <string>
#include <stdexcept>
#include <sstream>
#include <vector>
#include <utility>
#include <type_traits>

inline std::string polygons_to_yaml(const arena_polygons_t &polygons) {
    YAML::Node root(YAML::NodeType::Sequence);
 
    for (const auto &poly : polygons) {
        YAML::Node poly_node(YAML::NodeType::Sequence);
        for (const auto &v : poly) {
            YAML::Node vtx;
            vtx["x"] = v.x;
            vtx["y"] = v.y;
            poly_node.push_back(vtx);
        }
        root.push_back(poly_node);
    }
 
    YAML::Emitter emitter;
    emitter << root;              // Default = block style, indented
    return {emitter.c_str(), static_cast<std::size_t>(emitter.size())};
}
 

class Configuration {
public:
    Configuration();

    explicit Configuration(const YAML::Node &node);

    void load(const std::string& file_name);

    Configuration operator[](const std::string& key) const;

    Configuration at_path(const std::string& dotted_key) const;

    template<typename T>
    T get_path(const std::string& dotted_key, const T& default_value = T()) const;

    template<typename T>
    T get(const T& default_value = T()) const;

    template<typename T>
    void set(const std::string& key, const T& value);

    bool exists() const;

    std::string summary() const;

    std::vector<std::pair<std::string, Configuration>> children() const;
 
private:
    YAML::Node node_;
    mutable YAML::Node resolved_cache_;  // Cache for resolved hierarchical default
    mutable bool cache_valid_;           // Whether the cache is valid

    static YAML::Node resolve_hierarchical_default(const YAML::Node& n);
    
    const YAML::Node& get_resolved() const;
 
};
 
 
namespace detail {

template<typename T>
typename std::enable_if<std::is_arithmetic<T>::value, T>::type
numeric_fallback(const YAML::Node& n, const T& default_value) {
    try {
        // integral → go through double, floating-point → long double
        typedef typename std::conditional<
                std::is_integral<T>::value, double, long double>::type tmp_t;
 
        tmp_t tmp = n.as<tmp_t>();            // may still throw
        return static_cast<T>(tmp);
    } catch (const YAML::Exception&) {
        return default_value;                 // out-of-range, etc.
    }
}

template<typename T>
typename std::enable_if<!std::is_arithmetic<T>::value, T>::type
numeric_fallback(const YAML::Node&, const T& default_value) {
    return default_value;
}
 
} // namespace detail
 
template<typename T>
T Configuration::get(const T& default_value) const {
    if (!node_) {                      // nothing stored here
        return default_value;
    }
 
    // Get the cached resolved node at this level
    const YAML::Node& target_ref = get_resolved();
    YAML::Node target = target_ref;  // Copy for subsequent modifications
 
    /* honour an eventual "default_option" sub-key ---------------- */
    if (target.IsMap()) {
        YAML::Node opt = target["default_option"];
        if (opt) { target = opt; }
    }
 
    /* -------- 1st attempt – let yaml-cpp do the conversion ------ */
    try {
        return target.as<T>();         // success? great, we’re done.
    } catch (const YAML::Exception&) {
        /* -------- 2nd attempt – only if T is numeric ------------ */
        return detail::numeric_fallback(target, default_value);
    }
}
 
template<typename T>
void Configuration::set(const std::string& key, const T& value) {
    // Ensure the current node is a map; if not, convert it to one.
    if (!node_ || !node_.IsMap()) {
        node_ = YAML::Node(YAML::NodeType::Map);
    }
    node_[key] = value;
}
 
template<typename T>
T Configuration::get_path(const std::string& dotted_key, const T& default_value) const {
    return at_path(dotted_key).get<T>(default_value);
}
 
 
#endif // CONFIGURATION_H
 
// MODELINE "{{{1
// vim:expandtab:softtabstop=4:shiftwidth=4:fileencoding=utf-8
// vim:foldmethod=marker