Ticket #23: item_validity_check.patch

lemon/graph_utils.h

@@ -128 +128 @@
   typedef typename ::lemon::_graph_utils_bits::                         \
   Node<Digraph>::type Node;                                             \
   typedef typename ::lemon::_graph_utils_bits::                         \
-  NodeIt<Digraph>::type NodeIt;                                         \
+  NodeIt<Digraph>::type NodeIt;                                         \
   typedef typename ::lemon::_graph_utils_bits::                         \
   Arc<Digraph>::type Arc;                                               \
   typedef typename ::lemon::_graph_utils_bits::                         \

lemon/list_graph.h

@@ -152 +152 @@
     static Node nodeFromId(int id) { return Node(id);}
     static Arc arcFromId(int id) { return Arc(id);}
 
+    bool valid(Node n) const { 
+      return n.id >= 0 && n.id < static_cast<int>(nodes.size()) && 
+        nodes[n.id].prev != -2;
+    }
+
+    bool valid(Arc a) const { 
+      return a.id >= 0 && a.id < static_cast<int>(arcs.size()) && 
+        arcs[a.id].prev_in != -2;
+    }
+
     Node addNode() {     
       int n;
       
@@ -219 +229 @@
       
       nodes[n].next = first_free_node;
       first_free_node = n;
+      nodes[n].prev = -2;
 
     }
     
@@ -247 +258 @@
       }
       
       arcs[n].next_in = first_free_arc;
-      first_free_arc = n;      
-
+      first_free_arc = n;
+      arcs[n].prev_in = -2;
     }
 
     void clear() {
@@ -349 +360 @@
     Arc addArc(const Node& s, const Node& t) { 
       return Parent::addArc(s, t); 
     }
+
+    /// Node validity checking
+
+    /// The function gives back true, when the given node is valid,
+    /// ie. it is a real node of the graph.  
+    ///
+    /// \warning A removed node could become valid, if new nodes are
+    /// added to the graph.
+    bool valid(Node n) const { return Parent::valid(n); }
+
+    /// Arc validity checking
+
+    /// The function gives back true, when the given arc is valid,
+    /// ie. it is a real arc of the graph.  
+    ///
+    /// \warning A removed arc could become valid, if new arcs are
+    /// added to the graph.
+    bool valid(Arc a) const { return Parent::valid(a); }
 
     /// Change the target of \c e to \c n
 
@@ -945 +974 @@
     static Arc arcFromId(int id) { return Arc(id);}
     static Edge edgeFromId(int id) { return Edge(id);}
 
+    bool valid(Node n) const { 
+      return n.id >= 0 && n.id < static_cast<int>(nodes.size()) && 
+        nodes[n.id].prev != -2;
+    }
+
+    bool valid(Arc a) const { 
+      return a.id >= 0 && a.id < static_cast<int>(arcs.size()) && 
+        arcs[a.id].prev_out != -2;
+    }
+
+    bool valid(Edge e) const { 
+      return e.id >= 0 && 2 * e.id < static_cast<int>(arcs.size()) && 
+        arcs[2 * e.id].prev_out != -2;
+    }
+
     Node addNode() {     
       int n;
       
@@ -1013 +1057 @@
       
       nodes[n].next = first_free_node;
       first_free_node = n;
-
+      nodes[n].prev = -2;
     }
     
     void erase(const Edge& edge) {
@@ -1041 +1085 @@
       
       arcs[n].next_out = first_free_arc;
       first_free_arc = n;      
+      arcs[n].prev_out = -2;
+      arcs[n | 1].prev_out = -2;
 
     }
 
@@ -1157 +1203 @@
     Edge addEdge(const Node& s, const Node& t) { 
       return Parent::addEdge(s, t); 
     }
+    /// \brief Node validity checking
+    ///
+    /// The function gives back true, when the given node is valid,
+    /// ie. it is a real node of the graph.  
+    ///
+    /// \warning A removed node could become valid, if new nodes are
+    /// added to the graph.
+    bool valid(Node n) const { return Parent::valid(n); }
+    /// \brief Arc validity checking
+    ///
+    /// The function gives back true, when the given arc is valid,
+    /// ie. it is a real arc of the graph.  
+    ///
+    /// \warning A removed arc could become valid, if new edges are
+    /// added to the graph.
+    bool valid(Arc a) const { return Parent::valid(a); }
+    /// \brief Edge validity checking
+    ///
+    /// The function gives back true, when the given edge is valid,
+    /// ie. it is a real edge of the graph.  
+    ///
+    /// \warning A removed edge could become valid, if new edges are
+    /// added to the graph.
+    bool valid(Edge e) const { return Parent::valid(e); }
     /// \brief Change the source of \c e to \c n
     ///
     /// This function changes the source of \c e to \c n.

lemon/smart_graph.h

@@ -114 +114 @@
 
     static Node nodeFromId(int id) { return Node(id);}
     static Arc arcFromId(int id) { return Arc(id);}
+
+    bool valid(Node n) const { 
+      return n._id >= 0 && n._id < static_cast<int>(nodes.size()); 
+    }
+    bool valid(Arc a) const { 
+      return a._id >= 0 && a._id < static_cast<int>(arcs.size()); 
+    }
 
     class Node {
       friend class SmartDigraphBase;
@@ -261 +268 @@
     /// \sa reserveNode
     void reserveArc(int m) { arcs.reserve(m); };
 
+    /// \brief Node validity checking
+    ///
+    /// The function gives back true, when the given node is valid,
+    /// ie. it is a real node of the graph.  
+    ///
+    /// \warning A removed node (using Snapshot) could become valid,
+    /// if new nodes are added to the graph.
+    bool valid(Node n) const { return Parent::valid(n); }
+
+    /// \brief Arc validity checking
+    ///
+    /// The function gives back true, when the given arc is valid,
+    /// ie. it is a real arc of the graph.  
+    ///
+    /// \warning A removed arc (using Snapshot) could become valid,
+    /// if new arcs are added to the graph.
+    bool valid(Arc a) const { return Parent::valid(a); }
+
     ///Clear the digraph.
     
     ///Erase all the nodes and arcs from the digraph.
@@ -550 +575 @@
     static Arc arcFromId(int id) { return Arc(id);}
     static Edge edgeFromId(int id) { return Edge(id);}
 
+    bool valid(Node n) const { 
+      return n._id >= 0 && n._id < static_cast<int>(nodes.size()); 
+    }
+    bool valid(Arc a) const { 
+      return a._id >= 0 && a._id < static_cast<int>(arcs.size());
+    }
+    bool valid(Edge e) const { 
+      return e._id >= 0 && 2 * e._id < static_cast<int>(arcs.size()); 
+    }
+
     Node addNode() {     
       int n = nodes.size();
       nodes.push_back(NodeT());
@@ -642 +677 @@
       return Parent::addEdge(s, t); 
     }
 
+    /// \brief Node validity checking
+    ///
+    /// The function gives back true, when the given node is valid,
+    /// ie. it is a real node of the graph.  
+    ///
+    /// \warning A removed node (using Snapshot) could become valid,
+    /// if new nodes are added to the graph.
+    bool valid(Node n) const { return Parent::valid(n); }
+
+    /// \brief Arc validity checking
+    ///
+    /// The function gives back true, when the given arc is valid,
+    /// ie. it is a real arc of the graph.  
+    ///
+    /// \warning A removed arc (using Snapshot) could become valid,
+    /// if new edges are added to the graph.
+    bool valid(Arc a) const { return Parent::valid(a); }
+
+    /// \brief Edge validity checking
+    ///
+    /// The function gives back true, when the given edge is valid,
+    /// ie. it is a real edge of the graph.  
+    ///
+    /// \warning A removed edge (using Snapshot) could become valid,
+    /// if new edges are added to the graph.
+    bool valid(Edge e) const { return Parent::valid(e); }
+
     ///Clear the graph.
     
     ///Erase all the nodes and edges from the graph.

test/graph_test.cc

@@ -22 +22 @@
 // #include <lemon/full_graph.h>
 // #include <lemon/grid_graph.h>
 
-//#include <lemon/graph_utils.h>
+#include <lemon/graph_utils.h>
 
 #include "test_tools.h"
 
@@ -82 +82 @@
 }
 
 template <typename Graph>
-void print_items(Graph &g) {
+void check_graph_counts() {
 
-  typedef typename Graph::NodeIt NodeIt;
-  typedef typename Graph::EdgeIt EdgeIt;
-  typedef typename Graph::ArcIt ArcIt;
-
-  std::cout << "Nodes" << std::endl;
-  int i=0;
-  for(NodeIt it(g); it!=INVALID; ++it, ++i) {
-    std::cout << "  " << i << ": " << g.id(it) << std::endl;
-  }
-
-  std::cout << "Edge" << std::endl;
-  i=0;
-  for(EdgeIt it(g); it!=INVALID; ++it, ++i) {
-    std::cout << "  " << i << ": " << g.id(it) 
-         << " (" << g.id(g.source(it)) << ", " << g.id(g.target(it)) 
-         << ")" << std::endl;
-  }
-
-  std::cout << "Arc" << std::endl;
-  i=0;
-  for(ArcIt it(g); it!=INVALID; ++it, ++i) {
-    std::cout << "  " << i << ": " << g.id(it)
-         << " (" << g.id(g.source(it)) << ", " << g.id(g.target(it)) 
-         << ")" << std::endl;
-  }
-
-}
-
-template <typename Graph>
-void check_graph() {
-
-  typedef typename Graph::Node Node;
-  typedef typename Graph::Edge Edge;
-  typedef typename Graph::Arc Arc;
-  typedef typename Graph::NodeIt NodeIt;
-  typedef typename Graph::EdgeIt EdgeIt;
-  typedef typename Graph::ArcIt ArcIt;
-
+  GRAPH_TYPEDEFS(Graph);
   Graph g;
 
   check_item_counts(g,0,0);
@@ -135 +98 @@
     e1 = g.addEdge(n1, n2),
     e2 = g.addEdge(n2, n3);
 
-  // print_items(g);
-
   check_item_counts(g,3,2);
 }
+
+template <typename Graph>
+void check_graph_validity() {
+
+  GRAPH_TYPEDEFS(Graph);
+  Graph g;
+
+  check_item_counts(g,0,0);
+
+  Node
+    n1 = g.addNode(),
+    n2 = g.addNode(),
+    n3 = g.addNode();
+
+  Edge
+    e1 = g.addEdge(n1, n2),
+    e2 = g.addEdge(n2, n3);
+
+  check(g.valid(n1), "Validity check");
+  check(g.valid(e1), "Validity check");
+  check(g.valid(g.direct(e1, true)), "Validity check");
+
+  check(!g.valid(g.nodeFromId(-1)), "Validity check");
+  check(!g.valid(g.edgeFromId(-1)), "Validity check");
+  check(!g.valid(g.arcFromId(-1)), "Validity check");
+    
+}
+
+template <typename Graph>
+void check_graph_validity_erase() {
+
+  GRAPH_TYPEDEFS(Graph);
+  Graph g;
+
+  check_item_counts(g,0,0);
+
+  Node
+    n1 = g.addNode(),
+    n2 = g.addNode(),
+    n3 = g.addNode();
+
+  Edge
+    e1 = g.addEdge(n1, n2),
+    e2 = g.addEdge(n2, n3);
+
+  check(g.valid(n1), "Validity check");
+  check(g.valid(e1), "Validity check");
+  check(g.valid(g.direct(e1, true)), "Validity check");
+
+  g.erase(n1);
+
+  check(!g.valid(n1), "Validity check");
+  check(g.valid(n2), "Validity check");
+  check(g.valid(n3), "Validity check");
+  check(!g.valid(e1), "Validity check");
+  check(g.valid(e2), "Validity check");
+
+  check(!g.valid(g.nodeFromId(-1)), "Validity check");
+  check(!g.valid(g.edgeFromId(-1)), "Validity check");
+  check(!g.valid(g.arcFromId(-1)), "Validity check");
+    
+}
+
+
 
 // void checkGridGraph(const GridGraph& g, int w, int h) {
 //   check(g.width() == w, "Wrong width");
@@ -187 +212 @@
 int main() {
   check_concepts();
 
-  check_graph<ListGraph>();
-  check_graph<SmartGraph>();
+  check_graph_counts<ListGraph>();
+  check_graph_counts<SmartGraph>();
+
+  check_graph_validity_erase<ListGraph>();
+  check_graph_validity<SmartGraph>();
 
 //   {
 //     FullGraph g(5);