settings.hpp

Go to the documentation of this file.

#ifndef _SETTINGS_H_
#define _SETTINGS_H_
 
#include "logger.hpp"
#include <memory>
 
#include <iostream>
#include <string>
 
#include <nlohmann/json.hpp>
 
#include "rclcpp/rclcpp.hpp"
 
#include "rcl_interfaces/msg/set_parameters_result.hpp"
#include "rcl_interfaces/msg/floating_point_range.hpp"
#include "rcl_interfaces/msg/parameter_descriptor.hpp"
 
using namespace std;
using nlohmann::json;
 
namespace galaxis {
  namespace utils {
 
    shared_ptr<json> read_json_file(std::string path);
    shared_ptr<json> read_system_settings(std::string key);
    shared_ptr<std::string> read_file_to_string(std::string path);
 
    template<typename T, typename = typename std::enable_if<std::is_arithmetic<T>::value, T>::type>
    bool check_parameter(
      rclcpp::Parameter const& param,
      rcl_interfaces::msg::SetParametersResult& result,
      T min = numeric_limits<T>::min(),
      T max = numeric_limits<T>::max()
      ) {
      
      T paramValue;
      if( std::is_same<T, int>::value ) {
        if( param.get_type() == rclcpp::ParameterType::PARAMETER_INTEGER ) {
          paramValue = param.as_int();
        }
        else {
          result.successful = false;
          result.reason += "[" + param.get_name() + "] Type wrong. Must be INTEGER; ";
          return false;
        }
      }
      else if ( std::is_same<T, double>::value || std::is_same<T, float>::value ) {
        if( param.get_type() == rclcpp::ParameterType::PARAMETER_DOUBLE ) {
          paramValue = param.as_double();
        }
        else {
          result.successful = false;
          result.reason += "[" + param.get_name() + "] Type wrong. Must be DOUBLE; ";
          return false;
        }
      }
      else {
        result.successful = false;
        result.reason += "[" + param.get_name() + "] Type wrong.; ";
        return false;
      }
 
      if( paramValue < min ) {
        result.successful = false;
        result.reason += "[" + param.get_name() + "] Value too low. Must be larger or equal to " + std::to_string(min) + " ; ";
        return false;
      }
      if( paramValue > max ) {
        result.successful = false;
        result.reason += "[" + param.get_name() + "] Value too high. Must be lower or equal to " + std::to_string(max) + " ; ";
        return false;
      }
 
      return true;
    }
 
    // enum ParameterType {
    //   BOOLEAN,
    //   INTEGER,
    //   DOUBLE,
    //   STRING,
    //   NOTEXIT
    // };
 
    // class Settings {
    //   private:
    //   std::map<std::string, bool> booleanParamMap;
    //   std::map<std::string, int> integerParamMap;
    //   std::map<std::string, double> doubleParamMap;
    //   std::map<std::string, std::string> stringParamMap;
 
    //   bool loadLock = false;
 
    //   public:
    //   Settings();
    //   ~Settings();
    //   void load(std::shared_ptr<json> settingsJson);
 
    //   ParameterType getType();
    //   bool getParamBool(std::string key);
    //   double getParamDouble(std::string key);
    //   std::string getParamString(std::string key);
    // };
 
  } // namespace utils
} // namespace galaxis
 
#endif // _SETTINGS_H_