add basic strip method for the graph

Author: tanneberger

include/reactor-cpp/environment.hh

@@ -91,6 +91,8 @@ public:
   }
 
   void optimize();
+  void expand_and_merge();
+  void strip_and_optimize();
 
   void register_reactor(Reactor* reactor);
   void register_port(BasePort* port) noexcept;

include/reactor-cpp/graph.hh

@@ -19,6 +19,8 @@ namespace reactor {
 template <class E, class P> class Graph {
 private:
   std::map<E, std::vector<std::pair<P, E>>> graph_;
+  std::size_t index{0};
+  std::map<E, std::string> name_map{};
 
   // custom compare operator this is required if u want special key values in std::map
   // this is required for the Graph::get_edges() method
@@ -38,6 +40,8 @@ public:
       : graph_(std::move(graph.graph_)) {}
   ~Graph() noexcept = default;
 
+  using Path = std::vector<std::pair<P, E>>;
+
   auto operator=(const Graph other) noexcept -> Graph& {
     graph_ = other.graph_;
     return *this;
@@ -51,7 +55,7 @@ public:
   // adds a single edge to the graph structure
   void add_edge(E source, E destination, P properties) noexcept {
     if (graph_.find(source) == std::end(graph_)) {
-      std::vector<std::pair<P, E>> edges{std::make_pair(properties, destination)};
+      Path edges{std::make_pair(properties, destination)};
       graph_[source] = edges;
     } else {
       graph_[source].emplace_back(properties, destination);
@@ -85,33 +89,88 @@ public:
     return keys;
   }
 
-  // returns the spanning tree of a given source including properties
-  [[nodiscard]] auto spanning_tree(E source) noexcept -> std::map<E, std::vector<std::pair<P, E>>> {
-    std::map<E, std::vector<std::pair<P, E>>> tree{};
-    std::vector<E> work_nodes{source};
-
-    while (!work_nodes.empty()) {
-      auto parent = *work_nodes.begin();
-
-      for (auto child : graph_[parent]) {
-        // figuring out the properties until this node
-        std::vector<std::pair<P, E>> parent_properties{};
-        if (tree.find(parent) != std::end(tree)) {
-          // this if should always be the case except the first time when tree is empty
-          parent_properties = tree[parent]; // TODO: make sure this is a copy otherwise we change this properties as
-                                            // well
-        }
+  auto name_resolver(E object) -> std::string {
+    char names[] = "ABCDEFGHIJKLMNOPQRSTUVGXYZabcdefghijklmnopqrstuvgxyz";
+    if(name_map.find(object) == std::end(name_map)) {
+      name_map[object] = names[index];
+      index++;
+      return std::string{names[index - 1], 1};
+    }
+    return name_map[object];
+  }
+
+  // the return type looks a little bit cursed what is happening here ?
+  // we have a map from the destination as a key to a list of paths through the graph.
+  // A path here is modelled by a list of edges (with properties and the next vertex).
+  auto naive_spanning_tree(E source) noexcept -> std::vector<std::vector<std::pair<P, E>>> {
+    auto result = recursive_spanning_tree(source, std::vector<E>{});
+
+    std::string mermaid_string = "graph TD;\n";
+
+    for (auto path : result ) {
+      mermaid_string += std::string("    ") + name_resolver(source);
+      for (auto edge : path) {
+         mermaid_string += std::string("-->")+ name_resolver(edge.second);
+      }
+      mermaid_string += std::string(";\n");
+
+    }
+    //std::cout << "EDGE: \n" << mermaid_string << std::endl;
+    return result;
+  }
+
+
+  // this function goes recursively though the graph and tries to find every possible path
+  auto recursive_spanning_tree(E source_node, std::vector<E> visited_nodes) -> std::vector<std::vector<std::pair<P, E>>> {
+    std::vector<Path> paths{};
+
+    if (graph_[source_node].empty()) {
+      return std::vector<Path>{Path{}};
+    }
+
+    for (auto child : graph_[source_node]) {
+      E current_node = child.second;
+
+      // means this node has not been visited yey
+      if (std::find(std::begin(visited_nodes), std::end(visited_nodes), current_node) == std::end(visited_nodes)) {
 
-        // appending the new property and inserting into the tree
-        parent_properties.push_back(child);
-        work_nodes.push_back(child.second);
-        tree[child.second] = parent_properties;
+        // creating a temporary vector where the currently selected vertex is appended
+        auto temp_nodes = visited_nodes;
+        temp_nodes.push_back(current_node);
+
+        for (auto path: recursive_spanning_tree(current_node, temp_nodes)) {
+          path.insert(std::begin(path), child);
+          paths.push_back(path);
+        }
       }
+    }
+
+    return paths;
+  }
 
-      work_nodes.erase(std::begin(work_nodes));
+  auto shortest_path(E source, E destination) -> std::optional<Path> {
+    // TODO: maybe build proper djikstra here
+
+    auto spanning_tre = naive_spanning_tree(source);
+    std::vector<Path> relevant_paths{};
+
+    std::copy_if(spanning_tre.begin(), spanning_tre.end(), std::back_inserter(relevant_paths), [destination](Path path) {
+      return (*path.end()).second == destination;
+    });
+
+    if (relevant_paths.empty()) {
+      return std::nullopt;
     }
 
-    return tree;
+    Path best_path = *relevant_paths.begin();
+
+    for (auto path : relevant_paths) {
+      if (path.size() < best_path.size()) {
+        best_path = path;
+      }
+    }
+
+    return best_path;
   }
 
   [[nodiscard]] auto get_destinations(E source) const noexcept -> std::vector<std::pair<P, E>> {
@@ -126,6 +185,17 @@ public:
     }
   }
 
+  auto to_mermaid() noexcept -> std::string {
+    std::string mermaid_string = "graph TD;\n";
+
+    for (const auto& [source, destinations] : graph_) {
+      for (auto dest : destinations) {
+        mermaid_string += std::string("    ") + name_resolver(source) + std::string("-->") + name_resolver(dest.second) + std::string(";\n");
+      }
+    }
+    return mermaid_string;
+  }
+
   friend auto operator<<(std::ostream& outstream, const Graph& graph) -> std::ostream& {
     for (auto const& [source, destinations] : graph.graph_) {
       for (auto destination : destinations) {

include/reactor-cpp/port.hh

@@ -92,6 +92,7 @@ public:
   [[nodiscard]] inline auto has_outward_bindings() const noexcept -> bool { return !outward_bindings_.empty(); }
   [[nodiscard]] inline auto has_dependencies() const noexcept -> bool { return !dependencies_.empty(); }
   [[nodiscard]] inline auto has_anti_dependencies() const noexcept -> bool { return !anti_dependencies_.empty(); }
+  [[nodiscard]] inline auto has_triggers() const noexcept -> bool { return !triggers_.empty(); }
 
   [[nodiscard]] inline auto inward_binding() const noexcept -> BasePort* { return inward_binding_; }
   [[nodiscard]] inline auto outward_bindings() const noexcept -> const auto& { return outward_bindings_; }

lib/CMakeLists.txt

@@ -22,7 +22,7 @@ else()
   set(REACTOR_CPP_INCLUDE "include")
 endif()
 
-add_library(${LIB_TARGET} SHARED ${SOURCE_FILES})
+add_library(${LIB_TARGET} STATIC ${SOURCE_FILES})
 target_include_directories(${LIB_TARGET} PUBLIC
   "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>"
   "$<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/include>"