param_loader.h

Go to the documentation of this file.

// clang: MatousFormat
#ifndef PARAM_LOADER_H
#define PARAM_LOADER_H
 
#include <ros/ros.h>
#include <string>
#include <map>
#include <unordered_set>
#include <iostream>
#include <Eigen/Dense>
#include <std_msgs/ColorRGBA.h>
#include <mrs_lib/param_provider.h>
 
namespace mrs_lib
{
 
/*** 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>;
 
private:
  bool m_load_successful, m_print_values;
  std::string m_node_name;
  std::string m_prefix;
  const ros::NodeHandle& m_nh;
  mrs_lib::ParamProvider m_pp;
  std::unordered_set<std::string> m_loaded_params;
 
  /* printing helper functions //{ */
  /* printError and print_warning functions //{*/
  void printError(const std::string& str)
  {
    if (m_node_name.empty())
      ROS_ERROR_STREAM(str);
    else
      ROS_ERROR_STREAM("[" << m_node_name << "]: " << str);
  }
  void print_warning(const std::string& str)
  {
    if (m_node_name.empty())
      ROS_WARN_STREAM(str);
    else
      ROS_WARN_STREAM("[" << m_node_name << "]: " << str);
  }
  //}
 
  /* printValue function and overloads //{ */
 
  template <typename T>
  void printValue(const std::string& name, const T& value)
  {
    if (m_node_name.empty())
      std::cout << "\t" << name << ":\t" << value << std::endl;
    else
      ROS_INFO_STREAM("[" << m_node_name << "]: parameter '" << name << "':\t" << value);
  }
 
  template <typename T>
  void printValue(const std::string& name, const std::vector<T>& value)
  {
    std::stringstream strstr;
    if (m_node_name.empty())
      strstr << "\t";
    strstr << name << ":\t";
    size_t it = 0;
    for (const auto& elem : value)
    {
      strstr << elem;
      if (it < value.size() - 1)
        strstr << ", ";
      it++;
    }
    if (m_node_name.empty())
      std::cout << strstr.str() << std::endl;
    else
      ROS_INFO_STREAM("[" << m_node_name << "]: parameter '" << strstr.str());
  }
 
  template <typename T1, typename T2>
  void printValue(const std::string& name, const std::map<T1, T2>& value)
  {
    std::stringstream strstr;
    if (m_node_name.empty())
      strstr << "\t";
    strstr << name << ":" << std::endl;
    size_t it = 0;
    for (const auto& pair : value)
    {
      strstr << pair.first << " = " << pair.second;
      if (it < value.size() - 1)
        strstr << std::endl;
      it++;
    }
    if (m_node_name.empty())
      std::cout << strstr.str() << std::endl;
    else
      ROS_INFO_STREAM("[" << m_node_name << "]: parameter '" << strstr.str());
  }
 
  template <typename T>
  void printValue(const std::string& name, const MatrixX<T>& value)
  {
    std::stringstream strstr;
    /* const Eigen::IOFormat fmt(4, 0, ", ", "\n", "\t\t[", "]"); */
    /* strstr << value.format(fmt); */
    const Eigen::IOFormat fmt;
    strstr << value.format(fmt);
    if (m_node_name.empty())
      std::cout << "\t" << name << ":\t" << std::endl << strstr.str() << std::endl;
    else
      ROS_INFO_STREAM("[" << m_node_name << "]: parameter '" << name << "':" << std::endl << strstr.str());
  }
 
  std::string printValue_recursive(const std::string& name, XmlRpc::XmlRpcValue& value, unsigned depth = 0)
  {
    std::stringstream strstr;
    for (unsigned it = 0; it < depth; it++)
      strstr << "\t";
    strstr << name << ":";
    switch (value.getType())
    {
      case XmlRpc::XmlRpcValue::TypeArray:
        {
          for (int it = 0; it < value.size(); it++)
          {
            strstr << std::endl;
            const std::string name = "[" + std::to_string(it) + "]";
            strstr << printValue_recursive(name, value[it], depth+1);
          }
          break;
        }
      case XmlRpc::XmlRpcValue::TypeStruct:
        {
          int it = 0;
          for (auto& pair : value)
          {
            strstr << std::endl;
            strstr << printValue_recursive(pair.first, pair.second, depth+1);
            it++;
          }
          break;
        }
      default:
        {
          strstr << "\t" << value;
          break;
        }
    }
    return strstr.str();
  }
 
  void printValue(const std::string& name, XmlRpc::XmlRpcValue& value)
  {
    const std::string txt = printValue_recursive(name, value);
    if (m_node_name.empty())
      std::cout << txt << std::endl;
    else
      ROS_INFO_STREAM("[" << m_node_name << "]: parameter '" << txt);
  }
 
  //}
  
  std::string resolved(const std::string& param_name)
  {
    return m_nh.resolveName(param_name);
  }
  //}
 
  /* check_duplicit_loading checks whether the parameter was already loaded - returns true if yes //{ */
  bool check_duplicit_loading(const std::string& name)
  {
    if (m_loaded_params.count(name))
    {
      printError(std::string("Tried to load parameter ") + name + std::string(" twice"));
      m_load_successful = false;
      return true;
    } else
    {
      return false;
    }
  }
  //}
 
  /* 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)
  {
    const std::string name_prefixed = m_prefix + name;
    MatrixX<T> loaded = default_value;
    bool used_rosparam_value = false;
    // first, check if the user already tried to load this parameter
    if (unique && check_duplicit_loading(name_prefixed))
      return {loaded, used_rosparam_value};
 
    // this function only accepts dynamic columns (you can always transpose the matrix afterward)
    if (rows < 0)
    {
      // if the parameter was compulsory, alert the user and set the flag
      printError(std::string("Invalid expected matrix dimensions for parameter ") + resolved(name_prefixed));
      m_load_successful = false;
      return {loaded, used_rosparam_value};
    }
    const bool expect_zero_matrix = rows == 0;
    if (expect_zero_matrix)
    {
      if (cols > 0)
      {
        printError(std::string("Invalid expected matrix dimensions for parameter ") + resolved(name_prefixed) + ". One dimension indicates zero matrix, but other expects non-zero.");
        m_load_successful = false;
        return {loaded, used_rosparam_value};
      }
    }
 
    bool cur_load_successful = true;
    bool check_size_exact = true;
    if (cols <= 0)  // this means that the cols dimension is dynamic or a zero matrix is expected
      check_size_exact = false;
 
    std::vector<T> tmp_vec;
    // try to load the parameter
    const bool success = m_pp.getParam(name_prefixed, tmp_vec);
    // check if the loaded vector has correct length
    bool correct_size = (int)tmp_vec.size() == rows * cols;
    if (!check_size_exact && !expect_zero_matrix)
      correct_size = (int)tmp_vec.size() % rows == 0;  // if the cols dimension is dynamic, the size just has to be divisable by rows
 
    if (success && correct_size)
    {
      // if successfully loaded, everything is in order
      // transform the vector to the matrix
      if (cols <= 0 && rows > 0)
        cols = tmp_vec.size() / rows;
      if (swap)
        std::swap(rows, cols);
      loaded = Eigen::Map<Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>, Eigen::Unaligned>(tmp_vec.data(), rows, cols);
      used_rosparam_value = true;
    } else
    {
      if (success && !correct_size)
      {
        // warn the user that this parameter was not successfully loaded because of wrong vector length (might be an oversight)
        std::string warning =
            std::string("Matrix parameter ") + name_prefixed
            + std::string(" could not be loaded because the vector has a wrong length " + std::to_string(tmp_vec.size()) + " instead of expected ");
        // process the message correctly based on whether the loaded matrix should be dynamic or static
        if (cols <= 0)  // for dynamic matrices
          warning = warning + std::string("number divisible by ") + std::to_string(rows);
        else  // for static matrices
          warning = warning + std::to_string(rows * cols);
        print_warning(warning);
      }
      // if it was not loaded, the default value is used (set at the beginning of the function)
      if (!optional)
      {
        // if the parameter was compulsory, alert the user and set the flag
        printError(std::string("Could not load non-optional parameter ") + resolved(name_prefixed));
        cur_load_successful = false;
      }
    }
 
    // check if load was a success
    if (cur_load_successful)
    {
      if (m_print_values && printValues)
        printValue(name_prefixed, loaded);
      m_loaded_params.insert(name_prefixed);
    } else
    {
      m_load_successful = false;
    }
    // finally, return the resulting value
    return {loaded, used_rosparam_value};
  }
  //}
 
  /* 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)
  {
    const auto [dynamic, loaded_ok] = loadMatrixX(name, MatrixX<T>(default_value), rows, cols, optional, unique, NO_SWAP);
    return {dynamic, loaded_ok};
  }
  //}
 
  /* 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)
  {
    MatrixX<T> loaded = default_value;
    // first, check that at least one dimension is set
    if (rows <= 0 || cols <= 0)
    {
      printError(std::string("Invalid expected matrix dimensions for parameter ") + resolved(name) + std::string(" (use loadMatrixDynamic?)"));
      m_load_successful = false;
      return {loaded, false};
    }
 
    return loadMatrixX(name, default_value, rows, cols, optional, unique, NO_SWAP);
  }
  //}
 
  /* 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)
  {
    MatrixX<T> loaded = default_value;
 
    // next, check that at least one dimension is set
    if (rows <= 0 && cols <= 0)
    {
      printError(std::string("Invalid expected matrix dimensions for parameter ") + resolved(name) + std::string(" (at least one dimension must be specified)"));
      m_load_successful = false;
      return {loaded, false};
    }
 
    swap_t swap = NO_SWAP;
    if (rows <= 0)
    {
      std::swap(rows, cols);
      swap = SWAP;
    }
    return loadMatrixX(name, default_value, rows, cols, optional, unique, swap);
  }
  //}
  //}
 
  /* 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)
  {
    const std::string name_prefixed = m_prefix + name;
    int rows;
    std::vector<int> cols;
    bool success = true;
    success = success && m_pp.getParam(name_prefixed + "/rows", rows);
    success = success && m_pp.getParam(name_prefixed + "/cols", cols);
 
    std::vector<MatrixX<T>> loaded;
    loaded.reserve(cols.size());
 
    int total_cols = 0;
    /* check correctness of loaded parameters so far calculate the total dimension //{ */
 
    if (!success)
    {
      printError(std::string("Failed to load ") + resolved(name_prefixed) + std::string("/rows or ") + resolved(name_prefixed) + std::string("/cols"));
      m_load_successful = false;
      return default_value;
    }
    if (rows < 0)
    {
      printError(std::string("Invalid expected matrix dimensions for parameter ") + resolved(name_prefixed) + std::string(" (rows and cols must be >= 0)"));
      m_load_successful = false;
      return default_value;
    }
    for (const auto& col : cols)
    {
      if (col < 0)
      {
        printError(std::string("Invalid expected matrix dimensions for parameter ") + resolved(name_prefixed) + std::string(" (rows and cols must be >= 0)"));
        m_load_successful = false;
        return default_value;
      }
      total_cols += col;
    }
    
    //}
 
    const auto [loaded_matrix, loaded_ok] = loadMatrixX(name + "/data", MatrixX<T>(), rows, total_cols, optional, unique, NO_SWAP, false);
    /* std::cout << "loaded_matrix: " << loaded_matrix << std::endl; */
    /* std::cout << "loaded_matrix: " << loaded_matrix.rows() << "x" << loaded_matrix.cols() << std::endl; */
    /* std::cout << "expected dims: " << rows << "x" << total_cols << std::endl; */
    if (loaded_matrix.rows() != rows || loaded_matrix.cols() != total_cols)
    {
      m_load_successful = false;
      return default_value;
    }
 
    int cols_loaded = 0;
    for (unsigned it = 0; it < cols.size(); it++)
    {
      const int cur_cols = cols.at(it);
      const MatrixX<T> cur_mat = loaded_matrix.block(0, cols_loaded, rows, cur_cols);
      /* std::cout << "cur_mat: " << cur_mat << std::endl; */
      loaded.push_back(cur_mat);
      cols_loaded += cur_cols;
      printValue(name_prefixed + "/matrix#" + std::to_string(it), cur_mat);
    }
    return loaded;
  }
  //}
 
  /* 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)
  {
    const std::string name_prefixed = m_prefix + name;
    T loaded = default_value;
    if (unique && check_duplicit_loading(name_prefixed))
      return {loaded, false};
 
    bool cur_load_successful = true;
    // try to load the parameter
    const bool success = m_pp.getParam(name_prefixed, loaded);
    if (!success)
    {
      // if it was not loaded, set the default value
      loaded = default_value;
      if (!optional)
      {
        // if the parameter was compulsory, alert the user and set the flag
        printError(std::string("Could not load non-optional parameter ") + resolved(name_prefixed));
        cur_load_successful = false;
      }
    }
 
    if (cur_load_successful)
    {
      // everything is fine and just print the name_prefixed and value if required
      if (m_print_values)
        printValue(name_prefixed, loaded);
      // mark the param name_prefixed as successfully loaded
      m_loaded_params.insert(name_prefixed);
    } else
    {
      m_load_successful = false;
    }
    // finally, return the resulting value
    return {loaded, success};
  }
  //}
 
public:
  ParamLoader(const ros::NodeHandle& nh, bool printValues = true, std::string_view node_name = std::string())
      : m_load_successful(true),
        m_print_values(printValues),
        m_node_name(node_name),
        m_nh(nh),
        m_pp(nh, m_node_name)
  {
    /* std::cout << "Initialized1 ParamLoader for node " << node_name << std::endl; */
  }
 
  /* Constructor overloads //{ */
  ParamLoader(const ros::NodeHandle& nh, std::string_view node_name)
      : ParamLoader(nh, true, node_name)
  {
    /* std::cout << "Initialized2 ParamLoader for node " << node_name << std::endl; */
  }
 
  ParamLoader(const std::string& filepath, const ros::NodeHandle& nh)
    : ParamLoader(nh, "none")
  {
    YAML::Node node = YAML::Load(filepath);
  }
  //}
 
  /* setPrefix function //{ */
  
  void setPrefix(const std::string& prefix)
  {
    m_prefix = prefix;
  }
  
  //}
 
  /* getPrefix function //{ */
  
  std::string getPrefix()
  {
    return m_prefix;
  }
  
  //}
 
  /* addYamlFile() function //{ */
  
  bool addYamlFile(const std::string& filepath)
  {
    return m_pp.addYamlFile(filepath);
  }
  //}
 
  /* addYamlFileFromParam() function //{ */
  
  bool addYamlFileFromParam(const std::string& param_name)
  {
    std::string filepath;
    if (!loadParam(param_name, filepath))
      return false;
    return m_pp.addYamlFile(filepath);
  }
  //}
 
  /* loadedSuccessfully function //{ */
  bool loadedSuccessfully()
  {
    return m_load_successful;
  }
  //}
 
  /* resetLoadedSuccessfully function //{ */
  void resetLoadedSuccessfully()
  {
    m_load_successful = true;
  }
  //}
 
  /* resetUniques function //{ */
  void resetUniques()
  {
    m_loaded_params.clear();
  }
  //}
 
  /* loadParam function for optional parameters //{ */
  template <typename T>
  bool loadParam(const std::string& name, T& out_value, const T& default_value)
  {
    const auto [ret, success] = load<T>(name, default_value, OPTIONAL, UNIQUE);
    out_value = ret;
    return success;
  }
  template <typename T>
  T loadParam2(const std::string& name, const T& default_value)
  {
    const auto loaded = load<T>(name, default_value, OPTIONAL, UNIQUE);
    return loaded.first;
  }
  template <typename T>
  bool loadParamReusable(const std::string& name, T& out_value, const T& default_value)
  {
    const auto [ret, success] = load<T>(name, default_value, OPTIONAL, REUSABLE);
    out_value = ret;
    return success;
  }
  template <typename T>
  T loadParamReusable2(const std::string& name, const T& default_value)
  {
    const auto [ret, success] = load<T>(name, default_value, OPTIONAL, REUSABLE);
    return ret;
  }
  //}
 
  /* loadParam function for compulsory parameters //{ */
  template <typename T>
  bool loadParam(const std::string& name, T& out_value)
  {
    const auto [ret, success] = load<T>(name, T(), COMPULSORY, UNIQUE);
    out_value = ret;
    return success;
  }
  template <typename T>
  T loadParam2(const std::string& name)
  {
    const auto [ret, success] = load<T>(name, T(), COMPULSORY, UNIQUE);
    return ret;
  }
  template <typename T>
  bool loadParamReusable(const std::string& name, T& out_value)
  {
    const auto [ret, success] = load<T>(name, T(), COMPULSORY, REUSABLE);
    out_value = ret;
    return success;
  }
  template <typename T>
  T loadParamReusable2(const std::string& name)
  {
    const auto [ret, success] = load<T>(name, T(), COMPULSORY, REUSABLE);
    return ret;
  }
  //}
 
  /* loadParam specializations for ros::Duration type //{ */
 
  bool loadParam(const std::string& name, ros::Duration& out, const ros::Duration& default_value)
  {
    double secs;
    const bool ret = loadParam<double>(name, secs, default_value.toSec());
    out = ros::Duration(secs);
    return ret;
  }
 
  bool loadParam(const std::string& name, ros::Duration& out)
  {
    double secs;
    const bool ret = loadParam<double>(name, secs);
    out = ros::Duration(secs);
    return ret;
  }
  
  //}
 
  /* loadParam specializations for std_msgs::ColorRGBA type //{ */
 
  bool loadParam(const std::string& name, std_msgs::ColorRGBA& out, const std_msgs::ColorRGBA& default_value = {})
  {
    std_msgs::ColorRGBA res;
    bool ret = true;
    ret = ret & loadParam(name+"/r", res.r, default_value.r);
    ret = ret & loadParam(name+"/g", res.g, default_value.g);
    ret = ret & loadParam(name+"/b", res.b, default_value.b);
    ret = ret & loadParam(name+"/a", res.a, default_value.a);
    if (ret)
      out = res;
    return ret;
  }
 
  std_msgs::ColorRGBA loadParam2(const std::string& name, const std_msgs::ColorRGBA& default_value = {})
  {
    std_msgs::ColorRGBA ret;
    loadParam(name, ret, default_value);
    return ret;
  }
 
  //}
 
  /* loadParam specializations for XmlRpc::Value type //{ */
 
  bool loadParam(const std::string& name, XmlRpc::XmlRpcValue& out, const XmlRpc::XmlRpcValue& default_value)
  {
    return loadParam<XmlRpc::XmlRpcValue>(name, out, default_value);
  }
 
  bool loadParam(const std::string& name, XmlRpc::XmlRpcValue& out)
  {
    return loadParam<XmlRpc::XmlRpcValue>(name, out);
  }
 
  XmlRpc::XmlRpcValue loadParam2(const std::string& name, const XmlRpc::XmlRpcValue& default_value)
  {
    return loadParam2<XmlRpc::XmlRpcValue>(name, default_value);
  }
 
  //}
 
  /* 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)
  {
    const int rows = default_value.rows();
    const int cols = default_value.cols();
    const bool loaded_ok = loadMatrixDynamic(name, mat, default_value, rows, cols);
    return loaded_ok;
  }
 
  template <typename T>
  MatrixX<T> loadParam2(const std::string& name, const MatrixX<T>& default_value)
  {
    MatrixX<T> ret;
    loadParam(name, ret, default_value);
    return ret;
  }
  
  //}
 
  // 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)
  {
    const auto [ret, loaded_ok] = loadMatrixStatic_internal<rows, cols, T>(name, Eigen::Matrix<T, rows, cols>::Zero(), COMPULSORY, UNIQUE);
    mat = ret;
    return loaded_ok;
  }
 
  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)
  {
    const auto [ret, loaded_ok] = loadMatrixStatic_internal<rows, cols, T>(name, Eigen::Matrix<T, rows, cols>(default_value), OPTIONAL, UNIQUE);
    mat = ret;
    return loaded_ok;
  }
 
  template <int rows, int cols, typename T = double>
  Eigen::Matrix<T, rows, cols> loadMatrixStatic2(const std::string& name)
  {
    Eigen::Matrix<T, rows, cols> ret;
    loadMatrixStatic(name, ret);
    return ret;
  }
 
  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)
  {
    Eigen::Matrix<T, rows, cols> ret;
    loadMatrixStatic(name, ret, default_value);
    return ret;
  }
  //}
 
  // 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)
  {
    const auto [ret, loaded_ok] = loadMatrixKnown_internal(name, MatrixX<T>(), rows, cols, COMPULSORY, UNIQUE);
    mat = ret;
    return loaded_ok;
  }
 
  template <typename T, typename Derived>
  bool loadMatrixKnown(const std::string& name, MatrixX<T>& mat, const Eigen::MatrixBase<Derived>& default_value, int rows, int cols)
  {
    const auto [ret, loaded_ok] = loadMatrixKnown_internal(name, MatrixX<T>(default_value), rows, cols, OPTIONAL, UNIQUE);
    mat = ret;
    return loaded_ok;
  }
 
  template <typename T = double>
  MatrixX<T> loadMatrixKnown2(const std::string& name, int rows, int cols)
  {
    MatrixX<T> ret;
    loadMatrixKnown(name, ret, rows, cols);
    return ret;
  }
 
  template <typename T, typename Derived>
  MatrixX<T> loadMatrixKnown2(const std::string& name, const Eigen::MatrixBase<Derived>& default_value, int rows, int cols)
  {
    MatrixX<T> ret;
    loadMatrixKnown(name, ret, default_value, rows, cols);
    return ret;
  }
  //}
 
  // 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)
  {
    const auto [ret, loaded_ok] = loadMatrixDynamic_internal(name, MatrixX<T>(), rows, cols, COMPULSORY, UNIQUE);
    mat = ret;
    return loaded_ok;
  }
 
  template <typename T, typename Derived>
  bool loadMatrixDynamic(const std::string& name, MatrixX<T>& mat, const Eigen::MatrixBase<Derived>& default_value, int rows, int cols)
  {
    const auto [ret, loaded_ok] = loadMatrixDynamic_internal(name, MatrixX<T>(default_value), rows, cols, OPTIONAL, UNIQUE);
    mat = ret;
    return loaded_ok;
  }
 
  template <typename T = double>
  MatrixX<T> loadMatrixDynamic2(const std::string& name, int rows, int cols)
  {
    MatrixX<T> ret;
    loadMatrixDynamic(name, ret, rows, cols);
    return ret;
  }
 
  template <typename T, typename Derived>
  MatrixX<T> loadMatrixDynamic2(const std::string& name, const Eigen::MatrixBase<Derived>& default_value, int rows, int cols)
  {
    MatrixX<T> ret;
    loadMatrixDynamic(name, ret, default_value, rows, cols);
    return ret;
  }
 
  //}
 
  // 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)
  {
    mat = loadMatrixArray2<double>(name);
  }
 
  template <typename T>
  void loadMatrixArray(const std::string& name, std::vector<MatrixX<T>>& mat, const std::vector<MatrixX<T>>& default_value)
  {
    mat = loadMatrixArray2(name, default_value);
  }
 
  template <typename T = double>
  std::vector<MatrixX<T>> loadMatrixArray2(const std::string& name)
  {
    return loadMatrixArray_internal(name, std::vector<MatrixX<T>>(), COMPULSORY, UNIQUE);
  }
 
  template <typename T>
  std::vector<MatrixX<T>> loadMatrixArray2(const std::string& name, const std::vector<MatrixX<T>>& default_value)
  {
    return loadMatrixArray_internal(name, default_value, OPTIONAL, UNIQUE);
  }
  //}
 
  //}
 
};
//}
 
  template <>
  ros::Duration ParamLoader::loadParam2<ros::Duration>(const std::string& name, const ros::Duration& default_value);
 
  template <>
  ros::Duration ParamLoader::loadParam2<ros::Duration>(const std::string& name);
 
}  // namespace mrs_lib
 
#endif  // PARAM_LOADER_H