node_manifest.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
//
//    http://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 <map>
#include <vector>
 
#include "auto_apms_behavior_tree_core/definitions.hpp"
#include "auto_apms_behavior_tree_core/node/node_registration_options.hpp"
#include "auto_apms_util/exceptions.hpp"
#include "auto_apms_util/yaml.hpp"
 
namespace auto_apms_behavior_tree::core
{

struct NodeManifestResourceIdentity
{
  NodeManifestResourceIdentity(const std::string & identity);

  NodeManifestResourceIdentity(const char * identity);

  NodeManifestResourceIdentity() = default;
 
  virtual ~NodeManifestResourceIdentity() = default;
 
  bool operator==(const NodeManifestResourceIdentity & other) const;
 
  bool operator<(const NodeManifestResourceIdentity & other) const;

  std::string str() const;

  bool empty() const;

  std::string package_name;
  std::string metadata_id;
};

std::set<NodeManifestResourceIdentity> getNodeManifestResourceIdentities(
  const std::set<std::string> & exclude_packages = {});

class NodeManifest
{
public:
  using RegistrationOptions = NodeRegistrationOptions;

  using Map = std::map<std::string, NodeRegistrationOptions>;

  NodeManifest(const Map & map = {});
 
  AUTO_APMS_UTIL_DEFINE_YAML_CONVERSION_METHODS(NodeManifest)
 
  
  static NodeManifest fromFiles(const std::vector<std::string> & paths);

  static NodeManifest fromResource(const NodeManifestResourceIdentity & search_identity);

  void toFile(const std::string & file_path) const;

  bool contains(const std::string & node_name) const;

  RegistrationOptions & operator[](const std::string & node_name);

  const RegistrationOptions & operator[](const std::string & node_name) const;

  NodeManifest & add(const std::string & node_name, const RegistrationOptions & opt);

  NodeManifest & remove(const std::string & node_name);

  NodeManifest & merge(const NodeManifest & other, bool replace = false);

  NodeManifest & mergeWithNamespace(
    const NodeManifest & other, const std::string & with_namespace,
    const std::string & sep = _AUTO_APMS_BEHAVIOR_TREE_CORE__NODE_NAMESPACE_DEFAULT_SEP);

  NodeManifest & applyNodeNamespace(
    const std::string & ns, const std::string & sep = _AUTO_APMS_BEHAVIOR_TREE_CORE__NODE_NAMESPACE_DEFAULT_SEP);

  std::vector<std::string> getNodeNames();

  size_t size() const;

  bool empty() const;

  const Map & map() const;
 
private:
  Map map_;
};

class NodeManifestResource
{
public:
  using Identity = NodeManifestResourceIdentity;

  NodeManifestResource(const Identity & search_identity);

  NodeManifestResource(const std::string & search_identity);

  NodeManifestResource(const char * search_identity);

  const Identity & getIdentity() const;

  const NodeManifest & getNodeManifest() const;

  const NodeModelMap & getNodeModel() const;
 
private:
  Identity unique_identity_;
  std::string node_manifest_file_path_;
  NodeManifest node_manifest_;
  std::string node_model_file_path_;
  NodeModelMap node_model_;
};
 
}  // namespace auto_apms_behavior_tree::core
 
// #####################################################################################################################
// ################################              DEFINITIONS              ##############################################
// #####################################################################################################################

namespace YAML
{
template <>
struct convert<auto_apms_behavior_tree::core::NodeManifestResourceIdentity>
{
  using Identity = auto_apms_behavior_tree::core::NodeManifestResourceIdentity;
  static Node encode(const Identity & rhs)
  {
    Node node;
    node = rhs.str();
    return node;
  }
  static bool decode(const Node & node, Identity & rhs)
  {
    if (!node.IsScalar()) return false;
    rhs = Identity(node.Scalar());
    return true;
  }
};
template <>
struct convert<auto_apms_behavior_tree::core::NodeManifest>
{
  using Manifest = auto_apms_behavior_tree::core::NodeManifest;
  inline static Node encode(const Manifest & rhs)
  {
    Node node(NodeType::Map);
    for (const auto & [name, params] : rhs.map()) node[name] = params;
    return node;
  }
  inline static bool decode(const Node & node, Manifest & rhs)
  {
    if (!node.IsMap())
      throw auto_apms_util::exceptions::YAMLFormatError(
        "YAML::Node for auto_apms_behavior_tree::core::NodeManifest 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 auto & name = it->first.as<std::string>();
      try {
        rhs.add(name, it->second.as<Manifest::RegistrationOptions>());
      } catch (const std::exception & e) {
        throw auto_apms_util::exceptions::YAMLFormatError(
          "Node registration options for node '" + name + "' are invalid: " + e.what());
      }
    }
    return true;
  }
};
}  // namespace YAML