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;
}

namespace YAML
{
template <>
struct convert<auto_apms_behavior_tree::core::NodeRegistrationOptions>
{
  using Options = auto_apms_behavior_tree::core::NodeRegistrationOptions;
  static Node encode(const Options & rhs);
  static bool decode(const Node & node, Options & lhs);
};
}  // namespace YAML
 
namespace auto_apms_behavior_tree::core
{

struct NodeRegistrationOptions
{
  static const std::string PARAM_NAME_CLASS;
  static const std::string PARAM_NAME_PORT;
  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;

  NodeRegistrationOptions() = default;
 
  AUTO_APMS_UTIL_DEFINE_YAML_CONVERSION_METHODS(NodeRegistrationOptions)
 
  
  std::string class_name;
  std::string port = "(input:port)";
  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 = "INFO";

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

namespace YAML
{
inline Node convert<auto_apms_behavior_tree::core::NodeRegistrationOptions>::encode(const Options & rhs)
{
  Node node(NodeType::Map);
  node[Options::PARAM_NAME_CLASS] = rhs.class_name;
  node[Options::PARAM_NAME_PORT] = rhs.port;
  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;
  return node;
}
inline bool convert<auto_apms_behavior_tree::core::NodeRegistrationOptions>::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 (auto it = node.begin(); it != node.end(); ++it) {
    const std::string key = it->first.as<std::string>();
    const Node & val = it->second;
    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).");
 
    if (key == Options::PARAM_NAME_CLASS) {
      rhs.class_name = val.as<std::string>();
      continue;
    }
    if (key == Options::PARAM_NAME_PORT) {
      rhs.port = val.as<std::string>();
      continue;
    }
    if (key == Options::PARAM_NAME_WAIT_TIMEOUT) {
      rhs.wait_timeout = std::chrono::duration<double>(val.as<double>());
      continue;
    }
    if (key == Options::PARAM_NAME_REQUEST_TIMEOUT) {
      rhs.request_timeout = std::chrono::duration<double>(val.as<double>());
      continue;
    }
    if (key == Options::PARAM_NAME_ALLOW_UNREACHABLE) {
      rhs.allow_unreachable = val.as<bool>();
      continue;
    }
    if (key == Options::PARAM_NAME_LOGGER_LEVEL) {
      rhs.logger_level = val.as<std::string>();
      continue;
    }
    // Unkown parameter
    throw auto_apms_util::exceptions::YAMLFormatError("Unkown parameter name '" + key + "'.");
  }
  return true;
}
}  // namespace YAML