graph.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_GRAPH_H_
#define HEDGEHOG_CX_GRAPH_H_
 
#ifdef HH_ENABLE_HH_CX
 
#include "node.h"
 
#include "../tools/concepts.h"
#include "../tools/types_nodes_map.h"
 
#include "../../src/tools/meta_functions.h"
 
namespace hh_cx {
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
template<tool::HedgehogDynamicGraphForStaticAnalysis GraphType>
class AbstractTest;
#endif //DOXYGEN_SHOULD_SKIP_THIS
 
template<tool::HedgehogDynamicGraphForStaticAnalysis GraphType>
class Graph : public Node<GraphType> {
 private:
  std::vector<hh_cx::behavior::AbstractNode const *>
      registeredNodes_{}; 
 
  std::vector<std::string>
      registeredNodesName_{}; 
 
  tool::TypesNodesMap
      inputNodes_{}, 
      outputNodes_{}; 
 
  std::vector<std::vector<std::vector<std::string>>>
      adjacencyMatrix_{}, 
      ROEdges_{}, 
      constEdges_{}; 
 
  std::vector<AbstractTest<GraphType> const *> tests_{}; 
 
  std::string report_{}; 
 
 public:
  constexpr explicit Graph(std::string const &name) : hh_cx::Node<GraphType>(name) {}
 
  constexpr virtual ~Graph() = default;
 
  [[nodiscard]] constexpr bool isLinked(
      hh_cx::behavior::AbstractNode const *sender,
      hh_cx::behavior::AbstractNode const *receiver) const {
    return isLinked(nodeId(sender), nodeId(receiver));
  }
 
  [[nodiscard]] constexpr bool isLinked(
      size_t const senderId,
      size_t const receiverId) const {
    if (senderId >= numberNodesRegistered() || receiverId >= numberNodesRegistered()) {
      throw (std::runtime_error("The node you are trying to get does not exist in the graph."));
    }
    return !adjacencyMatrix_.at(senderId).at(receiverId).empty();
  }
 
  [[nodiscard]] constexpr bool isROLinked(
      hh_cx::behavior::AbstractNode const *sender,
      hh_cx::behavior::AbstractNode const *receiver,
      std::string const &typeName) const {
    return isROLinked(nodeId(sender), nodeId(receiver), typeName);
  }
 
  [[nodiscard]] constexpr bool isROLinked(
      size_t const senderId,
      size_t const receiverId,
      std::string const &typeName) const {
    if (senderId >= numberNodesRegistered() || receiverId >= numberNodesRegistered()) {
      throw (std::runtime_error("The node you are trying to get does not exist in the graph."));
    }
    auto listROType = ROEdges_.at(senderId).at(receiverId);
    return std::find(listROType.cbegin(), listROType.cend(), typeName) != listROType.cend();
  }
 
  [[nodiscard]] constexpr bool isConstLinked(
      hh_cx::behavior::AbstractNode const *sender,
      hh_cx::behavior::AbstractNode const *receiver,
      std::string const &typeName) const {
    return isConstLinked(nodeId(sender), nodeId(receiver), typeName);
  }
 
  [[nodiscard]] constexpr bool isConstLinked(
      size_t const senderId,
      size_t const receiverId,
      std::string const &typeName) const {
    if (senderId >= numberNodesRegistered() || receiverId >= numberNodesRegistered()) {
      throw (std::runtime_error("The node you are trying to get does not exist in the graph."));
    }
    auto listConstType = constEdges_.at(senderId).at(receiverId);
    return std::find(listConstType.cbegin(), listConstType.cend(), typeName) != listConstType.cend();
  }
 
  [[nodiscard]] constexpr std::string const &report() const { return report_; }
 
  [[nodiscard]] constexpr std::vector<hh_cx::behavior::AbstractNode const *> const &registeredNodes() const {
    return registeredNodes_;
  }
 
  [[nodiscard]] constexpr std::vector<std::string> const &registeredNodesName() const {
    return registeredNodesName_;
  }
  [[nodiscard]] constexpr std::pair<size_t, size_t> maxEdgeSizes() const {
    size_t maxNumberEdges = 0, maxEdgeTypeSize = 0;
    for (auto const &sender : adjacencyMatrix_) {
      for (auto const &receiver : sender) {
        if (maxNumberEdges < receiver.size()) { maxNumberEdges = receiver.size(); }
        for (auto const &outputType : receiver) {
          if (maxEdgeTypeSize < outputType.size() + 1) { maxEdgeTypeSize = outputType.size() + 1; }
        }
      }
    }
    return {maxNumberEdges, maxEdgeTypeSize};
  }
 
  [[nodiscard]] constexpr size_t maxNodeNameSize() const {
    size_t maxNodeNameSize = 0;
    for (auto const &nodeName : registeredNodesName_) {
      if (nodeName.size() > maxNodeNameSize) { maxNodeNameSize = nodeName.size(); }
    }
    return maxNodeNameSize;
  }
 
  [[nodiscard]] constexpr std::vector<std::vector<std::vector<std::string>>> const &adjacencyMatrix() const {
    return adjacencyMatrix_;
  }
 
  [[nodiscard]] constexpr tool::TypesNodesMap const &inputNodes() const { return inputNodes_; }
 
  [[nodiscard]] constexpr tool::TypesNodesMap const &outputNodes() const { return outputNodes_; }
 
  [[nodiscard]] constexpr std::vector<std::vector<std::string>> const &
  adjacentNodesTypes(hh_cx::behavior::AbstractNode const *node) const {
    return adjacencyMatrix_.at(nodeId(node));
  }
 
  [[nodiscard]] constexpr std::vector<hh_cx::behavior::AbstractNode const *>
  adjacentNodes(hh_cx::behavior::AbstractNode const *node) const {
 
    std::vector<hh_cx::behavior::AbstractNode const *> adjacentNodes{};
 
    for (auto const &possibleReceiver : this->registeredNodes_) {
      if (isLinked(node, possibleReceiver)) {
        adjacentNodes.push_back(possibleReceiver);
      }
    }
    return adjacentNodes;
  }
 
  [[nodiscard]] constexpr std::vector<hh_cx::behavior::AbstractNode const *>
  adjacentNodes(hh_cx::behavior::AbstractNode const *node, std::string const &type) const {
 
    std::vector<hh_cx::behavior::AbstractNode const *> adjacentNodes{};
 
    for (auto const &possibleReceiver : this->registeredNodes_) {
      auto const &connectionTypes = this->adjacencyMatrix_.at(nodeId(node)).at(nodeId(possibleReceiver));
      if (std::find(connectionTypes.cbegin(), connectionTypes.cend(), type) != connectionTypes.cend()) {
        adjacentNodes.push_back(possibleReceiver);
 
      }
    }
 
    return adjacentNodes;
  }
 
  [[nodiscard]] constexpr size_t numberNodesRegistered() const { return registeredNodes_.size(); }
 
  template<tool::HedgehogStaticNode InputNode>
  constexpr void inputs(InputNode const &inputNode) {
    using commonTypes = hh::tool::Intersect_t<typename InputNode::inputs_t, typename GraphType::inputs_t>;
    static_assert(std::tuple_size_v<commonTypes> != 0,
                  "The node can not be an input node, at least one of its input types should be the same of "
                  "the graph input types");
 
    splitInputNodeRegistration<commonTypes>(inputNode, std::make_index_sequence<std::tuple_size_v<commonTypes>>());
  }
 
  template<class InputType, tool::HedgehogStaticNode InputNode>
  constexpr void input(InputNode const &inputNode) {
    auto typeName = hh::tool::typeToStr<InputType>();
    static_assert(
        hh::tool::isContainedInTuple_v<InputType, typename InputNode::inputs_t> &&
            hh::tool::isContainedInTuple_v<InputType, typename GraphType::inputs_t>,
        "The input type is not shared by the node and the graph.");
    registerNode(&inputNode);
    inputNodes_.insert(typeName, &inputNode);
  }
 
  template<tool::HedgehogStaticNode OutputNode>
  constexpr void outputs(OutputNode const &outputNode) {
    using commonTypes = hh::tool::Intersect_t<typename OutputNode::outputs_t, typename GraphType::outputs_t>;
    static_assert(std::tuple_size_v<commonTypes> != 0,
                  "The node can not be an output node, at least one of its output types should be the same of "
                  "the graph iouput types");
    splitOutputNodeRegistration<commonTypes>(outputNode, std::make_index_sequence<std::tuple_size_v<commonTypes>>{});
  }
 
  template<class OutputType, tool::HedgehogStaticNode OutputNode>
  constexpr void output(OutputNode const &outputNode) {
    auto typeName = hh::tool::typeToStr<OutputType>();
    static_assert(
        hh::tool::isContainedInTuple_v<OutputType, typename OutputNode::outputs_t> &&
            hh::tool::isContainedInTuple_v<OutputType, typename GraphType::outputs_t>,
        "The output type is not shared by the node and the graph.");
    registerNode(&outputNode);
    outputNodes_.insert(typeName, &outputNode);
  }
 
  template<tool::HedgehogStaticNode SenderNode, tool::HedgehogStaticNode ReceiverNode>
  constexpr void edges(SenderNode const &senderNode, ReceiverNode const &receiverNode) {
    using commonTypes = hh::tool::Intersect_t<typename SenderNode::outputs_t, typename ReceiverNode::inputs_t>;
    static_assert(std::tuple_size_v<commonTypes> != 0,
                  "The edge cannot be created, there is no common type between the nodes.");
 
    splitEdgeRegistration<commonTypes>(senderNode,
                                       receiverNode,
                                       std::make_index_sequence<std::tuple_size_v<commonTypes>>{});
  }
 
  template<class EdgeType, tool::HedgehogStaticNode SenderNode, tool::HedgehogStaticNode ReceiverNode>
  constexpr void edge(SenderNode &senderNode, ReceiverNode &receiverNode) {
    using sender_outputs_t = typename SenderNode::outputs_t;
    using receiver_inputs_t = typename ReceiverNode::inputs_t;
    using ro_receiver_inputs_t = typename ReceiverNode::ro_type_t;
    std::string typeName = hh::tool::typeToStr<EdgeType>();
    static_assert(
        hh::tool::isContainedInTuple_v<EdgeType, sender_outputs_t>
            && hh::tool::isContainedInTuple_v<EdgeType, receiver_inputs_t>,
        "The edge cannot be created, the type is not part of the sender's outputs or receiver's inputs.");
 
    registerNode(&senderNode);
    registerNode(&receiverNode);
 
    adjacencyMatrix_.at(nodeId(&senderNode)).at(nodeId(&receiverNode)).push_back(typeName);
 
    if constexpr (hh::tool::isContainedInTuple_v<EdgeType, ro_receiver_inputs_t>) {
      ROEdges_.at(nodeId(&senderNode)).at(nodeId(&receiverNode)).push_back(typeName);
    }
 
    if constexpr (std::is_const_v<EdgeType>) {
      constEdges_.at(nodeId(&senderNode)).at(nodeId(&receiverNode)).push_back(typeName);
    }
  }
 
  template<class Node>
  requires std::is_base_of_v<hh_cx::behavior::AbstractNode, Node>
  constexpr size_t nodeId(Node *node) const {
    if (std::find(registeredNodes_.cbegin(), registeredNodes_.cend(), node) == registeredNodes_.cend()) {
      throw (std::runtime_error("The node you are trying to get does not exist in the graph."));
    }
    size_t nodeId = 0;
    for (auto registeredNode : registeredNodes_) {
      if (registeredNode == node) { return nodeId; }
      else { ++nodeId; }
    }
    return nodeId;
  }
 
  [[nodiscard]] constexpr hh_cx::behavior::AbstractNode const *node(size_t id) const {
    if (id >= registeredNodes_.size()) { throw (std::runtime_error("The node you are requesting does not exist.")); }
    else { return registeredNodes_.at(id); }
  }
 
  template<class UserTest>
  requires std::is_base_of_v<AbstractTest<GraphType>, UserTest>
  constexpr void addTest(UserTest *test) {
    // Add the test if not already added
    if (std::find(tests_.cbegin(), tests_.cend(), test) == tests_.cend()) {
      tests_.push_back(test);
      test->test(this);
      report_.append(test->errorMessage());
      report_.append("\n");
    }
  }
 
  [[nodiscard]] constexpr bool isValid() const {
    bool ret = true;
    for (auto const &test : tests_) { ret &= test->isGraphValid(); }
    return ret;
  }
 
 private:
  template<class CommonInputs, class T, std::size_t... Is>
  constexpr void splitInputNodeRegistration(T const &node, std::index_sequence<Is...>) {
    (input<std::tuple_element_t<Is, CommonInputs>>(node), ...);
  }
 
  template<class CommonOutputs, class T, std::size_t... Is>
  constexpr void splitOutputNodeRegistration(T const &node, std::index_sequence<Is...>) {
    (output<std::tuple_element_t<Is, CommonOutputs>>(node), ...);
  }
 
  template<class CommonTypes, class S, class R, std::size_t... Is>
  constexpr void splitEdgeRegistration(S const &sender, R const &receiver, std::index_sequence<Is...>) {
    (edge<std::tuple_element_t<Is, CommonTypes>>(sender, receiver), ...);
  }
 
  constexpr void registerNode(hh_cx::behavior::AbstractNode const *node) {
    if (std::find(registeredNodes_.cbegin(), registeredNodes_.cend(), node) == registeredNodes_.cend()) {
      validateName(node);
      registeredNodes_.push_back(node);
      registeredNodesName_.push_back(node->name());
      adjacencyMatrix_.emplace_back();
      ROEdges_.emplace_back();
      constEdges_.emplace_back();
 
      for (auto &sender : adjacencyMatrix_) { sender.resize(registeredNodes_.size()); }
      for (auto &sender : ROEdges_) { sender.resize(registeredNodes_.size()); }
      for (auto &sender : constEdges_) { sender.resize(registeredNodes_.size()); }
    }
  }
 
  constexpr void validateName(hh_cx::behavior::AbstractNode const *node) {
    if (std::any_of(
        registeredNodes_.cbegin(), registeredNodes_.cend(),
        [&node](auto const &registeredNode) { return node->name() == registeredNode->name(); })) {
      throw std::runtime_error("Another node with the same name has already been registered.");
    }
  }
};
}
#endif //HH_ENABLE_HH_CX
#endif //HEDGEHOG_CX_GRAPH_H_