Changeset 1842:8abf74160dc4 in lemon-0.x for lemon/bits

Timestamp:

12/01/05 16:08:46 (18 years ago)

Author:

Balazs Dezso

Branch:

default

Phase:

public

Convert:

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

Message:

NewEdgeSetAdaptor? -> ListEdgeSet?
and moved to edge_set.h

Location:

lemon/bits

Files:

• alteration_notifier.h (modified) (2 diffs)
• clearable_graph_extender.h (modified) (2 diffs)
• default_map.h (modified) (2 diffs)
• erasable_graph_extender.h (modified) (2 diffs)
• extendable_graph_extender.h (modified) (2 diffs)

lemon/bits/alteration_notifier.h

@@ -399 +399 @@
   };
 
+
+  template <typename _Base> 
+  class AlterableEdgeSetExtender : public _Base {
+  public:
+
+    typedef AlterableEdgeSetExtender Graph;
+    typedef _Base Parent;
+
+    typedef typename Parent::Edge Edge;
+
+    /// The edge observer registry.
+    typedef AlterationNotifier<Edge> EdgeNotifier;
+
+  protected:
+
+    mutable EdgeNotifier edge_notifier;
+
+  public:
+
+    /// \brief Gives back the edge alteration notifier.
+    ///
+    /// Gives back the edge alteration notifier.
+    EdgeNotifier& getNotifier(Edge) const {
+      return edge_notifier;
+    }
+
+    ~AlterableEdgeSetExtender() {
+      edge_notifier.clear();
+    }
+    
+  };
+
   /// \brief Class to extend an undirected graph with the functionality of
   /// alteration observing.
@@ -438 +470 @@
     }
   };
+
+  template <typename _Base> 
+  class AlterableUndirEdgeSetExtender
+    : public AlterableEdgeSetExtender<_Base> {
+  public:
+
+    typedef AlterableUndirEdgeSetExtender Graph;
+    typedef AlterableEdgeSetExtender<_Base> Parent;
+
+    typedef typename Parent::UndirEdge UndirEdge;
+
+    typedef AlterationNotifier<UndirEdge> UndirEdgeNotifier;
+
+  protected:
+
+    mutable UndirEdgeNotifier undir_edge_notifier;
+
+  public:
+
+    using Parent::getNotifier;
+    UndirEdgeNotifier& getNotifier(UndirEdge) const {
+      return undir_edge_notifier;
+    }
+
+    ~AlterableUndirEdgeSetExtender() {
+      undir_edge_notifier.clear();
+    }
+  };
+
 
 

lemon/bits/clearable_graph_extender.h

@@ -27 +27 @@
 
   template <typename _Base> 
+  class ClearableEdgeSetExtender : public _Base {
+  public:
+
+    typedef ClearableEdgeSetExtender Graph;
+    typedef _Base Parent;
+    typedef typename Parent::Node Node;
+    typedef typename Parent::Edge Edge;
+
+    void clear() {
+      Parent::getNotifier(Edge()).clear();
+      Parent::clear();
+    }
+
+  };
+
+  template <typename _Base> 
   class ClearableUndirGraphExtender : public _Base {
   public:
@@ -38 +54 @@
     void clear() {
       Parent::getNotifier(Node()).clear();
+      Parent::getNotifier(UndirEdge()).clear();
+      Parent::getNotifier(Edge()).clear();
+      Parent::clear();
+    }
+  };
+
+  template <typename _Base> 
+  class ClearableUndirEdgeSetExtender : public _Base {
+  public:
+
+    typedef ClearableUndirEdgeSetExtender Graph;
+    typedef _Base Parent;
+    typedef typename Parent::Node Node;
+    typedef typename Parent::UndirEdge UndirEdge;
+    typedef typename Parent::Edge Edge;
+
+    void clear() {
       Parent::getNotifier(UndirEdge()).clear();
       Parent::getNotifier(Edge()).clear();

lemon/bits/default_map.h

@@ -226 +226 @@
   /// \e
   template <typename _Base> 
+  class MappableEdgeSetExtender : public _Base {
+  public:
+
+    typedef MappableEdgeSetExtender<_Base> Graph;
+    typedef _Base Parent;
+
+    typedef typename Parent::Edge Edge;
+    typedef typename Parent::EdgeIt EdgeIt;
+
+    template <typename _Value>
+    class EdgeMap 
+      : public IterableMapExtender<DefaultMap<Graph, Edge, _Value> > {
+    public:
+      typedef MappableEdgeSetExtender Graph;
+      typedef IterableMapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
+
+      EdgeMap(const Graph& _g) 
+        : Parent(_g) {}
+      EdgeMap(const Graph& _g, const _Value& _v) 
+        : Parent(_g, _v) {}
+
+      EdgeMap& operator=(const EdgeMap& cmap) {
+        return operator=<EdgeMap>(cmap);
+      }
+
+      template <typename CMap>
+      EdgeMap& operator=(const CMap& cmap) {
+        checkConcept<concept::ReadMap<Edge, _Value>, CMap>();
+        const typename Parent::Graph* graph = Parent::getGraph();
+        Edge it;
+        for (graph->first(it); it != INVALID; graph->next(it)) {
+          Parent::set(it, cmap[it]);
+        }
+        return *this;
+      }
+    };
+    
+  };
+
+  /// \e
+  template <typename _Base> 
   class MappableUndirGraphExtender : 
     public MappableGraphExtender<_Base> {
@@ -240 +281 @@
     public:
       typedef MappableUndirGraphExtender Graph;
+      typedef IterableMapExtender<
+        DefaultMap<Graph, UndirEdge, _Value> > Parent;
+
+      UndirEdgeMap(const Graph& _g) 
+        : Parent(_g) {}
+      UndirEdgeMap(const Graph& _g, const _Value& _v) 
+        : Parent(_g, _v) {}
+
+      UndirEdgeMap& operator=(const UndirEdgeMap& cmap) {
+        return operator=<UndirEdgeMap>(cmap);
+      }
+
+      template <typename CMap>
+      UndirEdgeMap& operator=(const CMap& cmap) {
+        checkConcept<concept::ReadMap<UndirEdge, _Value>, CMap>();
+        const typename Parent::Graph* graph = Parent::getGraph();
+        UndirEdge it;
+        for (graph->first(it); it != INVALID; graph->next(it)) {
+          Parent::set(it, cmap[it]);
+        }
+        return *this;
+      }
+    };
+
+
+  };
+
+  /// \e
+  template <typename _Base> 
+  class MappableUndirEdgeSetExtender : 
+    public MappableEdgeSetExtender<_Base> {
+  public:
+
+    typedef MappableUndirEdgeSetExtender Graph;
+    typedef MappableEdgeSetExtender<_Base> Parent;
+
+    typedef typename Parent::UndirEdge UndirEdge;
+
+    template <typename _Value>
+    class UndirEdgeMap 
+      : public IterableMapExtender<DefaultMap<Graph, UndirEdge, _Value> > {
+    public:
+      typedef MappableUndirEdgeSetExtender Graph;
       typedef IterableMapExtender<
         DefaultMap<Graph, UndirEdge, _Value> > Parent;

lemon/bits/erasable_graph_extender.h

@@ -47 +47 @@
 
   template <typename _Base> 
+  class ErasableEdgeSetExtender : public _Base {
+  public:
+
+    typedef ErasableEdgeSetExtender Graph;
+    typedef _Base Parent;
+
+    typedef typename Parent::Edge Edge;
+
+    void erase(const Edge& edge) {
+      Parent::getNotifier(Edge()).erase(edge);
+      Parent::erase(edge);
+    }
+
+  };
+
+  template <typename _Base> 
   class ErasableUndirGraphExtender : public _Base {
   public:
@@ -80 +96 @@
   };
 
+  template <typename _Base> 
+  class ErasableUndirEdgeSetExtender : public _Base {
+  public:
+
+    typedef ErasableUndirEdgeSetExtender Graph;
+    typedef _Base Parent;
+
+    typedef typename Parent::Node Node;
+    typedef typename Parent::UndirEdge UndirEdge;
+    typedef typename Parent::Edge Edge;
+
+    void erase(const UndirEdge& uedge) {
+      std::vector<Edge> edges;
+      edges.push_back(Parent::direct(uedge,true));
+      edges.push_back(Parent::direct(uedge,false));
+      Parent::getNotifier(Edge()).erase(edges);
+      Parent::getNotifier(UndirEdge()).erase(uedge);
+      Parent::erase(uedge);
+    }
+
+  };
+
 }
 

lemon/bits/extendable_graph_extender.h

@@ -31 +31 @@
 
   template <typename _Base> 
+  class ExtendableEdgeSetExtender : public _Base {
+  public:
+
+    typedef ExtendableEdgeSetExtender Graph;
+    typedef _Base Parent;
+
+    typedef typename Parent::Edge Edge;
+    typedef typename Parent::Node Node;
+
+    Edge addEdge(const Node& from, const Node& to) {
+      Edge edge = Parent::addEdge(from, to);
+      Parent::getNotifier(Edge()).add(edge);
+      return edge;
+    }
+
+  };
+
+  template <typename _Base> 
   class ExtendableUndirGraphExtender : public _Base {
   public:
@@ -46 +64 @@
       return node;
     }
+
+    UndirEdge addEdge(const Node& from, const Node& to) {
+      UndirEdge uedge = Parent::addEdge(from, to);
+      Parent::getNotifier(UndirEdge()).add(uedge);
+
+      std::vector<Edge> edges;
+      edges.push_back(Parent::direct(uedge, true));
+      edges.push_back(Parent::direct(uedge, false));
+      Parent::getNotifier(Edge()).add(edges);
+
+      return uedge;
+    }
+
+  };
+
+  template <typename _Base> 
+  class ExtendableUndirEdgeSetExtender : public _Base {
+  public:
+
+    typedef ExtendableUndirEdgeSetExtender Graph;
+    typedef _Base Parent;
+
+    typedef typename Parent::Node Node;
+    typedef typename Parent::Edge Edge;
+    typedef typename Parent::UndirEdge UndirEdge;
 
     UndirEdge addEdge(const Node& from, const Node& to) {