ParameterInterface.hpp

#pragma once
 
#include <memory>
 
#include "state_representation/parameters/ParameterType.hpp"
#include "state_representation/exceptions/InvalidParameterCastException.hpp"
#include "state_representation/exceptions/InvalidPointerException.hpp"
#include "state_representation/State.hpp"
 
namespace state_representation {
 
// forward declaration of derived Parameter class
template<typename T>
class Parameter;
 
class ParameterInterface : public State {
public:
  ParameterInterface(
      const std::string& name, const ParameterType& type, const StateType& parameter_state_type = StateType::NONE
  );
 
  ParameterInterface(const ParameterInterface& parameter);
 
  virtual ~ParameterInterface() = default;
 
  ParameterInterface& operator=(const ParameterInterface& state);
 
  template<typename T>
  std::shared_ptr<Parameter<T>> get_parameter(bool validate_pointer = true) const;
 
  template<typename T>
  T get_parameter_value() const;
 
  template<typename T>
  void set_parameter_value(const T& value);
 
  ParameterType get_parameter_type() const;
 
  StateType get_parameter_state_type() const;
 
private:
  ParameterType parameter_type_;
  StateType parameter_state_type_;
};
 
template<typename T>
inline std::shared_ptr<Parameter<T>> ParameterInterface::get_parameter(bool validate_pointer) const {
  std::shared_ptr<Parameter<T>> parameter_ptr;
  try {
    parameter_ptr = std::dynamic_pointer_cast<Parameter<T>>(std::const_pointer_cast<State>(shared_from_this()));
  } catch (const std::exception&) {
    if (validate_pointer) {
      throw exceptions::InvalidPointerException(
          "Parameter interface \"" + get_name() + "\" is not managed by a valid pointer");
    }
  }
  if (parameter_ptr == nullptr && validate_pointer) {
    std::string type_name(typeid(T).name());
    throw exceptions::InvalidParameterCastException(
        "Unable to cast parameter interface \"" + get_name() + "\" to a parameter pointer of requested type "
            + type_name);
  }
  return parameter_ptr;
}
 
template<typename T>
inline T ParameterInterface::get_parameter_value() const {
  return get_parameter<T>(true)->get_value();
}
 
template<typename T>
inline void ParameterInterface::set_parameter_value(const T& value) {
  get_parameter<T>(true)->set_value(value);
}
 
}// namespace state_representation