Changeset 1980:a954b780e3ab in lemon-0.x

Timestamp:

02/23/06 09:55:54 (18 years ago)

Author:

Balazs Dezso

Branch:

default

Phase:

public

Convert:

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

Message:

Renaming to be convient to the naming of the adaptors
Concept checking of the ugraph adaptors

Files:

• lemon/concept/ugraph.h (modified) (1 diff)
• lemon/graph_adaptor.h (modified) (6 diffs)
• lemon/ugraph_adaptor.h (modified) (10 diffs)
• test/graph_adaptor_test.cc (modified) (2 diffs)

lemon/concept/ugraph.h

@@ -865 +865 @@
 
 
+      void firstInc(UEdge &, bool &, const Node &) const {}
+
+      void nextInc(UEdge &, bool &) const {}
+
       /// \brief Base node of the iterator
       ///

lemon/graph_adaptor.h

@@ -699 +699 @@
 
   template <typename _Graph>
-  class UndirectGraphAdaptorBase : 
+  class UndirGraphAdaptorBase : 
     public UGraphBaseExtender<GraphAdaptorBase<_Graph> > {
   public:
@@ -705 +705 @@
     typedef UGraphBaseExtender<GraphAdaptorBase<_Graph> > Parent;
   protected:
-    UndirectGraphAdaptorBase() : Parent() { }
+    UndirGraphAdaptorBase() : Parent() { }
   public:
     typedef typename Parent::UEdge UEdge;
@@ -713 +713 @@
     class EdgeMap {
     protected:
-      const UndirectGraphAdaptorBase<_Graph>* g;
+      const UndirGraphAdaptorBase<_Graph>* g;
       template <typename TT> friend class EdgeMap;
       typename _Graph::template EdgeMap<T> forward_map, backward_map; 
@@ -720 +720 @@
       typedef Edge Key;
       
-      EdgeMap(const UndirectGraphAdaptorBase<_Graph>& _g) : g(&_g), 
+      EdgeMap(const UndirGraphAdaptorBase<_Graph>& _g) : g(&_g), 
         forward_map(*(g->graph)), backward_map(*(g->graph)) { }
 
-      EdgeMap(const UndirectGraphAdaptorBase<_Graph>& _g, T a) : g(&_g), 
+      EdgeMap(const UndirGraphAdaptorBase<_Graph>& _g, T a) : g(&_g), 
         forward_map(*(g->graph), a), backward_map(*(g->graph), a) { }
       
@@ -749 +749 @@
       typedef UEdge Key;
       
-      UEdgeMap(const UndirectGraphAdaptorBase<_Graph>& g) : 
+      UEdgeMap(const UndirGraphAdaptorBase<_Graph>& g) : 
         map(*(g.graph)) { }
 
-      UEdgeMap(const UndirectGraphAdaptorBase<_Graph>& g, T a) : 
+      UEdgeMap(const UndirGraphAdaptorBase<_Graph>& g, T a) : 
         map(*(g.graph), a) { }
       
@@ -774 +774 @@
   /// \author Marton Makai
   template<typename _Graph>
-  class UndirectGraphAdaptor : 
+  class UndirGraphAdaptor : 
     public UGraphAdaptorExtender<
-    UndirectGraphAdaptorBase<_Graph> > {
+    UndirGraphAdaptorBase<_Graph> > {
   public:
     typedef _Graph Graph;
     typedef UGraphAdaptorExtender<
-      UndirectGraphAdaptorBase<_Graph> > Parent;
+      UndirGraphAdaptorBase<_Graph> > Parent;
   protected:
-    UndirectGraphAdaptor() { }
-  public:
-    UndirectGraphAdaptor(_Graph& _graph) { 
+    UndirGraphAdaptor() { }
+  public:
+    UndirGraphAdaptor(_Graph& _graph) { 
       setGraph(_graph);
     }

lemon/ugraph_adaptor.h

@@ -512 +512 @@
   /// graph.
   /// 
-  /// \warning Graph adaptors are in even more experimental state than the
-  /// other parts of the lib. Use them at you own risk.
-  /// 
   /// SubUGraphAdaptor shows the undirected graph with filtered node-set and 
   /// edge-set. If the \c checked parameter is true then it filters the edgeset
@@ -529 +526 @@
   /// \c Graph::Node that is why \c g.id(n) can be applied.
   /// 
-  /// For examples see also the documentation of NodeSubUGraphAdaptor and 
-  /// EdgeSubUGraphAdaptor.
-  /// 
-  /// \author Marton Makai
-
   template<typename _UGraph, typename NodeFilterMap, 
            typename UEdgeFilterMap, bool checked = true>
@@ -554 +546 @@
   };
 
+  template<typename UGraph, typename NodeFilterMap, typename EdgeFilterMap>
+  SubUGraphAdaptor<const UGraph, NodeFilterMap, EdgeFilterMap>
+  subUGraphAdaptor(const UGraph& graph, 
+                   NodeFilterMap& nfm, EdgeFilterMap& efm) {
+    return SubUGraphAdaptor<const UGraph, NodeFilterMap, EdgeFilterMap>
+      (graph, nfm, efm);
+  }
+
+  template<typename UGraph, typename NodeFilterMap, typename EdgeFilterMap>
+  SubUGraphAdaptor<const UGraph, const NodeFilterMap, EdgeFilterMap>
+  subUGraphAdaptor(const UGraph& graph, 
+                   NodeFilterMap& nfm, EdgeFilterMap& efm) {
+    return SubUGraphAdaptor<const UGraph, const NodeFilterMap, EdgeFilterMap>
+      (graph, nfm, efm);
+  }
+
+  template<typename UGraph, typename NodeFilterMap, typename EdgeFilterMap>
+  SubUGraphAdaptor<const UGraph, NodeFilterMap, const EdgeFilterMap>
+  subUGraphAdaptor(const UGraph& graph, 
+                   NodeFilterMap& nfm, EdgeFilterMap& efm) {
+    return SubUGraphAdaptor<const UGraph, NodeFilterMap, const EdgeFilterMap>
+      (graph, nfm, efm);
+  }
+
+  template<typename UGraph, typename NodeFilterMap, typename EdgeFilterMap>
+  SubUGraphAdaptor<const UGraph, const NodeFilterMap, const EdgeFilterMap>
+  subUGraphAdaptor(const UGraph& graph, 
+                   NodeFilterMap& nfm, EdgeFilterMap& efm) {
+    return SubUGraphAdaptor<const UGraph, const NodeFilterMap, 
+      const EdgeFilterMap>(graph, nfm, efm);
+  }
+
   /// \ingroup graph_adaptors
   ///
-  /// \brief An adaptor for hiding nodes from an undorected graph.
-  ///
-  /// \warning Graph adaptors are in even more experimental state
-  /// than the other
-  /// parts of the lib. Use them at you own risk.
+  /// \brief An adaptor for hiding nodes from an undirected graph.
+  ///
   ///
   /// An adaptor for hiding nodes from an undirected graph.
@@ -568 +589 @@
   /// induced subgraph. But if the checked parameter is false then we can only
   /// filter only isolated nodes.
-  /// \author Marton Makai
   template<typename _UGraph, typename NodeFilterMap, bool checked = true>
   class NodeSubUGraphAdaptor : 
@@ -610 +630 @@
   /// only the edge-set 
   /// can be filtered.
-  ///
-  ///\author Marton Makai
   template<typename _UGraph, typename UEdgeFilterMap>
   class EdgeSubUGraphAdaptor : 
@@ -644 +662 @@
 
   template <typename _UGraph, typename _DirectionMap>
-  class DirectUGraphAdaptorBase {
+  class DirUGraphAdaptorBase {
   public:
     
@@ -737 +755 @@
     public:
       typedef typename _UGraph::template NodeMap<_Value> Parent;
-      explicit NodeMap(const DirectUGraphAdaptorBase& ga) 
+      explicit NodeMap(const DirUGraphAdaptorBase& ga) 
         : Parent(*ga.graph) { }
-      NodeMap(const DirectUGraphAdaptorBase& ga, const _Value& value)
+      NodeMap(const DirUGraphAdaptorBase& ga, const _Value& value)
         : Parent(*ga.graph, value) { }
     };
@@ -746 +764 @@
     class EdgeMap : public _UGraph::template UEdgeMap<_Value> {
     public:
-      typedef typename _UGraph::template EdgeMap<_Value> Parent;
-      explicit EdgeMap(const DirectUGraphAdaptorBase& ga) 
+      typedef typename _UGraph::template UEdgeMap<_Value> Parent;
+      explicit EdgeMap(const DirUGraphAdaptorBase& ga) 
         : Parent(*ga.graph) { }
-      EdgeMap(const DirectUGraphAdaptorBase& ga, const _Value& value)
+      EdgeMap(const DirUGraphAdaptorBase& ga, const _Value& value)
         : Parent(*ga.graph, value) { }
     };
@@ -770 +788 @@
 
 
-  template<typename _Graph, typename DirectionMap> 
-  class DirectUGraphAdaptor : 
+  /// \ingroup graph_adaptors
+  /// \brief A directed graph is made from a undirected graph by an adaptor
+  ///
+  /// This adaptor gives a direction for each uedge in the undirected graph.
+  /// The direction of the edges stored in the DirectionMap. This map is
+  /// a bool map on the undirected edges. If the uedge is mapped to true
+  /// then the direction of the directed edge will be the same as the
+  /// default direction of the uedge. The edges can be easily reverted
+  /// by the reverseEdge member in the adaptor.  
+  template<typename _Graph, 
+           typename DirectionMap = typename _Graph::template UEdgeMap<bool> > 
+  class DirUGraphAdaptor : 
     public GraphAdaptorExtender<
-    DirectUGraphAdaptorBase<_Graph, DirectionMap> > {
+    DirUGraphAdaptorBase<_Graph, DirectionMap> > {
   public:
     typedef _Graph Graph;
     typedef GraphAdaptorExtender<
-      DirectUGraphAdaptorBase<_Graph, DirectionMap> > Parent;
+      DirUGraphAdaptorBase<_Graph, DirectionMap> > Parent;
   protected:
-    DirectUGraphAdaptor() { }
-  public:
-    DirectUGraphAdaptor(_Graph& _graph, DirectionMap& _direction_map) { 
+    DirUGraphAdaptor() { }
+  public:
+    DirUGraphAdaptor(_Graph& _graph, DirectionMap& _direction_map) { 
       setGraph(_graph);
       setDirectionMap(_direction_map);
@@ -788 +816 @@
 
   template<typename UGraph, typename DirectionMap>
-  DirectUGraphAdaptor<const UGraph, DirectionMap>
-  directUGraphAdaptor(const UGraph& graph, DirectionMap& dm) {
-    return DirectUGraphAdaptor<const UGraph, DirectionMap>(graph, dm);
+  DirUGraphAdaptor<const UGraph, DirectionMap>
+  dirUGraphAdaptor(const UGraph& graph, DirectionMap& dm) {
+    return DirUGraphAdaptor<const UGraph, DirectionMap>(graph, dm);
   }
 
   template<typename UGraph, typename DirectionMap>
-  DirectUGraphAdaptor<const UGraph, const DirectionMap>
-  directUGraphAdaptor(const UGraph& graph, const DirectionMap& dm) {
-    return DirectUGraphAdaptor<const UGraph, const DirectionMap>(graph, dm);
+  DirUGraphAdaptor<const UGraph, const DirectionMap>
+  dirUGraphAdaptor(const UGraph& graph, const DirectionMap& dm) {
+    return DirUGraphAdaptor<const UGraph, const DirectionMap>(graph, dm);
   }
 

test/graph_adaptor_test.cc

@@ -27 +27 @@
 #include<lemon/full_graph.h>
 #include<lemon/graph_adaptor.h>
+#include<lemon/ugraph_adaptor.h>
 
 #include"test/test_tools.h"
@@ -67 +68 @@
       Graph::NodeMap<Graph::Edge> > >(); 
 
-    /// \bug why does not compile with StaticGraph
-    checkConcept<UGraph, UndirectGraphAdaptor<ListGraph> >();
+    checkConcept<UGraph, UndirGraphAdaptor<Graph> >();
+
+    checkConcept<UGraph, SubUGraphAdaptor<UGraph, 
+      UGraph::NodeMap<bool> , UGraph::UEdgeMap<bool> > >();
+    checkConcept<UGraph, NodeSubUGraphAdaptor<UGraph, 
+      UGraph::NodeMap<bool> > >();
+    checkConcept<UGraph, EdgeSubUGraphAdaptor<UGraph, 
+      UGraph::UEdgeMap<bool> > >();
+
+    checkConcept<StaticGraph, DirUGraphAdaptor<UGraph, 
+      UGraph::UEdgeMap<bool> > >();
   }
   std::cout << __FILE__ ": All tests passed.\n";