Changeset 1011:5bd6c7671c9e in lemon-0.x for src/lemon/list_graph.h

Timestamp:

11/20/04 11:19:06 (20 years ago)

Author:

Alpar Juttner

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@1401

Message:

• snapshot-rollback functionarity added to ListGraph?
• The iterface of the snapshot-rollback functionarity in SmartGraph? has changed to be compatible with ListGraph::SnapShot?.

File:

• src/lemon/list_graph.h (modified) (2 diffs)

src/lemon/list_graph.h

@@ -32 +32 @@
 #include <lemon/default_map.h>
 
+#include <list>
 
 namespace lemon {
@@ -387 +388 @@
       erase(b);
     }
+
+
+    ///Class to make a snapshot of the graph and to restrore to it later.
+
+    ///Class to make a snapshot of the graph and to restrore to it later.
+    ///
+    ///The newly added nodes and edges can be removed using the
+    ///restore() function.
+    ///
+    ///\warning Edge and node deletions cannot be restored.
+    ///\warning SnapShots cannot be nested.
+    ///\ingroup graphs
+    class SnapShot : public AlterationObserverRegistry<Node>::ObserverBase,
+                     public AlterationObserverRegistry<Edge>::ObserverBase
+    {
+      protected:
+      
+      ListGraph *g;
+      std::list<Node> added_nodes;
+      std::list<Edge> added_edges;
+      
+      bool active;
+      virtual void add(const Node& n) {
+        added_nodes.push_back(n);
+      };
+      ///\bug Exception...
+      ///
+      virtual void erase(const Node&) 
+      {
+        exit(1);
+      }
+      virtual void add(const Edge& n) {
+        added_edges.push_back(n);
+      };
+      ///\bug Exception...
+      ///
+      virtual void erase(const Edge&) 
+      {
+        exit(1);
+      }
+
+      void regist(ListGraph &_g) {
+        g=&_g;
+        AlterationObserverRegistry<Node>::ObserverBase::
+          attach(g->node_observers);
+        AlterationObserverRegistry<Edge>::ObserverBase::
+          attach(g->edge_observers);
+      }
+            
+      void deregist() {
+        AlterationObserverRegistry<Node>::ObserverBase::
+          detach();
+        AlterationObserverRegistry<Edge>::ObserverBase::
+          detach();
+        g=0;
+      }
+            
+    public:
+      ///Default constructur.
+      
+      ///Default constructur.
+      ///To actually make a snapshot you must call save().
+      ///
+      SnapShot() : g(0) {}
+      ///Constructor that immediately makes a snapshot.
+      
+      ///This constructor immediately makes a snapshot of the graph.
+      ///\param _g The graph we make a snapshot of.
+      SnapShot(ListGraph &_g) {
+        regist(_g);
+      }
+      ///\bug Is it necessary?
+      ///
+      ~SnapShot() 
+      {
+        if(g) deregist();
+      }
+      
+      ///Make a snapshot.
+
+      ///Make a snapshot of the graph.
+      ///
+      ///This function can be called more than once. In case of a repeated
+      ///call, the previous snapshot gets lost.
+      ///\param _g The graph we make the snapshot of.
+      void save(ListGraph &_g) 
+      {
+        if(g!=&_g) {
+          if(g) deregist();
+          regist(_g);
+        }
+        added_nodes.clear();
+        added_edges.clear();
+      }
+      
+    ///Undo the changes until the last snapshot.
+
+    ///Undo the changes until last snapshot created by save().
+    ///
+    ///\todo This function might be called undo().
+      void restore() {
+        deregist();
+        while(!added_edges.empty()) {
+          g->erase(added_edges.front());
+          added_edges.pop_front();
+        }
+        while(!added_nodes.empty()) {
+          g->erase(added_nodes.front());
+          added_nodes.pop_front();
+        }
+      }
+    };
+    
   };