Parameters.h

#ifndef FRAMEWORK_PARAMETERS_H
#define FRAMEWORK_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 "Framework/Exception/Exception.h"
 
namespace framework::config {
 
class Parameters {
 public:
  template <typename T>
  void add(const std::string& name, const T& value) {
    if (exists(name)) {
      EXCEPTION_RAISE("Config",
                      "The parameter " + name +
                          " already exists in the list of parameters.");
    }
 
    parameters_[name] = value;
  }
  void add(const std::string& name, const T& value) {…}
 
  template <typename T>
  void addParameter(const std::string& name, const T& value) {
    add<T>(name, value);
  }
 
  bool exists(const std::string& name) const {
    return parameters_.find(name) != parameters_.end();
  }
  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)) {
      EXCEPTION_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) {
      EXCEPTION_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()) + "'.");
    }
  }
  const T& get(const std::string& name) const  {…}
 
  template <typename T>
  const T& getParameter(const std::string& name) const {
    return get<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);
  }
  const T& get(const std::string& name, const T& def) const  {…}
 
  template <typename T>
  const T& getParameter(const std::string& name, const T& def) const {
    return get<T>(name, def);
  }
 
  std::vector<std::string> keys() const {
    std::vector<std::string> key;
    for (auto i : parameters_) key.push_back(i.first);
    return key;
  }
  std::vector<std::string> keys() const  {…}
 
 private:
  std::map<std::string, std::any> parameters_;
 
};  // Parameters
class Parameters {…};
}  // namespace framework::config
namespace framework::config {…}
 
#endif  // FRAMEWORK_PARAMETERS_H