node_registration_options.hpp

// Copyright 2024 Robin Müller
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#pragma once
 
#include <chrono>
#include <map>
#include <string>
 
#include "auto_apms_util/exceptions.hpp"
#include "auto_apms_util/yaml.hpp"
 
namespace auto_apms_behavior_tree::core
{

struct NodeRegistrationOptions
{
  static const std::string PARAM_NAME_CLASS;
  static const std::string PARAM_NAME_ROS2TOPIC;
  static const std::string PARAM_NAME_DESCRIPTION;
  static const std::string PARAM_NAME_PORT_ALIAS;
  static const std::string PARAM_NAME_PORT_DEFAULT;
  static const std::string PARAM_NAME_WAIT_TIMEOUT;
  static const std::string PARAM_NAME_REQUEST_TIMEOUT;
  static const std::string PARAM_NAME_ALLOW_UNREACHABLE;
  static const std::string PARAM_NAME_LOGGER_LEVEL;
  static const std::string PARAM_NAME_HIDDEN_PORTS;
  static const std::string PARAM_NAME_EXTRA;

  NodeRegistrationOptions() = default;
 
  AUTO_APMS_UTIL_DEFINE_YAML_CONVERSION_METHODS(NodeRegistrationOptions)
 
  
  std::string class_name;
  std::string description = "No description provided.";
  std::string topic = "(input:topic)";
  std::map<std::string, std::string> port_alias = {};
  std::map<std::string, std::string> port_default = {};
  std::vector<std::string> hidden_ports = {};
  std::chrono::duration<double> wait_timeout = std::chrono::duration<double>(3);
  std::chrono::duration<double> request_timeout = std::chrono::duration<double>(2);
  bool allow_unreachable = false;
  std::string logger_level = "";
  YAML::Node extra;

  bool valid() const;
};
 
}  // namespace auto_apms_behavior_tree::core
 
// #####################################################################################################################
// ################################              DEFINITIONS              ##############################################
// #####################################################################################################################

namespace YAML
{
template <>
struct convert<auto_apms_behavior_tree::core::NodeRegistrationOptions>
{
  using Options = auto_apms_behavior_tree::core::NodeRegistrationOptions;
  inline static Node encode(const Options & rhs)
  {
    Node node(NodeType::Map);
    node[Options::PARAM_NAME_CLASS] = rhs.class_name;
    node[Options::PARAM_NAME_DESCRIPTION] = rhs.description;
    node[Options::PARAM_NAME_ROS2TOPIC] = rhs.topic;
    node[Options::PARAM_NAME_PORT_ALIAS] = rhs.port_alias;
    node[Options::PARAM_NAME_PORT_DEFAULT] = rhs.port_default;
    node[Options::PARAM_NAME_HIDDEN_PORTS] = rhs.hidden_ports;
    node[Options::PARAM_NAME_WAIT_TIMEOUT] = rhs.wait_timeout.count();
    node[Options::PARAM_NAME_REQUEST_TIMEOUT] = rhs.request_timeout.count();
    node[Options::PARAM_NAME_ALLOW_UNREACHABLE] = rhs.allow_unreachable;
    node[Options::PARAM_NAME_LOGGER_LEVEL] = rhs.logger_level;
    node[Options::PARAM_NAME_EXTRA] = rhs.extra;
    return node;
  }
  inline static bool decode(const Node & node, Options & rhs)
  {
    if (!node.IsMap())
      throw auto_apms_util::exceptions::YAMLFormatError(
        "YAML::Node for auto_apms_behavior_tree::core::NodeRegistrationOptions must be map but is type " +
        std::to_string(node.Type()) + " (0: Undefined - 1: Null - 2: Scalar - 3: Sequence - 4: Map).");
 
    for (YAML::const_iterator it = node.begin(); it != node.end(); ++it) {
      const std::string key = it->first.as<std::string>();
      const Node val = it->second;
 
      if (key == Options::PARAM_NAME_EXTRA) {
        // Any valid yaml is allowed as extra options
        rhs.extra = val;
        continue;
      }
 
      if (key == Options::PARAM_NAME_PORT_ALIAS) {
        if (!val.IsMap()) {
          throw auto_apms_util::exceptions::YAMLFormatError(
            "Value for key '" + key + "' must be a map but is type " + std::to_string(val.Type()) +
            " (0: Undefined - 1: Null - 2: Scalar - 3: Sequence - 4: Map).");
        }
        rhs.port_alias = val.as<std::map<std::string, std::string>>();
        continue;
      }
 
      if (key == Options::PARAM_NAME_PORT_DEFAULT) {
        if (!val.IsMap()) {
          throw auto_apms_util::exceptions::YAMLFormatError(
            "Value for key '" + key + "' must be a map but is type " + std::to_string(val.Type()) +
            " (0: Undefined - 1: Null - 2: Scalar - 3: Sequence - 4: Map).");
        }
        rhs.port_default = val.as<std::map<std::string, std::string>>();
        continue;
      }
 
      if (key == Options::PARAM_NAME_HIDDEN_PORTS) {
        if (!val.IsSequence()) {
          throw auto_apms_util::exceptions::YAMLFormatError(
            "Value for key '" + key + "' must be a sequence but is type " + std::to_string(val.Type()) +
            " (0: Undefined - 1: Null - 2: Scalar - 3: Sequence - 4: Map).");
        }
        rhs.hidden_ports = val.as<std::vector<std::string>>();
        continue;
      }
 
      if (key == Options::PARAM_NAME_CLASS) {
        if (!val.IsScalar()) {
          throw auto_apms_util::exceptions::YAMLFormatError(
            "Value for key '" + key + "' must be scalar but is type " + std::to_string(val.Type()) +
            " (0: Undefined - 1: Null - 2: Scalar - 3: Sequence - 4: Map).");
        }
        rhs.class_name = val.as<std::string>();
        continue;
      }
      if (key == Options::PARAM_NAME_DESCRIPTION) {
        if (!val.IsScalar()) {
          throw auto_apms_util::exceptions::YAMLFormatError(
            "Value for key '" + key + "' must be scalar but is type " + std::to_string(val.Type()) +
            " (0: Undefined - 1: Null - 2: Scalar - 3: Sequence - 4: Map).");
        }
        rhs.description = val.as<std::string>();
        continue;
      }
      if (key == Options::PARAM_NAME_ROS2TOPIC) {
        if (!val.IsScalar()) {
          throw auto_apms_util::exceptions::YAMLFormatError(
            "Value for key '" + key + "' must be scalar but is type " + std::to_string(val.Type()) +
            " (0: Undefined - 1: Null - 2: Scalar - 3: Sequence - 4: Map).");
        }
        rhs.topic = val.as<std::string>();
        continue;
      }
      if (key == Options::PARAM_NAME_WAIT_TIMEOUT) {
        if (!val.IsScalar()) {
          throw auto_apms_util::exceptions::YAMLFormatError(
            "Value for key '" + key + "' must be scalar but is type " + std::to_string(val.Type()) +
            " (0: Undefined - 1: Null - 2: Scalar - 3: Sequence - 4: Map).");
        }
        rhs.wait_timeout = std::chrono::duration<double>(val.as<double>());
        continue;
      }
      if (key == Options::PARAM_NAME_REQUEST_TIMEOUT) {
        if (!val.IsScalar()) {
          throw auto_apms_util::exceptions::YAMLFormatError(
            "Value for key '" + key + "' must be scalar but is type " + std::to_string(val.Type()) +
            " (0: Undefined - 1: Null - 2: Scalar - 3: Sequence - 4: Map).");
        }
        rhs.request_timeout = std::chrono::duration<double>(val.as<double>());
        continue;
      }
      if (key == Options::PARAM_NAME_ALLOW_UNREACHABLE) {
        if (!val.IsScalar()) {
          throw auto_apms_util::exceptions::YAMLFormatError(
            "Value for key '" + key + "' must be scalar but is type " + std::to_string(val.Type()) +
            " (0: Undefined - 1: Null - 2: Scalar - 3: Sequence - 4: Map).");
        }
        rhs.allow_unreachable = val.as<bool>();
        continue;
      }
      if (key == Options::PARAM_NAME_LOGGER_LEVEL) {
        if (!val.IsScalar()) {
          throw auto_apms_util::exceptions::YAMLFormatError(
            "Value for key '" + key + "' must be scalar but is type " + std::to_string(val.Type()) +
            " (0: Undefined - 1: Null - 2: Scalar - 3: Sequence - 4: Map).");
        }
        rhs.logger_level = val.as<std::string>();
        continue;
      }
 
      // Unkown parameter
      throw auto_apms_util::exceptions::YAMLFormatError("Unkown parameter name '" + key + "'.");
    }
    return true;
  }
};
 
}  // namespace YAML