Parameters.h

#ifndef FRAMEWORK_PARAMETERS_H
#define FRAMEWORK_PARAMETERS_H
 
/*~~~~~~~~~~~~~~~~*/
/*   C++ StdLib   */
/*~~~~~~~~~~~~~~~~*/
#include <any>
#include <iostream>
#include <limits>
#include <map>
#include <string>
#include <type_traits>
#include <typeinfo>
#include <vector>
#include <boost/core/demangle.hpp>
#include "fire/exception/Exception.h"
 
namespace fire::config {
 
class Parameters {
 public:
  template <typename T>
  void add(const std::string& name, const T& value) {
    if (exists(name)) {
      throw Exception("Config",
          "The parameter " + name + " already exists in the list of parameters.");
    }
 
    parameters_[name] = 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();
  }
 
  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)) {
      throw Exception("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) {
      throw Exception("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& 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);
  }
 
  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;
  }
 
 private:
  std::map<std::string, std::any> parameters_;
 
};  // Parameters
}  // namespace fire::config
 
#endif  // FRAMEWORK_PARAMETERS_H