support for reverse edges

Author: Roland Leißa

include/graphtool/graph.h

@@ -21,27 +21,33 @@ class Graph {
 
     public:
         Sym name() const { return name_; }
-        size_t pre() const { return pre_; }
-        size_t post() const { return post_; }
-        size_t rp() const { return rp_; }
+        template<size_t mode> size_t pre()  const { return order_[mode].pre; }
+        template<size_t mode> size_t post() const { return order_[mode].post; }
+        template<size_t mode> size_t rp()   const { return order_[mode].rp; }
 
         void link(Node* succ) {
             this->succs_.emplace(succ);
             succ->preds_.emplace(this);
         }
-        const auto& preds() const { return preds_; }
-        const auto& succs() const { return succs_; }
+
+        template<size_t mode = 0> const auto& preds() const { return mode == 0 ? preds_ : succs_; }
+        template<size_t mode = 0> const auto& succs() const { return mode == 0 ? succs_ : preds_; }
 
         friend std::ostream& operator<<(std::ostream&, const Node&);
 
     private:
-        std::pair<size_t, size_t> number(size_t, size_t);
+        template<size_t mode> std::pair<size_t, size_t> number(size_t, size_t);
 
         Sym name_;
         NodeSet preds_, succs_;
-        size_t pre_  = Not_Visited;
-        size_t post_ = Not_Visited;
-        size_t rp_   = Not_Visited;
+
+        struct Order {
+            size_t pre  = Not_Visited;
+            size_t post = Not_Visited;
+            size_t rp   = Not_Visited;
+        };
+
+        Order order_[2];
 
         friend class Graph;
     };
@@ -65,13 +71,12 @@ class Graph {
     fe::Driver& driver() { return driver_; }
     Sym name() const { return name_; }
     const auto& nodes() const { return nodes_; }
-    const auto& rpo() const { return rpo_; }
+    template<size_t mode> const auto& rpo() const { return rpo_[mode]; }
     ///@}
 
     void set_name(Sym name) { name_ = name; }
     Node* node(Sym name);
     void critical_edge_elimination();
-
     void number();
 
     friend std::ostream& operator<<(std::ostream&, const Graph&);
@@ -88,12 +93,14 @@ class Graph {
     }
 
 private:
+    template<size_t mode> void number_();
+
     fe::Driver& driver_;
     Sym name_;
     Node* entry_ = nullptr;
     Node* exit_  = nullptr;
     fe::SymMap<Node*> nodes_;
-    std::vector<Node*> rpo_;
+    std::vector<Node*> rpo_[2];
 };
 
 } // namespace graphtool

src/graphtool/graph.cpp

@@ -21,23 +21,32 @@ Graph::Node* Graph::node(Sym name) {
  */
 
 void Graph::number() {
-    auto [n, m] = entry_->number(0, 0);
+    number_<0>();
+    number_<1>();
+}
+
+template<size_t mode>
+void Graph::number_() {
+    auto [n, m] = entry_->number<mode>(0, 0);
     assert(n == m);
-    rpo_.resize(n);
+    rpo_[mode].resize(n);
     for (auto [_, node] : nodes()) {
-        if (node->post_ != Graph::Node::Not_Visited) {
-            size_t i = n - node->post_ - 1;
-            node->rp_ = i;
-            rpo_[i] = node;
+        auto& order = node->order_[mode];
+        if (order.post != Graph::Node::Not_Visited) {
+            size_t i = n - order.post - 1;
+            order.rp = i;
+            rpo_[mode][i] = node;
         }
     }
 }
 
+template<size_t mode>
 std::pair<size_t, size_t> Graph::Node::number(size_t pre, size_t post) {
-    if (pre_ == Not_Visited) {
-        pre_ = pre++;
-        for (auto succ : succs()) std::tie(pre, post) = succ->number(pre, post);
-        post_ = post++;
+    auto& order = order_[mode];
+    if (order.pre == Not_Visited) {
+        order.pre = pre++;
+        for (auto succ : succs<mode>()) std::tie(pre, post) = succ->template number<mode>(pre, post);
+        order.post = post++;
     }
     return {pre, post};
 }
@@ -70,12 +79,14 @@ void Graph::critical_edge_elimination() {
  */
 
 std::ostream& operator<<(std::ostream& os, const Graph::Node& node) {
-    return os << std::format("\t\"{}|{}|{}|{}\"", node.name(), node.pre(), node.post(), node.rp());
+    return os << std::format("\t\"{}[{}|{}|{}][{}|{}|{}]\"", node.name(),
+            node.pre<0>(), node.post<0>(), node.rp<0>(),
+            node.pre<1>(), node.post<1>(), node.rp<1>());
 }
 
 std::ostream& operator<<(std::ostream& os, const Graph& graph) {
     os << std::format("digraph {} {{", graph.name()) << std::endl;
-    for (const char* sep = ""; auto node : graph.rpo()) {
+    for (const char* sep = ""; auto node : graph.rpo<0>()) {
         for (auto succ : node->succs())
             os << std::format("\t{} -> {}", *node, *succ) << sep;
         sep = "\n";