Parameters.h

#pragma once
#ifndef PFLIB_CONFIG_PARAMETERS_H
#define PFLIB_CONFIG_PARAMETERS_H
 
/*~~~~~~~~~~~~~~~~*/
/*   C++ StdLib   */
/*~~~~~~~~~~~~~~~~*/
#include <any>
#include <boost/core/demangle.hpp>
#include <iostream>
#include <limits>
#include <map>
#include <string>
#include <type_traits>
#include <typeinfo>
#include <vector>
 
#include "pflib/Exception.h"
 
namespace pflib {
 
class Parameters {
 public:
  template <typename T>
  void add(const std::string& name, const T& value, bool overlay = false) {
    if (not overlay and exists(name)) {
      PFEXCEPTION_RAISE("Config",
                        "The parameter " + name +
                            " already exists in the list of parameters.");
    }
 
    parameters_[name] = value;
  }
 
  bool exists(const std::string& name) const;
 
  template <typename T>
  const T& get(const std::string& name) const {
    // Check if the variable exists in the map.  If it doesn't,
    // raise an exception.
    if (not exists(name)) {
      PFEXCEPTION_RAISE(
          "Config",
          "Parameter '" + name + "' does not exist in list of parameters.");
    }
 
    try {
      return std::any_cast<const T&>(parameters_.at(name));
    } catch (const std::bad_any_cast& e) {
      PFEXCEPTION_RAISE(
          "Config",
          "Parameter '" + name + "' of type '" +
              boost::core::demangle(parameters_.at(name).type().name()) +
              "' is being cast to incorrect type '" +
              boost::core::demangle(typeid(T).name()) + "'.");
    }
  }
 
  template <typename T>
  const T& get(const std::string& name, const T& def) const {
    if (not exists(name)) return def;
 
    // get here knowing that name exists in parameters_
    return get<T>(name);
  }
 
  std::vector<std::string> keys() const;
 
  void from_yaml(const std::string& filepath, bool overlay = true);
 
 private:
  std::map<std::string, std::any> parameters_;
 
};  // Parameters
}  // namespace pflib
 
#endif  // PFLIB_CONFIG_PARAMETERS_H