lemon-0.x: comparison src/lemon/smart

equal deleted inserted replaced

-:87fee299ff83
+:0e0b78863514
 #include <vector>
 #include <lemon/invalid.h>
-#include <lemon/erasable_graph_extender.h>
 #include <lemon/clearable_graph_extender.h>
 #include <lemon/extendable_graph_extender.h>
 #include <lemon/idmappable_graph_extender.h>
 namespace lemon {
 /// \addtogroup graphs
 /// @{
+class SmartGraph;
 ///Base of SmartGraph
 ///Base of SmartGraph
 ///
 class SmartGraphBase {
+friend class SmatGraph;
+protected:
 struct NodeT
 {
 int first_in,first_out;
 NodeT() : first_in(-1), first_out(-1) {}
 };
 }
 class Node {
 friend class SmartGraphBase;
+friend class SmartGraph;
 protected:
 int n;
+///\todo It should be removed (or at least define a setToId() instead).
+///
 Node(int nn) {n=nn;}
 public:
 Node() {}
 Node (Invalid) { n=-1; }
 bool operator==(const Node i) const {return n==i.n;}
 };
 class Edge {
 friend class SmartGraphBase;
+friend class SmartGraph;
 protected:
 int n;
+///\todo It should be removed (or at least define a setToId() instead).
+///
 Edge(int nn) {n=nn;}
 public:
 Edge() { }
 Edge (Invalid) { n=-1; }
 bool operator==(const Edge i) const {return n==i.n;}
 int e = (prev.n==-1)? nodes[u.n].first_out : edges[prev.n].next_out;
 while(e!=-1 && edges[e].tail!=v.n) e = edges[e].next_out;
 prev.n=e;
 return prev;
 }
 };
 typedef AlterableGraphExtender<SmartGraphBase> AlterableSmartGraphBase;
 typedef IterableGraphExtender<AlterableSmartGraphBase> IterableSmartGraphBase;
 typedef IdMappableGraphExtender<IterableSmartGraphBase> IdMappableSmartGraphBase;
 ///
 ///\author Alpar Juttner
 class SmartGraph :public ClearableSmartGraphBase {
 public:
 /// Finds an edge between two nodes.
 /// Finds an edge from node \c u to node \c v.
 ///
 /// If \c prev is \ref INVALID (this is the default value), then
 /// it finds the first edge from \c u to \c v. Otherwise it looks for
 /// the next edge from \c u to \c v after \c prev.
 /// \todo Possibly it should be a global function.
 Edge findEdge(Node u,Node v, Edge prev = INVALID)
 {
 return _findEdge(u,v,prev);
 }
-};
+///Internal data structure to store snapshots
+///\ingroup graphs
+///\sa makeSnapShot()
+///\sa rollBack()
+struct SnapShot
+{
+unsigned int node_num;
+unsigned int edge_num;
+};
+///Make a snapshot of the graph.
+///Make a snapshot of the graph.
+///
+///The newly added nodes and edges can be removed using the
+///rollBack() function.
+///
+///\return An stucture SnapShot describing the pesent state of the
+///graph.
+///\note After you rolled back to a state, you cannot roll "back" to
+///a later state, in other word you cannot add again the edges deleted
+///by rollBack().
+SnapShot makeSnapShot()
+{
+SnapShot s;
+s.node_num=nodes.size();
+s.edge_num=edges.size();
+return s;
+}
+///Undo the changes until a snapshot.
+///Undo the changes until a snapshot created by makeSnapShot().
+///
+///\param s an internal stucture given back by makeSnapShot()
+///\note After you rolled back to a state, you cannot "roll forward" to
+///a later state, in other word you cannot add again the edges deleted
+///by rollBack().
+///
+///\todo This function might be called undo().
+void rollBack(const SnapShot &s)
+{
+while(s.edge_num>edges.size()) {
+	edge_observers.erase(Edge(edges.size()-1));
+	nodes[edges.back().head].first_in=edges.back().next_in;
+	nodes[edges.back().tail].first_out=edges.back().next_out;
+	edges.pop_back();
+}
+//nodes.resize(s.nodes_num);
+while(s.node_num>nodes.size()) {
+	node_observers.erase(Node(nodes.size()-1));
+	nodes.pop_back();
+}
+}
+};
 template <>
 int countNodes<SmartGraph>(const SmartGraph& graph) {
 return graph.nodeNum();
 }

changeset 973	6a6f3ac07b20
parent 969	0631847b37e5
child 974	785062a83f8e