param_provider.h

Go to the documentation of this file.

// clang: MatousFormat
#pragma once
 
#include <concepts>
#include <memory>
#include <optional>
 
#include <yaml-cpp/yaml.h>
#include <rclcpp/rclcpp.hpp>
 
namespace mrs_lib
{
 
  template <typename T>
  std::ostream& operator<<(std::ostream& os, const std::vector<T>& var);
 
  template <typename Key, typename Value>
  std::ostream& operator<<(std::ostream& os, const std::map<Key, Value>& var);
 
  std::ostream& operator<<(std::ostream& os, rclcpp::ParameterType& var);
 
  template <typename T>
  rclcpp::ParameterType to_param_type();
 
  template <typename T>
  concept numeric = (std::integral<T> || std::floating_point<T>) && !std::same_as<T, bool>;
 
/*** ParamProvider CLASS //{ **/
 
class ParamProvider
{
public:
  struct resolved_name_t;
 
  template <typename T>
  struct range_t
  {
    T minimum;
    T maximum;
  };
 
  template <typename T>
  struct declare_options_t
  {
    bool reconfigurable = false;
    std::optional<T> default_value = std::nullopt;
    std::optional<range_t<T>> range = std::nullopt;
  };
 
  template <typename T>
  struct get_options_t
  {
    bool always_declare = false;
    bool use_yaml = true;
    std::optional<bool> use_rosparam = std::nullopt;
    std::optional<std::string> prefix = std::nullopt;
    declare_options_t<T> declare_options = {};
  };
 
  template <typename T>
  struct set_options_t
  {
    std::optional<std::string> prefix = std::nullopt;
    declare_options_t<T> declare_options = {};
  };
 
  ParamProvider(const std::shared_ptr<rclcpp::Node>& node, const bool use_rosparam = true);
 
  bool addYamlFile(const std::string& filepath);
 
  void copyYamls(const ParamProvider& param_provider);
 
  template <typename T>
  bool getParam(const std::string& param_name, T& value_out) const;
 
  template <typename T>
  bool getParam(const resolved_name_t& resolved_name, T& value_out, const get_options_t<T>& opts = {}) const;
 
  template <typename T>
  bool setParam(const std::string& param_name, const T& value) const;
 
  template <typename T>
  bool setParam(const resolved_name_t& resolved_name, const T& value, const set_options_t<T>& opts = {}) const;
 
  template <typename T>
  bool declareParam(const std::string& param_name) const;
 
  template <typename T>
  bool declareParam(const std::string& param_name, const T& default_value) const;
 
  template <typename T>
  bool declareParam(const resolved_name_t& resolved_name, const declare_options_t<T>& opts = {}) const;
 
  void setPrefix(const std::string& prefix);
 
  std::string getPrefix() const;
 
  resolved_name_t resolveName(const std::string& param_name) const;
 
private:
  std::vector<std::shared_ptr<YAML::Node>> m_yamls;
  std::shared_ptr<rclcpp::Node> m_node;
  std::string m_node_name;
  bool m_use_rosparam;
  std::string m_prefix;
 
  std::optional<YAML::Node> findYamlNode(const resolved_name_t& resolved_name) const;
 
  template <typename T>
  bool ranges_match(const rcl_interfaces::msg::ParameterDescriptor& descriptor, const range_t<T>& declare_range) const;
 
  template <typename T>
  bool loadFromYaml(const resolved_name_t& resolved_name, T& value_out, const get_options_t<T>& opts) const;
 
  template <typename T>
  bool loadFromROS(const resolved_name_t& resolved_name, T& value_out, const get_options_t<T>& opts) const;
};
//}
 
}  // namespace mrs_lib
 
#ifndef PARAM_PROVIDER_HPP
#include <mrs_lib/impl/param_provider.hpp>
#endif