param_loader.h

// clang: MatousFormat
#pragma once
 
#include <rclcpp/rclcpp.hpp>
#include <string>
#include <unordered_set>
#include <Eigen/Dense>
#include <std_msgs/msg/color_rgba.hpp>
#include <mrs_lib/param_provider.h>
 
namespace mrs_lib
{
 
  template <typename T>
  std::ostream& operator<<(std::ostream& os, const Eigen::MatrixX<T>& var);
 
/*** ParamLoader CLASS //{ **/
 
class ParamLoader {
 
private:
  enum unique_t
  {
    UNIQUE   = true,
    REUSABLE = false
  };
  enum optional_t
  {
    OPTIONAL   = true,
    COMPULSORY = false
  };
  enum swap_t
  {
    SWAP    = true,
    NO_SWAP = false
  };
 
  template <typename T>
  using MatrixX = Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>;
 
  using resolved_name_t = ParamProvider::resolved_name_t;
 
private:
  bool                                m_load_successful, m_print_values;
  std::string                         m_node_name;
  std::shared_ptr<rclcpp::Node>       m_node;
  mrs_lib::ParamProvider              m_pp;
  std::unordered_set<resolved_name_t> m_loaded_params;
 
  /* printing helper functions //{ */
 
  /* printError and printWarning functions //{*/
 
  void printError(const std::string& str);
  void printWarning(const std::string& str);
 
  //}
 
  /* printValue function and overloads //{ */
 
  template <typename T>
  void printValue(const resolved_name_t& name, const T& value) const;
  
  //}
 
  //}
 
  /* loading helper functions //{ */
 
  /* check_duplicit_loading checks whether the parameter was already loaded - returns true if yes //{ */
 
  bool check_duplicit_loading(const resolved_name_t& name);
  
  //}
 
  /* helper functions for loading dynamic Eigen matrices //{ */
  // loadMatrixX helper function for loading dynamic Eigen matrices //{
  template <typename T>
  std::pair<MatrixX<T>, bool> loadMatrixX(const std::string& name, const MatrixX<T>& default_value, int rows, int cols = Eigen::Dynamic, optional_t optional = OPTIONAL, unique_t unique = UNIQUE, swap_t swap = NO_SWAP, bool printValues = true);
  //}
 
  /* loadMatrixStatic_internal helper function for loading static Eigen matrices //{ */
  template <int rows, int cols, typename T>
  std::pair<Eigen::Matrix<T, rows, cols>, bool> loadMatrixStatic_internal(const std::string& name, const Eigen::Matrix<T, rows, cols>& default_value, optional_t optional, unique_t unique);
  //}
 
  /* loadMatrixKnown_internal helper function for loading EigenXd matrices with known dimensions //{ */
  template <typename T>
  std::pair<MatrixX<T>, bool> loadMatrixKnown_internal(const std::string& name, const MatrixX<T>& default_value, int rows, int cols, optional_t optional, unique_t unique);
  //}
 
  /* loadMatrixDynamic_internal helper function for loading Eigen matrices with one dynamic (unspecified) dimension //{ */
  template <typename T>
  std::pair<MatrixX<T>, bool> loadMatrixDynamic_internal(const std::string& name, const MatrixX<T>& default_value, int rows, int cols, optional_t optional, unique_t unique);
  //}
 
  /* loadMatrixArray_internal helper function for loading an array of EigenXd matrices with known dimensions //{ */
  template <typename T>
  std::vector<MatrixX<T>> loadMatrixArray_internal(const std::string& name, const std::vector<MatrixX<T>>& default_value, optional_t optional, unique_t unique);
  //}
 
  //}
 
  /* load helper function for generic types //{ */
  // This function tries to load a parameter with name 'name' and a default value.
  // You can use the flag 'optional' to not throw a ROS_ERROR when the parameter
  // cannot be loaded and the flag 'printValues' to set whether the loaded
  // value and name of the parameter should be printed to cout.
  // If 'optional' is set to false and the parameter could not be loaded,
  // the flag 'load_successful' is set to false and a ROS_ERROR message
  // is printer.
  // If 'unique' flag is set to false then the parameter is not checked
  // for being loaded twice.
  // Returns a tuple, containing either the loaded or the default value and a bool,
  // indicating if the value was loaded (true) or the default value was used (false).
  template <typename T>
  std::pair<T, bool> load(const std::string& name, const T& default_value, optional_t optional = OPTIONAL, unique_t unique = UNIQUE);
  //}
  //}
 
public:
  ParamLoader(const std::shared_ptr<rclcpp::Node>& node, bool printValues = true, std::string_view node_name = std::string());
 
  /* Constructor overloads //{ */
  ParamLoader(const std::shared_ptr<rclcpp::Node>& node, std::string node_name);
 
  //}
 
  /* setPrefix function //{ */
 
  void setPrefix(const std::string& prefix);
 
  //}
 
  /* getPrefix function //{ */
 
  std::string getPrefix();
 
  //}
 
  /* addYamlFile() function //{ */
 
  bool addYamlFile(const std::string& filepath);
  //}
 
  /* addYamlFileFromParam() function //{ */
 
  bool addYamlFileFromParam(const std::string& param_name);
  //}
 
  void copyYamls(const ParamLoader& param_loader);
 
  ParamProvider& getParamProvider();
 
  /* loadedSuccessfully function //{ */
  bool loadedSuccessfully() const;
  //}
 
  /* resetLoadedSuccessfully function //{ */
  void resetLoadedSuccessfully();
  //}
 
  /* resetUniques function //{ */
  void resetUniques();
  //}
 
  /* loadParam function for optional parameters //{ */
  template <typename T>
  bool loadParam(const std::string& name, T& out_value, const T& default_value);
 
  template <typename T>
  T loadParam2(const std::string& name, const T& default_value);
 
  template <typename T>
  bool loadParamReusable(const std::string& name, T& out_value, const T& default_value);
 
  template <typename T>
  T loadParamReusable2(const std::string& name, const T& default_value);
 
  //}
 
  /* loadParam function for compulsory parameters //{ */
  template <typename T>
  bool loadParam(const std::string& name, T& out_value); 
 
  template <typename T>
  T loadParam2(const std::string& name);
 
  template <typename T>
  bool loadParamReusable(const std::string& name, T& out_value);
 
  template <typename T>
  T loadParamReusable2(const std::string& name);
 
  //}
 
  /* loadParam specializations for rclcpp::Duration type //{ */
 
  bool loadParam(const std::string& name, rclcpp::Duration& out, const rclcpp::Duration& default_value);
 
  bool loadParam(const std::string& name, rclcpp::Duration& out);
 
  //}
 
  /* loadParam specializations for std_msgs::msg::ColorRGBA type //{ */
 
  bool loadParam(const std::string& name, std_msgs::msg::ColorRGBA& out, const std_msgs::msg::ColorRGBA& default_value = std_msgs::msg::ColorRGBA());
 
  std_msgs::msg::ColorRGBA loadParam2(const std::string& name, const std_msgs::msg::ColorRGBA& default_value = std_msgs::msg::ColorRGBA());
 
  //}
 
  /* loadParam specializations and convenience functions for Eigen dynamic matrix type //{ */
 
  template <typename T>
  bool loadParam(const std::string& name, MatrixX<T>& mat, const MatrixX<T>& default_value);
 
  template <typename T>
  MatrixX<T> loadParam2(const std::string& name, const MatrixX<T>& default_value);
 
  //}
 
  // loadMatrixStatic function for loading of static Eigen::Matrices //{
 
  template <int rows, int cols, typename T>
  bool loadMatrixStatic(const std::string& name, Eigen::Matrix<T, rows, cols>& mat);
 
  template <int rows, int cols, typename T, typename Derived>
  bool loadMatrixStatic(const std::string& name, Eigen::Matrix<T, rows, cols>& mat, const Eigen::MatrixBase<Derived>& default_value);
 
  template <int rows, int cols, typename T = double>
  Eigen::Matrix<T, rows, cols> loadMatrixStatic2(const std::string& name);
 
  template <int rows, int cols, typename T, typename Derived>
  Eigen::Matrix<T, rows, cols> loadMatrixStatic2(const std::string& name, const Eigen::MatrixBase<Derived>& default_value);
 
  //}
 
  // loadMatrixKnown function for loading of Eigen matrices with known dimensions //{
 
  template <typename T>
  bool loadMatrixKnown(const std::string& name, MatrixX<T>& mat, int rows, int cols);
 
  template <typename T, typename Derived>
  bool loadMatrixKnown(const std::string& name, MatrixX<T>& mat, const Eigen::MatrixBase<Derived>& default_value, int rows, int cols);
 
  template <typename T = double>
  MatrixX<T> loadMatrixKnown2(const std::string& name, int rows, int cols);
 
  template <typename T, typename Derived>
  MatrixX<T> loadMatrixKnown2(const std::string& name, const Eigen::MatrixBase<Derived>& default_value, int rows, int cols);
 
  //}
 
  // loadMatrixDynamic function for half-dynamic loading of MatrixX<T> //{
 
  template <typename T>
  bool loadMatrixDynamic(const std::string& name, MatrixX<T>& mat, int rows, int cols);
 
  template <typename T, typename Derived>
  bool loadMatrixDynamic(const std::string& name, MatrixX<T>& mat, const Eigen::MatrixBase<Derived>& default_value, int rows, int cols);
 
  template <typename T = double>
  MatrixX<T> loadMatrixDynamic2(const std::string& name, int rows, int cols);
 
  template <typename T, typename Derived>
  MatrixX<T> loadMatrixDynamic2(const std::string& name, const Eigen::MatrixBase<Derived>& default_value, int rows, int cols);
 
  //}
 
  // loadMatrixArray function for loading of an array of MatrixX<T> with known dimensions //{
  template <typename T>
  void loadMatrixArray(const std::string& name, std::vector<MatrixX<T>>& mat);
 
  template <typename T>
  void loadMatrixArray(const std::string& name, std::vector<MatrixX<T>>& mat, const std::vector<MatrixX<T>>& default_value);
 
  template <typename T = double>
  std::vector<MatrixX<T>> loadMatrixArray2(const std::string& name);
 
  template <typename T>
  std::vector<MatrixX<T>> loadMatrixArray2(const std::string& name, const std::vector<MatrixX<T>>& default_value);
  
  //}
 
};
//}
 
template <>
rclcpp::Duration ParamLoader::loadParam2<rclcpp::Duration>(const std::string& name, const rclcpp::Duration& default_value);
 
template <>
rclcpp::Duration ParamLoader::loadParam2<rclcpp::Duration>(const std::string& name);
 
}  // namespace mrs_lib
 
#include <mrs_lib/impl/param_loader.hpp>