ParameterMap.hpp

#pragma once
 
#include <list>
#include <map>
#include <memory>
 
#include "state_representation/exceptions/InvalidParameterException.hpp"
#include "state_representation/parameters/Parameter.hpp"
 
namespace state_representation {
 
typedef std::list<std::shared_ptr<ParameterInterface>> ParameterInterfaceList;
typedef std::map<std::string, std::shared_ptr<ParameterInterface>> ParameterInterfaceMap;
 
class ParameterMap {
public:
 
  ParameterMap() = default;
 
  explicit ParameterMap(const ParameterInterfaceList& parameters);
 
  explicit ParameterMap(const ParameterInterfaceMap& parameters);
 
  [[nodiscard]] std::shared_ptr<ParameterInterface> get_parameter(const std::string& name) const;
 
  [[nodiscard]] ParameterInterfaceMap get_parameters() const;
 
  template<typename T>
  [[nodiscard]] T get_parameter_value(const std::string& name) const;
 
  [[nodiscard]] ParameterInterfaceList get_parameter_list() const;
 
  void set_parameter(const std::shared_ptr<ParameterInterface>& parameter);
 
  void set_parameters(const ParameterInterfaceList& parameters);
 
  void set_parameters(const ParameterInterfaceMap& parameters);
 
  template<typename T>
  void set_parameter_value(const std::string& name, const T& value);
 
  void remove_parameter(const std::string& name);
 
protected:
 
  virtual void validate_and_set_parameter(const std::shared_ptr<ParameterInterface>& parameter);
 
  void assert_parameter_valid(const std::shared_ptr<ParameterInterface>& parameter);
 
  ParameterInterfaceMap parameters_; 
 
};
 
template<typename T>
inline T ParameterMap::get_parameter_value(const std::string& name) const {
  return this->get_parameter(name)->get_parameter_value<T>();
}
 
template<typename T>
inline void ParameterMap::set_parameter_value(const std::string& name, const T& value) {
  this->validate_and_set_parameter(make_shared_parameter<T>(name, value));
}
 
}