defroster.h

Go to the documentation of this file.

// NIST-developed software is provided by NIST as a public service. You may use, copy and distribute copies of the
// software in any medium, provided that you keep intact this entire notice. You may improve, modify and create
// derivative works of the software or any portion of the software, and you may copy and distribute such modifications
// or works. Modified works should carry a notice stating that you changed the software and should note the date and
// nature of any such change. Please explicitly acknowledge the National Institute of Standards and Technology as the
// source of the software. NIST-developed software is expressly provided "AS IS." NIST MAKES NO WARRANTY OF ANY KIND,
// EXPRESS, IMPLIED, IN FACT OR ARISING BY OPERATION OF LAW, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTY OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT AND DATA ACCURACY. NIST NEITHER REPRESENTS NOR
// WARRANTS THAT THE OPERATION OF THE SOFTWARE WILL BE UNINTERRUPTED OR ERROR-FREE, OR THAT ANY DEFECTS WILL BE
// CORRECTED. NIST DOES NOT WARRANT OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF THE SOFTWARE OR THE RESULTS
// THEREOF, INCLUDING BUT NOT LIMITED TO THE CORRECTNESS, ACCURACY, RELIABILITY, OR USEFULNESS OF THE SOFTWARE. You
// are solely responsible for determining the appropriateness of using and distributing the software and you assume
// all risks associated with its use, including but not limited to the risks and costs of program errors, compliance
// with applicable laws, damage to or loss of data, programs or equipment, and the unavailability or interruption of
// operation. This software is not intended to be used in any situation where a failure could cause risk of injury or
// damage to property. The software developed by NIST employees is not subject to copyright protection within the
// United States.
 
#ifndef HEDGEHOG_CX_DEFROSTER_H_
#define HEDGEHOG_CX_DEFROSTER_H_
 
#ifdef HH_ENABLE_HH_CX
 
#include <array>
#include <ostream>
#include "../tools/type_nodes_map_array.h"
#include "../tools/concepts.h"
#include "graph.h"
 
namespace hh_cx {
 
template<class DynGraphType, class name_t, class report_t, class adjacencyMatrix_t, class registeredNodesName_t, class inputMap_t, class outputMap_t>
class Defroster {
 private:
  name_t const name_; 
  bool const isValid_; 
  report_t const report_; 
  adjacencyMatrix_t const adjacencyMatrix_; 
  registeredNodesName_t const registeredNodesName_; 
  inputMap_t const inputMap_; 
  outputMap_t const outputMap_; 
 public:
  constexpr Defroster(
      name_t const name,
      bool const isValid,
      report_t const &report,
      adjacencyMatrix_t const &adjacencyMatrix,
      registeredNodesName_t const &registeredNodesName,
      inputMap_t const &inputMap,
      outputMap_t const &outputMap)
      : name_(name),
        isValid_(isValid),
        report_(report),
        adjacencyMatrix_(adjacencyMatrix),
        registeredNodesName_(registeredNodesName),
        inputMap_(inputMap),
        outputMap_(outputMap) {}
 
  constexpr virtual ~Defroster() = default;
 
  [[nodiscard]] std::string graphName() const { return std::string(name_.data()); }
 
  [[nodiscard]] constexpr bool isValid() const { return isValid_; }
 
  [[nodiscard]] std::string report() const { return std::string(report_.data()); }
 
  template<class ...Args>
  auto map(Args... args) const {
    if constexpr (sizeof...(args) > 0 && sizeof...(args) % 2 != 0) {
      throw std::runtime_error(
          "The map function only accepts an even number of parameters as follows: name1, dynNode1, name2, dynNode2...");
    }
    std::set<std::string> validatedNames{};
    auto [names, dynNodes] = validateAndSplit(validatedNames, args...);
    return generateGraph(names, dynNodes);
  }
 
 private:
  template<class NodeName, tool::HedgehogConnectableNode Node, class ...Args>
  requires std::is_convertible_v<NodeName, std::string>
  auto validateAndSplit(
      std::set<std::string> &setName,
      NodeName const &nodeName, std::shared_ptr<Node> node, Args... args) const {
    bool nameFound = false;
    std::string name = nodeName;
    for (size_t nameId = 0; nameId < registeredNodesName_.size() && !nameFound; ++nameId) {
      if (std::string(registeredNodesName_.at(nameId).data()) == name) { nameFound = true; }
    }
    if (!nameFound) {
      std::ostringstream oss;
      oss << "The node name identifier \"" << name
          << "\" has not been found in the list of names identifier of static nodes.";
      throw std::runtime_error(oss.str());
    } else {
      if (setName.insert(name).second == false) {
        std::ostringstream oss;
        oss << "The node name identifier \"" << name << "\" has already been used to map a dynamic node.";
        throw std::runtime_error(oss.str());
      }
      if constexpr (sizeof...(args) > 0) {
        auto [names, dynNodes] = validateAndSplit(setName, args...);
        std::vector<std::string> newNames{nodeName};
        newNames.insert(newNames.end(), names.cbegin(), names.cend());
        return std::make_pair(
            newNames,
            std::tuple_cat(std::tuple<std::shared_ptr<Node>>{node}, dynNodes)
        );
      } else {
        if (registeredNodesName_.size() != setName.size()) {
          std::ostringstream oss;
          oss << "There are static nodes that are not mapped.";
          throw std::runtime_error(oss.str());
        }
        return std::make_pair(
            std::vector<std::string>{nodeName},
            std::tuple<std::shared_ptr<Node>>{node}
        );
      }
    }
  }
 
  template<class T, class U, class ...Args>
  auto validateAndSplit(std::set<std::string> &, T const &, U const &, Args...) const {
    std::ostringstream oss;
    oss << "The map function has not the rights type, the sequence of types " << hh::tool::typeToStr<T>() << " "
        << hh::tool::typeToStr<U>()
        << " has been found";
    throw std::runtime_error(oss.str());
  }
 
  template<class DynamicNodes>
  auto generateGraph(std::vector<std::string> const &dynamicNameIds,
                     DynamicNodes const &dynamicNodes) const {
    auto graph = std::make_shared<DynGraphType>(this->graphName());
    std::vector<typename hh_cx::tool::UniqueVariantFromTuple_t<DynamicNodes>> dynamicNodesVariant;
    populateVariants(dynamicNodes, dynamicNodesVariant);
 
    // Deal with input nodes
    setInputNodes<DynamicNodes>(graph, dynamicNameIds, dynamicNodesVariant);
 
    // Deal with output nodes
    setOutputNodes<DynamicNodes>(graph, dynamicNameIds, dynamicNodesVariant);
 
    // Deal with edges
    setEdges<DynamicNodes>(graph, dynamicNameIds, dynamicNodesVariant);
 
    return graph;
  }
 
  template<class DynamicNodes>
  void setInputNodes(
      std::shared_ptr<DynGraphType> graph,
      std::vector<std::string> const &dynamicNameIds,
      std::vector<typename hh_cx::tool::UniqueVariantFromTuple_t<DynamicNodes>> dynamicNodesVariant) const {
    using GraphInputsTuple = typename DynGraphType::inputs_t;
 
    // For all ids for a type
    for (auto const &inputNodeNameToTypes : inputMap_.mapNodeNameToTypeNames()) {
      // Get the variant
      auto staticNameId = inputNodeNameToTypes.first;
      auto positionDynNode =
          std::distance(
              dynamicNameIds.begin(),
              std::find(dynamicNameIds.begin(), dynamicNameIds.end(), staticNameId)
          );
      auto dynamicNode = dynamicNodesVariant.at(positionDynNode);
      // Visit the variant
      std::visit([&](auto const &node) {
        // Get the common types between the node and the graph
        using IntersectionInputTypes =
            hh::tool::Intersect_t<GraphInputsTuple, typename std::remove_reference_t<decltype(*node)>::inputs_t>;
        // For all of these types
        for (auto const &typeName : inputNodeNameToTypes.second) {
          // If the connection type from the map is in the common types
          if (isTypeNameInTuple<IntersectionInputTypes>(
              typeName, std::make_index_sequence<std::tuple_size_v<IntersectionInputTypes>>{})
              ) {
            // Set the node as input
            setNodeAsGraphInput<IntersectionInputTypes>(
                typeName, node, graph, std::make_index_sequence<std::tuple_size_v<IntersectionInputTypes>>{}
            );
          } else {
            // else throw an error
            std::ostringstream oss;
            oss << "Problem during mapping: the node " << node->name() << " cannot be set as input of the graph " <<
                graphName() << " for the type " << typeName;
            throw std::runtime_error(oss.str());
          }
        }
      }, dynamicNode);
    }
  }
 
  template<class DynamicNodes>
  void setOutputNodes(
      std::shared_ptr<DynGraphType> graph,
      std::vector<std::string> const &dynamicNameIds,
      std::vector<typename hh_cx::tool::UniqueVariantFromTuple_t<DynamicNodes>> dynamicNodesVariant) const {
    using GraphOutputsTuple = typename DynGraphType::outputs_t;
    // For all ids for a type
    for (auto const &outputNodeNameToTypes : outputMap_.mapNodeNameToTypeNames()) {
      // Get the variant
      auto staticNameId = outputNodeNameToTypes.first;
      auto positionDynNode =
          std::distance(
              dynamicNameIds.begin(),
              std::find(dynamicNameIds.begin(), dynamicNameIds.end(), staticNameId)
          );
      auto dynamicNode = dynamicNodesVariant.at(positionDynNode);
      // Visit the variant
      std::visit([&](auto const &node) {
        // Get the common types between the node and the graph
        using IntersectionOutputTypes =
            hh::tool::Intersect_t<GraphOutputsTuple, typename std::remove_reference_t<decltype(*node)>::outputs_t>;
        // For all of these types
        for (auto const &typeName : outputNodeNameToTypes.second) {
          // If the connection type from the map is in the common types
          if (isTypeNameInTuple<IntersectionOutputTypes>(
              typeName, std::make_index_sequence<std::tuple_size_v<IntersectionOutputTypes>>{})
              ) {
            // Set the node as input
            setNodeAsGraphOutput<IntersectionOutputTypes>(
                typeName, node, graph, std::make_index_sequence<std::tuple_size_v<IntersectionOutputTypes>>{}
            );
          } else {
            // else throw an error
            std::ostringstream oss;
            oss << "Problem during mapping: the node " << node->name() << " cannot be set as input of the graph " <<
                graphName() << " for the type " << typeName;
            throw std::runtime_error(oss.str());
          }
        }
      }, dynamicNode);
    }
  }
 
  template<class DynamicNodes>
  void setEdges(
      std::shared_ptr<DynGraphType> graph,
      std::vector<std::string> const &dynamicNameIds,
      std::vector<typename hh_cx::tool::UniqueVariantFromTuple_t<DynamicNodes>> dynamicNodesVariant) const {
 
    // For all nodes as sender
    for (size_t senderId = 0; senderId < adjacencyMatrix_.size(); ++senderId) {
      // Get the name-id
      auto staticSenderNodeNameId = std::string(registeredNodesName_.at(senderId).data());
      // Get the dynamic variant
      auto positionSenderDynNode =
          std::distance(
              dynamicNameIds.begin(),
              std::find(dynamicNameIds.begin(), dynamicNameIds.end(), staticSenderNodeNameId)
          );
      auto dynamicSenderNodeVariant = dynamicNodesVariant.at(positionSenderDynNode);\
      // Visit the variant
      std::visit([&](auto const &dynamicSenderNode) {
        // For all the nodes as receiver
        for (size_t receiverId = 0; receiverId < adjacencyMatrix_.at(senderId).size(); ++receiverId) {
          // Get the name-id
          auto staticReceiverNodeNameId = std::string(registeredNodesName_.at(receiverId).data());
          // Get the variant
          auto positionReceiverDynNode =
              std::distance(
                  dynamicNameIds.begin(),
                  std::find(dynamicNameIds.begin(), dynamicNameIds.end(), staticReceiverNodeNameId)
              );
          auto dynamicReceiverNodeVariant = dynamicNodesVariant.at(positionReceiverDynNode);
          // Visit the vriant
          std::visit([&](auto const &dynamicReceiverNode) {
            // Get the common types between the 2 nodes
            using commonTypesDynamicNodes =
                hh::tool::Intersect_t<
                    typename std::remove_reference_t<decltype(*dynamicSenderNode)>::outputs_t,
                    typename std::remove_reference_t<decltype(*dynamicReceiverNode)>::inputs_t>;
 
            // For all the types in the adjacency matrix
            for (size_t typeId = 0; typeId < adjacencyMatrix_.at(senderId).at(receiverId).size(); ++typeId) {
              auto typeName = std::string(adjacencyMatrix_.at(senderId).at(receiverId).at(typeId).data());
              if (!typeName.empty()) {
                // If the connexion type is in the common types
                if (isTypeNameInTuple<commonTypesDynamicNodes>(
                    typeName, std::make_index_sequence<std::tuple_size_v<commonTypesDynamicNodes>>{})
                    ) {
                  // Set the edge
                  setEdge<commonTypesDynamicNodes>(
                      typeName,
                      dynamicSenderNode,
                      dynamicReceiverNode,
                      graph,
                      std::make_index_sequence<std::tuple_size_v<commonTypesDynamicNodes>>{}
                  );
                } else {
                  // else, throw an error
                  std::ostringstream oss;
                  oss
                      << "Problem during mapping: the node " << dynamicSenderNode->name()
                      << " cannot be set linked to " << dynamicReceiverNode->name()
                      << " for the type " << typeName;
                  throw std::runtime_error(oss.str());
                }
              }
            }
          }, dynamicReceiverNodeVariant);
        }
      }, dynamicSenderNodeVariant);
    }
  }
 
  template<size_t Position = 0, class Tuple, class VectorVariant>
  void populateVariants(Tuple const &tup, VectorVariant &vectorVariant) const {
    if constexpr (Position < std::tuple_size_v<Tuple>) {
      vectorVariant.emplace_back(std::get<Position>(tup));
      populateVariants<Position + 1, Tuple, VectorVariant>(tup, vectorVariant);
    }
  }
 
  template<class TupleOfTypes, class NodeType, class GraphType, size_t... Indices>
  void setNodeAsGraphInput(std::string const &typeName,
                           NodeType &node,
                           GraphType &graph,
                           std::index_sequence<Indices...>) const {
    (setNodeAsGraphInputType<std::tuple_element_t<Indices, TupleOfTypes>>(typeName, node, graph), ...);
  }
 
  template<class T, class NodeType, class GraphType>
  void setNodeAsGraphInputType(std::string const &typeName, NodeType &node, GraphType &graph) const {
    if (hh::tool::typeToStr<T>() == typeName) { graph->template input<T>(node); }
  }
 
  template<class TupleOfTypes, class NodeType, class GraphType, size_t... Indices>
  void setNodeAsGraphOutput(std::string const &typeName,
                            NodeType &node,
                            GraphType &graph,
                            std::index_sequence<Indices...>) const {
    (setNodeAsGraphOutputType<std::tuple_element_t<Indices, TupleOfTypes>>(typeName, node, graph), ...);
  }
 
  template<class T, class NodeType, class GraphType>
  void setNodeAsGraphOutputType(std::string const &typeName, NodeType &node, GraphType &graph) const {
    if (hh::tool::typeToStr<T>() == typeName) { graph->template output<T>(node); }
  }
 
  template<class TupleOfTypes, class SenderNodeType, class ReceiverNodeType, class GraphType, size_t... Indices>
  void setEdge(std::string const &typeName,
               SenderNodeType &sender,
               ReceiverNodeType &receiver,
               GraphType &graph,
               std::index_sequence<Indices...>) const {
    (setEdgeType<std::tuple_element_t<Indices, TupleOfTypes>>(typeName, sender, receiver, graph), ...);
  }
 
  template<class T, class SenderNodeType, class ReceiverNodeType, class GraphType>
  void setEdgeType(std::string const &typeName,
                   SenderNodeType &sender,
                   ReceiverNodeType &receiver,
                   GraphType &graph) const {
    if (hh::tool::typeToStr<T>() == typeName) { graph->template edge<T>(sender, receiver); }
  }
 
  template<class TupleOfTypes, size_t... Indices>
  [[nodiscard]] bool isTypeNameInTuple(std::string const &typeName, std::index_sequence<Indices...>) const {
    return (isSameTypeName<std::tuple_element_t<Indices, TupleOfTypes>>(typeName) || ...);
  }
 
  template<class T>
  [[nodiscard]] inline bool isSameTypeName(std::string const &typeName) const {
    return hh::tool::typeToStr<T>() == typeName;
  }
};
 
template<auto FctGraph>
constexpr auto createDefroster() {
  // Static graph
  auto graph = FctGraph();
  static_assert(
      std::is_base_of_v<hh_cx::Graph<typename decltype(graph)::dynamic_node_t>, decltype(graph)>,
      "The callable given to the createDefroster function should 1) be a constexpr function and 2) return a valid hh_cx::Graph");
  using DynGraphType = typename decltype(graph)::dynamic_node_t;
 
 
  // Static sizes
  constexpr size_t
      graphNameSize = FctGraph().name().size() + 1,
      reportSize = FctGraph().report().size() + 1,
      numberNodes = FctGraph().numberNodesRegistered(),
      maxNodeNameSize = FctGraph().maxNodeNameSize() + 1,
      maxNumberEdges = FctGraph().maxEdgeSizes().first,
      maxEdgeTypeSize = FctGraph().maxEdgeSizes().second,
      nbTypesInput = FctGraph().inputNodes().nbTypes(),
      maxTypeSizeInput = FctGraph().inputNodes().maxTypeSize() + 1,
      maxNumberNodesInput = FctGraph().inputNodes().maxNumberNodes(),
      maxSizeNameInput = FctGraph().inputNodes().maxSizeName() + 1,
      nbTypesOutput = FctGraph().outputNodes().nbTypes(),
      maxTypeSizeOutput = FctGraph().outputNodes().maxTypeSize() + 1,
      maxNumberNodesOutput = FctGraph().outputNodes().maxNumberNodes(),
      maxSizeNameOutput = FctGraph().outputNodes().maxSizeName() + 1;
 
  // Get Graph name
  auto const &graphName = graph.name();
  std::array<char, graphNameSize> nameArray;
  std::copy(graphName.cbegin(), graphName.cend(), nameArray.begin());
  nameArray.at(graphName.size()) = '\0';
 
  // Get graph validity
  bool isGraphValid = graph.isValid();
 
  // Copy reports
  auto const &reportString = graph.report();
  std::array<char, reportSize> reportArray{};
  std::copy(reportString.begin(), reportString.end(), reportArray.begin());
  reportArray.at(reportString.size()) = '\0';
 
  // Copy adjacency matrix
  auto const &adjacencyMatrix = graph.adjacencyMatrix();
  std::array<std::array<std::array<std::array<char, maxEdgeTypeSize>, maxNumberEdges>, numberNodes>, numberNodes>
      adjacencyMatrixArray{};
 
  for (size_t senderId = 0; senderId < adjacencyMatrix.size(); ++senderId) {
    for (size_t receiverId = 0; receiverId < adjacencyMatrix.at(senderId).size(); ++receiverId) {
      for (size_t typeId = 0; typeId < adjacencyMatrix.at(senderId).at(receiverId).size(); ++typeId) {
        std::copy(
            adjacencyMatrix.at(senderId).at(receiverId).at(typeId).cbegin(),
            adjacencyMatrix.at(senderId).at(receiverId).at(typeId).cend(),
            adjacencyMatrixArray.at(senderId).at(receiverId).at(typeId).begin()
        );
      }
    }
  }
 
  // Copy registered nodes
  std::array<std::array<char, maxNodeNameSize>, numberNodes> registeredNodesNameArray;
  auto const &registeredNodesName = graph.registeredNodesName();
  for (size_t nodeId = 0; nodeId < numberNodes; ++nodeId) {
    std::copy(
        registeredNodesName.at(nodeId).cbegin(), registeredNodesName.at(nodeId).cend(),
        registeredNodesNameArray.at(nodeId).begin()
    );
    registeredNodesNameArray.at(nodeId).at(registeredNodesName.at(nodeId).size()) = '\0';
  }
 
  // Copy Input nodes
  auto inputTypeNodesMap = graph.inputNodes();
  hh_cx::tool::TypeNodesMapArray<nbTypesInput, maxTypeSizeInput, maxNumberNodesInput, maxSizeNameInput>
      inputTypeNodesMapArray{};
  for (size_t typeId = 0; typeId < inputTypeNodesMap.nbTypes(); ++typeId) {
    std::copy(
        inputTypeNodesMap.types().at(typeId).cbegin(), inputTypeNodesMap.types().at(typeId).cend(),
        inputTypeNodesMapArray.types().at(typeId).begin()
    );
    for (size_t nodeId = 0; nodeId < inputTypeNodesMap.nodesName().at(typeId).size(); ++nodeId) {
      std::copy(
          inputTypeNodesMap.nodesName().at(typeId).at(nodeId).cbegin(),
          inputTypeNodesMap.nodesName().at(typeId).at(nodeId).cend(),
          inputTypeNodesMapArray.nodes().at(typeId).at(nodeId).begin()
      );
    }
  }
 
  // Copy Output nodes
  auto outputTypeNodesMap = graph.outputNodes();
  hh_cx::tool::TypeNodesMapArray<nbTypesOutput, maxTypeSizeOutput, maxNumberNodesOutput, maxSizeNameOutput>
      outputTypeNodesMapArray{};
  for (size_t typeId = 0; typeId < outputTypeNodesMap.nbTypes(); ++typeId) {
    std::copy(
        outputTypeNodesMap.types().at(typeId).cbegin(), outputTypeNodesMap.types().at(typeId).cend(),
        outputTypeNodesMapArray.types().at(typeId).begin()
    );
    for (size_t nodeId = 0; nodeId < outputTypeNodesMap.nodesName().at(typeId).size(); ++nodeId) {
      std::copy(
          outputTypeNodesMap.nodesName().at(typeId).at(nodeId).cbegin(),
          outputTypeNodesMap.nodesName().at(typeId).at(nodeId).cend(),
          outputTypeNodesMapArray.nodes().at(typeId).at(nodeId).begin()
      );
    }
  }
 
  return hh_cx::Defroster<
      DynGraphType,
      decltype(nameArray),
      decltype(reportArray),
      decltype(adjacencyMatrixArray),
      decltype(registeredNodesNameArray),
      decltype(inputTypeNodesMapArray),
      decltype(outputTypeNodesMapArray)
  >(
      nameArray,
      isGraphValid, reportArray,
      adjacencyMatrixArray, registeredNodesNameArray,
      inputTypeNodesMapArray, outputTypeNodesMapArray);
}
}
#endif //HH_ENABLE_HH_CX
 
#endif //HEDGEHOG_CX_DEFROSTER_H_