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>