LEMON/LEMON-official Changeset - r664:4137ef9aacc6

Repositories » LEMON » LEMON-official

Summary
Changelog
Files
Switch To
- loading...
Options
- Lightweight changelog
- Search
Pull Requests

Changeset - r664:4137ef9aacc6

« 663:f2d6d3

665:b95898 »

r664:4137ef9aacc6

Fri, 24 Apr 2009 11:54:48

[Not Reviewed]

0 comments (0 inline)

kpeter (Peter Kovacs)
kpeter@inf.elte.hu

Fix and uniform the usage of Graph and Parent typedefs (#268) - Rename Graph typedefs to GraphType in the implementation of graph maps and MapExtender to prevent conflicts (especially using VS). They are not public. - Make Parent typedefs private in all classes. - Replace Digraph with Graph in some places (fix faulty renamings of the script). - Use Graph and Digraph typedefs (more) consequently.

0 19 0

default

19 files changed with 298 insertions and 277 deletions:

lemon/adaptors.h

lemon/bits/array_map.h

lemon/bits/base_extender.h

lemon/bits/default_map.h

lemon/bits/edge_set_extender.h

lemon/bits/graph_adaptor_extender.h

lemon/bits/graph_extender.h

lemon/bits/map_extender.h

lemon/bits/vector_map.h

lemon/concepts/graph_components.h

lemon/core.h

lemon/edge_set.h

lemon/full_graph.h

lemon/graph_to_eps.h

lemon/grid_graph.h

lemon/hypercube_graph.h

lemon/list_graph.h

lemon/maps.h

lemon/smart_graph.h

↑ Collapse diff ↑

lemon/adaptors.h

Show inline comments

@@ -106,19 +106,17 @@
 		    typedef typename ItemSetTraits<DGR, Arc>::ItemNotifier ArcNotifier;
 		    ArcNotifier& notifier(Arc) const { return _digraph->notifier(Arc()); }
 		    template <typename V>
 		    class NodeMap : public DGR::template NodeMap<V> {
 		      typedef typename DGR::template NodeMap<V> Parent;
 		    public:
 		      typedef typename DGR::template NodeMap<V> Parent;
 		      explicit NodeMap(const Adaptor& adaptor)
 		        : Parent(*adaptor._digraph) {}
 		      NodeMap(const Adaptor& adaptor, const V& value)
 		        : Parent(*adaptor._digraph, value) { }
 		    private:
 		      NodeMap& operator=(const NodeMap& cmap) {
 		        return operator=<NodeMap>(cmap);
@@ -131,19 +129,17 @@
+		      }
 		    };
 		    template <typename V>
 		    class ArcMap : public DGR::template ArcMap<V> {
 		      typedef typename DGR::template ArcMap<V> Parent;
 		    public:
 		      typedef typename DGR::template ArcMap<V> Parent;
 		      explicit ArcMap(const DigraphAdaptorBase<DGR>& adaptor)
 		        : Parent(*adaptor._digraph) {}
 		      ArcMap(const DigraphAdaptorBase<DGR>& adaptor, const V& value)
 		        : Parent(*adaptor._digraph, value) {}
 		    private:
 		      ArcMap& operator=(const ArcMap& cmap) {
 		        return operator=<ArcMap>(cmap);
@@ -252,14 +248,15 @@
 		    typedef typename ItemSetTraits<GR, Edge>::ItemNotifier EdgeNotifier;
 		    EdgeNotifier& notifier(Edge) const { return _graph->notifier(Edge()); }
 		    template <typename V>
 		    class NodeMap : public GR::template NodeMap<V> {
 		      typedef typename GR::template NodeMap<V> Parent;
 		    public:
 		      typedef typename GR::template NodeMap<V> Parent;
 		      explicit NodeMap(const GraphAdaptorBase<GR>& adapter)
 		        : Parent(*adapter._graph) {}
 		      NodeMap(const GraphAdaptorBase<GR>& adapter, const V& value)
 		        : Parent(*adapter._graph, value) {}
 		    private:
@@ -274,14 +271,15 @@
+		      }
 		    };
 		    template <typename V>
 		    class ArcMap : public GR::template ArcMap<V> {
 		      typedef typename GR::template ArcMap<V> Parent;
 		    public:
 		      typedef typename GR::template ArcMap<V> Parent;
 		      explicit ArcMap(const GraphAdaptorBase<GR>& adapter)
 		        : Parent(*adapter._graph) {}
 		      ArcMap(const GraphAdaptorBase<GR>& adapter, const V& value)
 		        : Parent(*adapter._graph, value) {}
 		    private:
@@ -295,14 +293,15 @@
 		        return *this;
+		      }
 		    };
 		    template <typename V>
 		    class EdgeMap : public GR::template EdgeMap<V> {
 		      typedef typename GR::template EdgeMap<V> Parent;
 		    public:
 		      typedef typename GR::template EdgeMap<V> Parent;
 		      explicit EdgeMap(const GraphAdaptorBase<GR>& adapter)
 		        : Parent(*adapter._graph) {}
 		      EdgeMap(const GraphAdaptorBase<GR>& adapter, const V& value)
 		        : Parent(*adapter._graph, value) {}
 		    private:
@@ -318,15 +317,15 @@
 		    };
 		  };
 		  template <typename DGR>
 		  class ReverseDigraphBase : public DigraphAdaptorBase<DGR> {
 		    typedef DigraphAdaptorBase<DGR> Parent;
 		  public:
 		    typedef DGR Digraph;
 		    typedef DigraphAdaptorBase<DGR> Parent;
 		  protected:
 		    ReverseDigraphBase() : Parent() { }
 		  public:
 		    typedef typename Parent::Node Node;
 		    typedef typename Parent::Arc Arc;
@@ -371,16 +370,16 @@
 		#ifdef DOXYGEN
 		  class ReverseDigraph {
 		#else
 		  class ReverseDigraph :
 		    public DigraphAdaptorExtender<ReverseDigraphBase<DGR> > {
 		#endif
 		    typedef DigraphAdaptorExtender<ReverseDigraphBase<DGR> > Parent;
 		  public:
 		    /// The type of the adapted digraph.
 		    typedef DGR Digraph;
 		    typedef DigraphAdaptorExtender<ReverseDigraphBase<DGR> > Parent;
 		  protected:
 		    ReverseDigraph() { }
 		  public:
 		    /// \brief Constructor
 		    ///
@@ -400,19 +399,19 @@
 		    return ReverseDigraph<const DGR>(digraph);
+		  }
 		  template <typename DGR, typename NF, typename AF, bool ch = true>
 		  class SubDigraphBase : public DigraphAdaptorBase<DGR> {
 		    typedef DigraphAdaptorBase<DGR> Parent;
 		  public:
 		    typedef DGR Digraph;
 		    typedef NF NodeFilterMap;
 		    typedef AF ArcFilterMap;
 		    typedef SubDigraphBase Adaptor;
 		    typedef DigraphAdaptorBase<DGR> Parent;
 		  protected:
 		    NF* _node_filter;
 		    AF* _arc_filter;
 		    SubDigraphBase()
 		      : Parent(), _node_filter(0), _arc_filter(0) { }
@@ -506,16 +505,17 @@
 		  public:
 		    template <typename V>
 		    class NodeMap
 		      : public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
 			      LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {
 		      typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
 			LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
 		    public:
 		      typedef V Value;
 		      typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
 			    LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
 		      NodeMap(const SubDigraphBase<DGR, NF, AF, ch>& adaptor)
 		        : Parent(adaptor) {}
 		      NodeMap(const SubDigraphBase<DGR, NF, AF, ch>& adaptor, const V& value)
 		        : Parent(adaptor, value) {}
@@ -532,16 +532,17 @@
 		    };
 		    template <typename V>
 		    class ArcMap
 		      : public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
 			      LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
 		      typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
 		        LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> Parent;
 		    public:
 		      typedef V Value;
 		      typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
 		        LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> Parent;
 		      ArcMap(const SubDigraphBase<DGR, NF, AF, ch>& adaptor)
 		        : Parent(adaptor) {}
 		      ArcMap(const SubDigraphBase<DGR, NF, AF, ch>& adaptor, const V& value)
 		        : Parent(adaptor, value) {}
@@ -559,19 +560,19 @@
 		  };
 		  template <typename DGR, typename NF, typename AF>
 		  class SubDigraphBase<DGR, NF, AF, false>
 		    : public DigraphAdaptorBase<DGR> {
 		    typedef DigraphAdaptorBase<DGR> Parent;
 		  public:
 		    typedef DGR Digraph;
 		    typedef NF NodeFilterMap;
 		    typedef AF ArcFilterMap;
 		    typedef SubDigraphBase Adaptor;
 		    typedef DigraphAdaptorBase<Digraph> Parent;
 		  protected:
 		    NF* _node_filter;
 		    AF* _arc_filter;
 		    SubDigraphBase()
 		      : Parent(), _node_filter(0), _arc_filter(0) { }
@@ -647,16 +648,17 @@
+		    }
 		    template <typename V>
 		    class NodeMap
 		      : public SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
 		          LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {
 		      typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
 		        LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
 		    public:
 		      typedef V Value;
 		      typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
 		        LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
 		      NodeMap(const SubDigraphBase<DGR, NF, AF, false>& adaptor)
 		        : Parent(adaptor) {}
 		      NodeMap(const SubDigraphBase<DGR, NF, AF, false>& adaptor, const V& value)
 		        : Parent(adaptor, value) {}
@@ -673,16 +675,17 @@
 		    };
 		    template <typename V>
 		    class ArcMap
 		      : public SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
 		          LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
 		      typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
 		        LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> Parent;
 		    public:
 		      typedef V Value;
 		      typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
 		          LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> Parent;
 		      ArcMap(const SubDigraphBase<DGR, NF, AF, false>& adaptor)
 		        : Parent(adaptor) {}
 		      ArcMap(const SubDigraphBase<DGR, NF, AF, false>& adaptor, const V& value)
 		        : Parent(adaptor, value) {}
@@ -860,19 +863,19 @@
 		      (digraph, node_filter, arc_filter);
+		  }
 		  template <typename GR, typename NF, typename EF, bool ch = true>
 		  class SubGraphBase : public GraphAdaptorBase<GR> {
 		    typedef GraphAdaptorBase<GR> Parent;
 		  public:
 		    typedef GR Graph;
 		    typedef NF NodeFilterMap;
 		    typedef EF EdgeFilterMap;
 		    typedef SubGraphBase Adaptor;
 		    typedef GraphAdaptorBase<GR> Parent;
 		  protected:
 		    NF* _node_filter;
 		    EF* _edge_filter;
 		    SubGraphBase()
@@ -1013,16 +1016,17 @@
+		    }
 		    template <typename V>
 		    class NodeMap
 		      : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
 		          LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> {
 		      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
 		        LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> Parent;
 		    public:
 		      typedef V Value;
 		      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
 		        LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> Parent;
 		      NodeMap(const SubGraphBase<GR, NF, EF, ch>& adaptor)
 		        : Parent(adaptor) {}
 		      NodeMap(const SubGraphBase<GR, NF, EF, ch>& adaptor, const V& value)
 		        : Parent(adaptor, value) {}
@@ -1039,16 +1043,17 @@
 		    };
 		    template <typename V>
 		    class ArcMap
 		      : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
 		          LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> {
 		      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
 		        LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> Parent;
 		    public:
 		      typedef V Value;
 		      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
 		        LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> Parent;
 		      ArcMap(const SubGraphBase<GR, NF, EF, ch>& adaptor)
 		        : Parent(adaptor) {}
 		      ArcMap(const SubGraphBase<GR, NF, EF, ch>& adaptor, const V& value)
 		        : Parent(adaptor, value) {}
@@ -1065,16 +1070,17 @@
 		    };
 		    template <typename V>
 		    class EdgeMap
 		      : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
 		        LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> {
 		      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
 		        LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
 		    public:
 		      typedef V Value;
 		      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
 		        LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
 		      EdgeMap(const SubGraphBase<GR, NF, EF, ch>& adaptor)
 		        : Parent(adaptor) {}
 		      EdgeMap(const SubGraphBase<GR, NF, EF, ch>& adaptor, const V& value)
 		        : Parent(adaptor, value) {}
@@ -1093,19 +1099,19 @@
 		  };
 		  template <typename GR, typename NF, typename EF>
 		  class SubGraphBase<GR, NF, EF, false>
 		    : public GraphAdaptorBase<GR> {
 		    typedef GraphAdaptorBase<GR> Parent;
 		  public:
 		    typedef GR Graph;
 		    typedef NF NodeFilterMap;
 		    typedef EF EdgeFilterMap;
 		    typedef SubGraphBase Adaptor;
 		    typedef GraphAdaptorBase<GR> Parent;
 		  protected:
 		    NF* _node_filter;
 		    EF* _edge_filter;
 		    SubGraphBase()
 			  : Parent(), _node_filter(0), _edge_filter(0) { }
@@ -1208,16 +1214,17 @@
+		    }
 		    template <typename V>
 		    class NodeMap
 		      : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
 		          LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> {
 		      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
 		        LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> Parent;
 		    public:
 		      typedef V Value;
 		      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
 		        LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> Parent;
 		      NodeMap(const SubGraphBase<GR, NF, EF, false>& adaptor)
 		        : Parent(adaptor) {}
 		      NodeMap(const SubGraphBase<GR, NF, EF, false>& adaptor, const V& value)
 		        : Parent(adaptor, value) {}
@@ -1234,16 +1241,17 @@
 		    };
 		    template <typename V>
 		    class ArcMap
 		      : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
 		          LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> {
 		      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
 		        LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> Parent;
 		    public:
 		      typedef V Value;
 		      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
 		        LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> Parent;
 		      ArcMap(const SubGraphBase<GR, NF, EF, false>& adaptor)
 		        : Parent(adaptor) {}
 		      ArcMap(const SubGraphBase<GR, NF, EF, false>& adaptor, const V& value)
 		        : Parent(adaptor, value) {}
@@ -1260,16 +1268,17 @@
 		    };
 		    template <typename V>
 		    class EdgeMap
 		      : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
 		        LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> {
 		      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
 			LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
 		    public:
 		      typedef V Value;
 		      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
 				  LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
 		      EdgeMap(const SubGraphBase<GR, NF, EF, false>& adaptor)
 		        : Parent(adaptor) {}
 		      EdgeMap(const SubGraphBase<GR, NF, EF, false>& adaptor, const V& value)
 		        : Parent(adaptor, value) {}
@@ -1482,21 +1491,21 @@
 		           typename Enable = void>
 		  class FilterNodes :
 		    public DigraphAdaptorExtender<
 		      SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, Const<bool, true> >,
 		                     true> > {
 		#endif
 		  public:
 		    typedef GR Digraph;
 		    typedef NF NodeFilterMap;
 		    typedef DigraphAdaptorExtender<
 		      SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, Const<bool, true> >,
 		                     true> > Parent;
 		  public:
 		    typedef GR Digraph;
 		    typedef NF NodeFilterMap;
 		    typedef typename Parent::Node Node;
 		  protected:
 		    ConstMap<typename Digraph::Arc, Const<bool, true> > const_true_map;
 		    FilterNodes() : const_true_map() {}
@@ -1545,20 +1554,23 @@
 		  class FilterNodes<GR, NF,
 		                    typename enable_if<UndirectedTagIndicator<GR> >::type> :
 		    public GraphAdaptorExtender<
 		      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >,
 		                   true> > {
 		  public:
 		    typedef GR Graph;
 		    typedef NF NodeFilterMap;
 		    typedef GraphAdaptorExtender<
 		      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >,
 		                   true> > Parent;
 		  public:
 		    typedef GR Graph;
 		    typedef NF NodeFilterMap;
 		    typedef typename Parent::Node Node;
 		  protected:
 		    ConstMap<typename GR::Edge, Const<bool, true> > const_true_map;
 		    FilterNodes() : const_true_map() {}
 		  public:
@@ -1626,22 +1638,23 @@
 		           typename AF = typename DGR::template ArcMap<bool> >
 		  class FilterArcs :
 		    public DigraphAdaptorExtender<
 		      SubDigraphBase<DGR, ConstMap<typename DGR::Node, Const<bool, true> >,
 		                     AF, false> > {
 		#endif
 		    typedef DigraphAdaptorExtender<
 		      SubDigraphBase<DGR, ConstMap<typename DGR::Node, Const<bool, true> >,
 		                     AF, false> > Parent;
 		  public:
 		    /// The type of the adapted digraph.
 		    typedef DGR Digraph;
 		    /// The type of the arc filter map.
 		    typedef AF ArcFilterMap;
 		    typedef DigraphAdaptorExtender<
 		      SubDigraphBase<DGR, ConstMap<typename DGR::Node, Const<bool, true> >,
 		                     AF, false> > Parent;
 		    typedef typename Parent::Arc Arc;
 		  protected:
 		    ConstMap<typename DGR::Node, Const<bool, true> > const_true_map;
 		    FilterArcs() : const_true_map() {}
@@ -1735,22 +1748,23 @@
 		           typename EF = typename GR::template EdgeMap<bool> >
 		  class FilterEdges :
 		    public GraphAdaptorExtender<
 		      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true> >,
 		                   EF, false> > {
 		#endif
 		    typedef GraphAdaptorExtender<
 		      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true > >,
 		                   EF, false> > Parent;
 		  public:
 		    /// The type of the adapted graph.
 		    typedef GR Graph;
 		    /// The type of the edge filter map.
 		    typedef EF EdgeFilterMap;
 		    typedef GraphAdaptorExtender<
 		      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true > >,
 		                   EF, false> > Parent;
 		    typedef typename Parent::Edge Edge;
 		  protected:
 		    ConstMap<typename GR::Node, Const<bool, true> > const_true_map;
 		    FilterEdges() : const_true_map(true) {
@@ -2108,16 +2122,16 @@
 		    };
 		  public:
 		    template <typename V>
 		    class NodeMap : public DGR::template NodeMap<V> {
 		      typedef typename DGR::template NodeMap<V> Parent;
 		    public:
 		      typedef V Value;
 		      typedef typename DGR::template NodeMap<Value> Parent;
 		      explicit NodeMap(const UndirectorBase<DGR>& adaptor)
 		        : Parent(*adaptor._digraph) {}
 		      NodeMap(const UndirectorBase<DGR>& adaptor, const V& value)
 		        : Parent(*adaptor._digraph, value) { }
@@ -2134,17 +2148,17 @@
+		      }
 		    };
 		    template <typename V>
 		    class ArcMap
 		      : public SubMapExtender<UndirectorBase<DGR>, ArcMapBase<V> >
+		    {
 		      : public SubMapExtender<UndirectorBase<DGR>, ArcMapBase<V> > {
 		      typedef SubMapExtender<UndirectorBase<DGR>, ArcMapBase<V> > Parent;
 		    public:
 		      typedef V Value;
 		      typedef SubMapExtender<Adaptor, ArcMapBase<V> > Parent;
 		      explicit ArcMap(const UndirectorBase<DGR>& adaptor)
 		        : Parent(adaptor) {}
 		      ArcMap(const UndirectorBase<DGR>& adaptor, const V& value)
 		        : Parent(adaptor, value) {}
@@ -2160,16 +2174,16 @@
 		        return *this;
+		      }
 		    };
 		    template <typename V>
 		    class EdgeMap : public Digraph::template ArcMap<V> {
 		      typedef typename Digraph::template ArcMap<V> Parent;
 		    public:
 		      typedef V Value;
 		      typedef typename Digraph::template ArcMap<V> Parent;
 		      explicit EdgeMap(const UndirectorBase<DGR>& adaptor)
 		        : Parent(*adaptor._digraph) {}
 		      EdgeMap(const UndirectorBase<DGR>& adaptor, const V& value)
 		        : Parent(*adaptor._digraph, value) {}
@@ -2235,16 +2249,16 @@
 		#ifdef DOXYGEN
 		  class Undirector {
 		#else
 		  class Undirector :
 		    public GraphAdaptorExtender<UndirectorBase<DGR> > {
 		#endif
 		    typedef GraphAdaptorExtender<UndirectorBase<DGR> > Parent;
 		  public:
 		    /// The type of the adapted digraph.
 		    typedef DGR Digraph;
 		    typedef GraphAdaptorExtender<UndirectorBase<DGR> > Parent;
 		  protected:
 		    Undirector() { }
 		  public:
 		    /// \brief Constructor
 		    ///
@@ -2446,16 +2460,16 @@
 		    typedef typename ItemSetTraits<GR, Arc>::ItemNotifier ArcNotifier;
 		    ArcNotifier& notifier(Arc) const { return _graph->notifier(Arc()); }
 		    template <typename V>
 		    class NodeMap : public GR::template NodeMap<V> {
 		      typedef typename GR::template NodeMap<V> Parent;
 		    public:
 		      typedef typename GR::template NodeMap<V> Parent;
 		      explicit NodeMap(const OrienterBase<GR, DM>& adapter)
 		        : Parent(*adapter._graph) {}
 		      NodeMap(const OrienterBase<GR, DM>& adapter, const V& value)
 		        : Parent(*adapter._graph, value) {}
@@ -2471,16 +2485,16 @@
+		      }
 		    };
 		    template <typename V>
 		    class ArcMap : public GR::template EdgeMap<V> {
 		      typedef typename Graph::template EdgeMap<V> Parent;
 		    public:
 		      typedef typename Graph::template EdgeMap<V> Parent;
 		      explicit ArcMap(const OrienterBase<GR, DM>& adapter)
 		        : Parent(*adapter._graph) { }
 		      ArcMap(const OrienterBase<GR, DM>& adapter, const V& value)
 		        : Parent(*adapter._graph, value) { }
@@ -2543,23 +2557,25 @@
 		#else
 		  template<typename GR,
 		           typename DM = typename GR::template EdgeMap<bool> >
 		  class Orienter :
 		    public DigraphAdaptorExtender<OrienterBase<GR, DM> > {
 		#endif
 		    typedef DigraphAdaptorExtender<OrienterBase<GR, DM> > Parent;
 		  public:
 		    /// The type of the adapted graph.
 		    typedef GR Graph;
 		    /// The type of the direction edge map.
 		    typedef DM DirectionMap;
 		    typedef DigraphAdaptorExtender<OrienterBase<GR, DM> > Parent;
 		    typedef typename Parent::Arc Arc;
 		  protected:
 		    Orienter() { }
 		  public:
 		    /// \brief Constructor
 		    ///
 		    /// Constructor of the adaptor.
 		    Orienter(GR& graph, DM& direction) {
@@ -2863,16 +2879,17 @@
 		    return ResidualDigraph<DGR, CM, FM> (digraph, capacity_map, flow_map);
+		  }
 		  template <typename DGR>
 		  class SplitNodesBase {
 		    typedef DigraphAdaptorBase<const DGR> Parent;
 		  public:
 		    typedef DGR Digraph;
 		    typedef DigraphAdaptorBase<const DGR> Parent;
 		    typedef SplitNodesBase Adaptor;
 		    typedef typename DGR::Node DigraphNode;
 		    typedef typename DGR::Arc DigraphArc;
 		    class Node;
@@ -3225,17 +3242,17 @@
 		    };
 		  public:
 		    template <typename V>
 		    class NodeMap
 		      : public SubMapExtender<SplitNodesBase<DGR>, NodeMapBase<V> >
+		    {
 		      : public SubMapExtender<SplitNodesBase<DGR>, NodeMapBase<V> > {
 		      typedef SubMapExtender<SplitNodesBase<DGR>, NodeMapBase<V> > Parent;
 		    public:
 		      typedef V Value;
 		      typedef SubMapExtender<SplitNodesBase<DGR>, NodeMapBase<Value> > Parent;
 		      NodeMap(const SplitNodesBase<DGR>& adaptor)
 		        : Parent(adaptor) {}
 		      NodeMap(const SplitNodesBase<DGR>& adaptor, const V& value)
 		        : Parent(adaptor, value) {}
@@ -3251,17 +3268,17 @@
 		        return *this;
+		      }
 		    };
 		    template <typename V>
 		    class ArcMap
 		      : public SubMapExtender<SplitNodesBase<DGR>, ArcMapBase<V> >
+		    {
 		      : public SubMapExtender<SplitNodesBase<DGR>, ArcMapBase<V> > {
 		      typedef SubMapExtender<SplitNodesBase<DGR>, ArcMapBase<V> > Parent;
 		    public:
 		      typedef V Value;
 		      typedef SubMapExtender<SplitNodesBase<DGR>, ArcMapBase<Value> > Parent;
 		      ArcMap(const SplitNodesBase<DGR>& adaptor)
 		        : Parent(adaptor) {}
 		      ArcMap(const SplitNodesBase<DGR>& adaptor, const V& value)
 		        : Parent(adaptor, value) {}
@@ -3321,15 +3338,16 @@
 		#ifdef DOXYGEN
 		  class SplitNodes {
 		#else
 		  class SplitNodes
 		    : public DigraphAdaptorExtender<SplitNodesBase<const DGR> > {
 		#endif
 		    typedef DigraphAdaptorExtender<SplitNodesBase<const DGR> > Parent;
 		  public:
 		    typedef DGR Digraph;
 		    typedef DigraphAdaptorExtender<SplitNodesBase<const DGR> > Parent;
 		    typedef typename DGR::Node DigraphNode;
 		    typedef typename DGR::Arc DigraphArc;
 		    typedef typename Parent::Node Node;
 		    typedef typename Parent::Arc Arc;

lemon/bits/array_map.h

Show inline comments

@@ -44,13 +44,13 @@
 		  // the Value type of the map.
 		  template <typename _Graph, typename _Item, typename _Value>
 		  class ArrayMap
 		    : public ItemSetTraits<_Graph, _Item>::ItemNotifier::ObserverBase {
 		  public:
 		    // The graph type.
-		    typedef _Graph Graph;
+		    typedef _Graph GraphType;
 		    // The item type.
 		    typedef _Item Item;
 		    // The reference map tag.
 		    typedef True ReferenceMapTag;
 		    // The key type of the map.
@@ -60,27 +60,31 @@
 		    // The const reference type of the map.
 		    typedef const _Value& ConstReference;
 		    // The reference type of the map.
 		    typedef _Value& Reference;
 		    // The map type.
 		    typedef ArrayMap Map;
 		    // The notifier type.
 		    typedef typename ItemSetTraits<_Graph, _Item>::ItemNotifier Notifier;
 		  private:
 		    // The MapBase of the Map which imlements the core regisitry function.
 		    typedef typename Notifier::ObserverBase Parent;
 		  private:
 		    typedef std::allocator<Value> Allocator;
 		  public:
 		    // \brief Graph initialized map constructor.
 		    //
 		    // Graph initialized map constructor.
-		    explicit ArrayMap(const Graph& graph) {
+		    explicit ArrayMap(const GraphType& graph) {
 		      Parent::attach(graph.notifier(Item()));
 		      allocate_memory();
 		      Notifier* nf = Parent::notifier();
 		      Item it;
 		      for (nf->first(it); it != INVALID; nf->next(it)) {
 		        int id = nf->id(it);;
@@ -88,13 +92,13 @@
+		      }
+		    }
 		    // \brief Constructor to use default value to initialize the map.
 		    //
 		    // It constructs a map and initialize all of the the map.
-		    ArrayMap(const Graph& graph, const Value& value) {
+		    ArrayMap(const GraphType& graph, const Value& value) {
 		      Parent::attach(graph.notifier(Item()));
 		      allocate_memory();
 		      Notifier* nf = Parent::notifier();
 		      Item it;
 		      for (nf->first(it); it != INVALID; nf->next(it)) {
 		        int id = nf->id(it);;

lemon/bits/base_extender.h

Show inline comments

@@ -35,16 +35,16 @@
 		  // \ingroup digraphbits
 		  //
 		  // \brief BaseDigraph to BaseGraph extender
 		  template <typename Base>
 		  class UndirDigraphExtender : public Base {
 		    typedef Base Parent;
 		  public:
 		    typedef Base Parent;
 		    typedef typename Parent::Arc Edge;
 		    typedef typename Parent::Node Node;
 		    typedef True UndirectedTag;
 		    class Arc : public Edge {
@@ -277,14 +277,15 @@
 		      return INVALID;
+		    }
 		  };
 		  template <typename Base>
 		  class BidirBpGraphExtender : public Base {
 		    typedef Base Parent;
 		  public:
 		    typedef Base Parent;
 		    typedef BidirBpGraphExtender Digraph;
 		    typedef typename Parent::Node Node;
 		    typedef typename Parent::Edge Edge;

lemon/bits/default_map.h

Show inline comments

@@ -150,21 +150,22 @@
 		// #endif
 		  // DefaultMap class
 		  template <typename _Graph, typename _Item, typename _Value>
 		  class DefaultMap
 		    : public DefaultMapSelector<_Graph, _Item, _Value>::Map {
 		    typedef typename DefaultMapSelector<_Graph, _Item, _Value>::Map Parent;
 		  public:
 		    typedef typename DefaultMapSelector<_Graph, _Item, _Value>::Map Parent;
 		    typedef DefaultMap<_Graph, _Item, _Value> Map;
 		    typedef typename Parent::Graph Graph;
 		    typedef typename Parent::GraphType GraphType;
 		    typedef typename Parent::Value Value;
 		    explicit DefaultMap(const Graph& graph) : Parent(graph) {}
 		    DefaultMap(const Graph& graph, const Value& value)
 		    explicit DefaultMap(const GraphType& graph) : Parent(graph) {}
 		    DefaultMap(const GraphType& graph, const Value& value)
 		      : Parent(graph, value) {}
 		    DefaultMap& operator=(const DefaultMap& cmap) {
 		      return operator=<DefaultMap>(cmap);
+		    }

lemon/bits/edge_set_extender.h

Show inline comments

@@ -31,15 +31,16 @@
 		  // \ingroup digraphbits
 		  //
 		  // \brief Extender for the ArcSets
 		  template <typename Base>
 		  class ArcSetExtender : public Base {
 		    typedef Base Parent;
 		  public:
 		    typedef Base Parent;
 		    typedef ArcSetExtender Digraph;
 		    // Base extensions
 		    typedef typename Parent::Node Node;
 		    typedef typename Parent::Arc Arc;
@@ -215,16 +216,15 @@
 		    // Mappable extension
 		    template <typename _Value>
 		    class ArcMap
 		      : public MapExtender<DefaultMap<Digraph, Arc, _Value> > {
 		    public:
 		      typedef ArcSetExtender Digraph;
 		      typedef MapExtender<DefaultMap<Digraph, Arc, _Value> > Parent;
 		    public:
 		      explicit ArcMap(const Digraph& _g)
 			: Parent(_g) {}
 		      ArcMap(const Digraph& _g, const _Value& _v)
 			: Parent(_g, _v) {}
 		      ArcMap& operator=(const ArcMap& cmap) {
@@ -271,23 +271,22 @@
 		  // \ingroup digraphbits
 		  //
 		  // \brief Extender for the EdgeSets
 		  template <typename Base>
 		  class EdgeSetExtender : public Base {
 		    typedef Base Parent;
 		  public:
 		    typedef Base Parent;
 		    typedef EdgeSetExtender Digraph;
 		    typedef EdgeSetExtender Graph;
 		    typedef typename Parent::Node Node;
 		    typedef typename Parent::Arc Arc;
 		    typedef typename Parent::Edge Edge;
 		    int maxId(Node) const {
 		      return Parent::maxNodeId();
+		    }
 		    int maxId(Arc) const {
 		      return Parent::maxArcId();
@@ -347,148 +346,148 @@
 		    EdgeNotifier& notifier(Edge) const {
 		      return edge_notifier;
+		    }
 		    class NodeIt : public Node {
-		      const Digraph* digraph;
+		      const Graph* graph;
 		    public:
 		      NodeIt() {}
 		      NodeIt(Invalid i) : Node(i) { }
-		      explicit NodeIt(const Digraph& _graph) : digraph(&_graph) {
+		      explicit NodeIt(const Graph& _graph) : graph(&_graph) {
 			_graph.first(static_cast<Node&>(*this));
+		      }
 		      NodeIt(const Digraph& _graph, const Node& node)
 			: Node(node), digraph(&_graph) {}
 		      NodeIt(const Graph& _graph, const Node& node)
 			: Node(node), graph(&_graph) {}
 		      NodeIt& operator++() {
-			digraph->next(*this);
+			graph->next(*this);
 			return *this;
+		      }
 		    };
 		    class ArcIt : public Arc {
-		      const Digraph* digraph;
+		      const Graph* graph;
 		    public:
 		      ArcIt() { }
 		      ArcIt(Invalid i) : Arc(i) { }
-		      explicit ArcIt(const Digraph& _graph) : digraph(&_graph) {
+		      explicit ArcIt(const Graph& _graph) : graph(&_graph) {
 			_graph.first(static_cast<Arc&>(*this));
+		      }
 		      ArcIt(const Digraph& _graph, const Arc& e) :
 			Arc(e), digraph(&_graph) { }
 		      ArcIt(const Graph& _graph, const Arc& e) :
 			Arc(e), graph(&_graph) { }
 		      ArcIt& operator++() {
-			digraph->next(*this);
+			graph->next(*this);
 			return *this;
+		      }
 		    };
 		    class OutArcIt : public Arc {
-		      const Digraph* digraph;
+		      const Graph* graph;
 		    public:
 		      OutArcIt() { }
 		      OutArcIt(Invalid i) : Arc(i) { }
 		      OutArcIt(const Digraph& _graph, const Node& node)
 			: digraph(&_graph) {
 		      OutArcIt(const Graph& _graph, const Node& node)
 			: graph(&_graph) {
 			_graph.firstOut(*this, node);
+		      }
 		      OutArcIt(const Digraph& _graph, const Arc& arc)
 			: Arc(arc), digraph(&_graph) {}
 		      OutArcIt(const Graph& _graph, const Arc& arc)
 			: Arc(arc), graph(&_graph) {}
 		      OutArcIt& operator++() {
-			digraph->nextOut(*this);
+			graph->nextOut(*this);
 			return *this;
+		      }
 		    };
 		    class InArcIt : public Arc {
-		      const Digraph* digraph;
+		      const Graph* graph;
 		    public:
 		      InArcIt() { }
 		      InArcIt(Invalid i) : Arc(i) { }
 		      InArcIt(const Digraph& _graph, const Node& node)
 			: digraph(&_graph) {
 		      InArcIt(const Graph& _graph, const Node& node)
 			: graph(&_graph) {
 			_graph.firstIn(*this, node);
+		      }
 		      InArcIt(const Digraph& _graph, const Arc& arc) :
 			Arc(arc), digraph(&_graph) {}
 		      InArcIt(const Graph& _graph, const Arc& arc) :
 			Arc(arc), graph(&_graph) {}
 		      InArcIt& operator++() {
-			digraph->nextIn(*this);
+			graph->nextIn(*this);
 			return *this;
+		      }
 		    };
 		    class EdgeIt : public Parent::Edge {
-		      const Digraph* digraph;
+		      const Graph* graph;
 		    public:
 		      EdgeIt() { }
 		      EdgeIt(Invalid i) : Edge(i) { }
-		      explicit EdgeIt(const Digraph& _graph) : digraph(&_graph) {
+		      explicit EdgeIt(const Graph& _graph) : graph(&_graph) {
 			_graph.first(static_cast<Edge&>(*this));
+		      }
 		      EdgeIt(const Digraph& _graph, const Edge& e) :
 			Edge(e), digraph(&_graph) { }
 		      EdgeIt(const Graph& _graph, const Edge& e) :
 			Edge(e), graph(&_graph) { }
 		      EdgeIt& operator++() {
-			digraph->next(*this);
+			graph->next(*this);
 			return *this;
+		      }
 		    };
 		    class IncEdgeIt : public Parent::Edge {
 		      friend class EdgeSetExtender;
-		      const Digraph* digraph;
+		      const Graph* graph;
 		      bool direction;
 		    public:
 		      IncEdgeIt() { }
 		      IncEdgeIt(Invalid i) : Edge(i), direction(false) { }
-		      IncEdgeIt(const Digraph& _graph, const Node &n) : digraph(&_graph) {
+		      IncEdgeIt(const Graph& _graph, const Node &n) : graph(&_graph) {
 			_graph.firstInc(*this, direction, n);
+		      }
 		      IncEdgeIt(const Digraph& _graph, const Edge &ue, const Node &n)
 			: digraph(&_graph), Edge(ue) {
 		      IncEdgeIt(const Graph& _graph, const Edge &ue, const Node &n)
 			: graph(&_graph), Edge(ue) {
 			direction = (_graph.source(ue) == n);
+		      }
 		      IncEdgeIt& operator++() {
-			digraph->nextInc(*this, direction);
+			graph->nextInc(*this, direction);
 			return *this;
+		      }
 		    };
 		    // \brief Base node of the iterator
 		    //
@@ -531,20 +530,19 @@
 		      return e.direction ? v(e) : u(e);
+		    }
 		    template <typename _Value>
 		    class ArcMap
-		      : public MapExtender<DefaultMap<Digraph, Arc, _Value> > {
+		      : public MapExtender<DefaultMap<Graph, Arc, _Value> > {
 		      typedef MapExtender<DefaultMap<Graph, Arc, _Value> > Parent;
 		    public:
 		      typedef EdgeSetExtender Digraph;
 		      typedef MapExtender<DefaultMap<Digraph, Arc, _Value> > Parent;
 		      ArcMap(const Digraph& _g)
 		      ArcMap(const Graph& _g)
 			: Parent(_g) {}
-		      ArcMap(const Digraph& _g, const _Value& _v)
+		      ArcMap(const Graph& _g, const _Value& _v)
 			: Parent(_g, _v) {}
 		      ArcMap& operator=(const ArcMap& cmap) {
 			return operator=<ArcMap>(cmap);
+		      }
@@ -556,21 +554,20 @@
 		    };
 		    template <typename _Value>
 		    class EdgeMap
-		      : public MapExtender<DefaultMap<Digraph, Edge, _Value> > {
+		      : public MapExtender<DefaultMap<Graph, Edge, _Value> > {
 		      typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
 		    public:
 		      typedef EdgeSetExtender Digraph;
 		      typedef MapExtender<DefaultMap<Digraph, Edge, _Value> > Parent;
 		      EdgeMap(const Digraph& _g)
 		      EdgeMap(const Graph& _g)
 			: Parent(_g) {}
-		      EdgeMap(const Digraph& _g, const _Value& _v)
+		      EdgeMap(const Graph& _g, const _Value& _v)
 			: Parent(_g, _v) {}
 		      EdgeMap& operator=(const EdgeMap& cmap) {
 			return operator=<EdgeMap>(cmap);
+		      }

lemon/bits/graph_adaptor_extender.h

Show inline comments

@@ -23,15 +23,16 @@
 		#include <lemon/error.h>
 		namespace lemon {
 		  template <typename _Digraph>
 		  class DigraphAdaptorExtender : public _Digraph {
 		    typedef _Digraph Parent;
 		  public:
 		    typedef _Digraph Parent;
 		    typedef _Digraph Digraph;
 		    typedef DigraphAdaptorExtender Adaptor;
 		    // Base extensions
 		    typedef typename Parent::Node Node;
@@ -170,15 +171,16 @@
+		    }
 		  };
 		  template <typename _Graph>
 		  class GraphAdaptorExtender : public _Graph {
 		    typedef _Graph Parent;
 		  public:
 		    typedef _Graph Parent;
 		    typedef _Graph Graph;
 		    typedef GraphAdaptorExtender Adaptor;
 		    typedef typename Parent::Node Node;
 		    typedef typename Parent::Arc Arc;
 		    typedef typename Parent::Edge Edge;

lemon/bits/graph_extender.h

Show inline comments

@@ -34,15 +34,16 @@
 		  // \ingroup graphbits
 		  //
 		  // \brief Extender for the digraph implementations
 		  template <typename Base>
 		  class DigraphExtender : public Base {
 		    typedef Base Parent;
 		  public:
 		    typedef Base Parent;
 		    typedef DigraphExtender Digraph;
 		    // Base extensions
 		    typedef typename Parent::Node Node;
 		    typedef typename Parent::Arc Arc;
@@ -215,16 +216,15 @@
+		    }
 		    template <typename _Value>
 		    class NodeMap
 		      : public MapExtender<DefaultMap<Digraph, Node, _Value> > {
 		    public:
 		      typedef DigraphExtender Digraph;
 		      typedef MapExtender<DefaultMap<Digraph, Node, _Value> > Parent;
 		    public:
 		      explicit NodeMap(const Digraph& digraph)
 		        : Parent(digraph) {}
 		      NodeMap(const Digraph& digraph, const _Value& value)
 		        : Parent(digraph, value) {}
 		    private:
@@ -240,16 +240,15 @@
 		    };
 		    template <typename _Value>
 		    class ArcMap
 		      : public MapExtender<DefaultMap<Digraph, Arc, _Value> > {
 		    public:
 		      typedef DigraphExtender Digraph;
 		      typedef MapExtender<DefaultMap<Digraph, Arc, _Value> > Parent;
 		    public:
 		      explicit ArcMap(const Digraph& digraph)
 		        : Parent(digraph) {}
 		      ArcMap(const Digraph& digraph, const _Value& value)
 		        : Parent(digraph, value) {}
 		    private:
@@ -327,15 +326,16 @@
 		  // \ingroup _graphbits
 		  //
 		  // \brief Extender for the Graphs
 		  template <typename Base>
 		  class GraphExtender : public Base {
 		    typedef Base Parent;
 		  public:
 		    typedef Base Parent;
 		    typedef GraphExtender Graph;
 		    typedef True UndirectedTag;
 		    typedef typename Parent::Node Node;
 		    typedef typename Parent::Arc Arc;
@@ -598,16 +598,15 @@
 		    // Mappable extension
 		    template <typename _Value>
 		    class NodeMap
 		      : public MapExtender<DefaultMap<Graph, Node, _Value> > {
 		    public:
 		      typedef GraphExtender Graph;
 		      typedef MapExtender<DefaultMap<Graph, Node, _Value> > Parent;
 		    public:
 		      NodeMap(const Graph& graph)
 		        : Parent(graph) {}
 		      NodeMap(const Graph& graph, const _Value& value)
 		        : Parent(graph, value) {}
 		    private:
@@ -623,16 +622,15 @@
 		    };
 		    template <typename _Value>
 		    class ArcMap
 		      : public MapExtender<DefaultMap<Graph, Arc, _Value> > {
 		    public:
 		      typedef GraphExtender Graph;
 		      typedef MapExtender<DefaultMap<Graph, Arc, _Value> > Parent;
 		    public:
 		      ArcMap(const Graph& graph)
 		        : Parent(graph) {}
 		      ArcMap(const Graph& graph, const _Value& value)
 		        : Parent(graph, value) {}
 		    private:
@@ -648,16 +646,15 @@
 		    };
 		    template <typename _Value>
 		    class EdgeMap
 		      : public MapExtender<DefaultMap<Graph, Edge, _Value> > {
 		    public:
 		      typedef GraphExtender Graph;
 		      typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
 		    public:
 		      EdgeMap(const Graph& graph)
 		        : Parent(graph) {}
 		      EdgeMap(const Graph& graph, const _Value& value)
 		        : Parent(graph, value) {}

lemon/bits/map_extender.h

Show inline comments

@@ -33,19 +33,18 @@
 		  // \ingroup graphbits
 		  //
 		  // \brief Extender for maps
 		  template <typename _Map>
 		  class MapExtender : public _Map {
 		    typedef _Map Parent;
 		    typedef typename Parent::GraphType GraphType;
 		  public:
 		    typedef _Map Parent;
 		    typedef MapExtender Map;
 		    typedef typename Parent::Graph Graph;
 		    typedef typename Parent::Key Item;
 		    typedef typename Parent::Key Key;
 		    typedef typename Parent::Value Value;
 		    typedef typename Parent::Reference Reference;
 		    typedef typename Parent::ConstReference ConstReference;
@@ -55,16 +54,16 @@
 		    friend class MapIt;
 		    friend class ConstMapIt;
 		  public:
-		    MapExtender(const Graph& graph)
+		    MapExtender(const GraphType& graph)
 		      : Parent(graph) {}
-		    MapExtender(const Graph& graph, const Value& value)
+		    MapExtender(const GraphType& graph, const Value& value)
 		      : Parent(graph, value) {}
 		  private:
 		    MapExtender& operator=(const MapExtender& cmap) {
 		      return operator=<MapExtender>(cmap);
+		    }
@@ -74,15 +73,16 @@
 		      Parent::operator=(cmap);
 		      return *this;
+		    }
 		  public:
 		    class MapIt : public Item {
 		      typedef Item Parent;
 		    public:
 		      typedef Item Parent;
 		      typedef typename Map::Value Value;
 		      MapIt() {}
 		      MapIt(Invalid i) : Parent(i) { }
@@ -113,16 +113,16 @@
 		    protected:
 		      Map& map;
 		    };
 		    class ConstMapIt : public Item {
 		      typedef Item Parent;
 		    public:
 		      typedef Item Parent;
 		      typedef typename Map::Value Value;
 		      ConstMapIt() {}
 		      ConstMapIt(Invalid i) : Parent(i) { }
@@ -144,16 +144,16 @@
 		    protected:
 		      const Map& map;
 		    };
 		    class ItemIt : public Item {
 		      typedef Item Parent;
 		    public:
 		      typedef Item Parent;
 		      ItemIt() {}
 		      ItemIt(Invalid i) : Parent(i) { }
 		      explicit ItemIt(Map& _map) : map(_map) {
 		        map.notifier()->first(*this);
@@ -175,19 +175,18 @@
 		  // \ingroup graphbits
 		  //
 		  // \brief Extender for maps which use a subset of the items.
 		  template <typename _Graph, typename _Map>
 		  class SubMapExtender : public _Map {
 		    typedef _Map Parent;
 		    typedef _Graph GraphType;
 		  public:
 		    typedef _Map Parent;
 		    typedef SubMapExtender Map;
 		    typedef _Graph Graph;
 		    typedef typename Parent::Key Item;
 		    typedef typename Parent::Key Key;
 		    typedef typename Parent::Value Value;
 		    typedef typename Parent::Reference Reference;
 		    typedef typename Parent::ConstReference ConstReference;
@@ -197,16 +196,16 @@
 		    friend class MapIt;
 		    friend class ConstMapIt;
 		  public:
-		    SubMapExtender(const Graph& _graph)
+		    SubMapExtender(const GraphType& _graph)
 		      : Parent(_graph), graph(_graph) {}
-		    SubMapExtender(const Graph& _graph, const Value& _value)
+		    SubMapExtender(const GraphType& _graph, const Value& _value)
 		      : Parent(_graph, _value), graph(_graph) {}
 		  private:
 		    SubMapExtender& operator=(const SubMapExtender& cmap) {
 		      return operator=<MapExtender>(cmap);
+		    }
@@ -220,15 +219,15 @@
+		      }
 		      return *this;
+		    }
 		  public:
 		    class MapIt : public Item {
 		      typedef Item Parent;
 		    public:
 		      typedef Item Parent;
 		      typedef typename Map::Value Value;
 		      MapIt() {}
 		      MapIt(Invalid i) : Parent(i) { }
@@ -259,16 +258,16 @@
 		    protected:
 		      Map& map;
 		    };
 		    class ConstMapIt : public Item {
 		      typedef Item Parent;
 		    public:
 		      typedef Item Parent;
 		      typedef typename Map::Value Value;
 		      ConstMapIt() {}
 		      ConstMapIt(Invalid i) : Parent(i) { }
@@ -290,16 +289,16 @@
 		    protected:
 		      const Map& map;
 		    };
 		    class ItemIt : public Item {
 		      typedef Item Parent;
 		    public:
 		      typedef Item Parent;
 		      ItemIt() {}
 		      ItemIt(Invalid i) : Parent(i) { }
 		      explicit ItemIt(Map& _map) : map(_map) {
 		        map.graph.first(*this);
@@ -317,13 +316,13 @@
 		      const Map& map;
 		    };
 		  private:
-		    const Graph& graph;
+		    const GraphType& graph;
 		  };
+		}
 		#endif

lemon/bits/vector_map.h

Show inline comments

@@ -53,13 +53,13 @@
 		    // The container type of the map.
 		    typedef std::vector<_Value> Container;
 		  public:
 		    // The graph type of the map.
-		    typedef _Graph Graph;
+		    typedef _Graph GraphType;
 		    // The item type of the map.
 		    typedef _Item Item;
 		    // The reference map tag.
 		    typedef True ReferenceMapTag;
 		    // The key type of the map.
@@ -69,35 +69,39 @@
 		    // The notifier type.
 		    typedef typename ItemSetTraits<_Graph, _Item>::ItemNotifier Notifier;
 		    // The map type.
 		    typedef VectorMap Map;
 		    // The base class of the map.
 		    typedef typename Notifier::ObserverBase Parent;
 		    // The reference type of the map;
 		    typedef typename Container::reference Reference;
 		    // The const reference type of the map;
 		    typedef typename Container::const_reference ConstReference;
 		  private:
 		    // The base class of the map.
 		    typedef typename Notifier::ObserverBase Parent;
 		  public:
 		    // \brief Constructor to attach the new map into the notifier.
 		    //
 		    // It constructs a map and attachs it into the notifier.
 		    // It adds all the items of the graph to the map.
-		    VectorMap(const Graph& graph) {
+		    VectorMap(const GraphType& graph) {
 		      Parent::attach(graph.notifier(Item()));
 		      container.resize(Parent::notifier()->maxId() + 1);
+		    }
 		    // \brief Constructor uses given value to initialize the map.
 		    //
 		    // It constructs a map uses a given value to initialize the map.
 		    // It adds all the items of the graph to the map.
-		    VectorMap(const Graph& graph, const Value& value) {
+		    VectorMap(const GraphType& graph, const Value& value) {
 		      Parent::attach(graph.notifier(Item()));
 		      container.resize(Parent::notifier()->maxId() + 1, value);
+		    }
 		  private:
 		    // \brief Copy constructor

lemon/concepts/graph_components.h

Show inline comments

@@ -177,24 +177,27 @@
 		    /// All graph %concepts have to conform to this class.
 		    /// It extends the interface of \ref BaseDigraphComponent with an
 		    /// \c Edge type and functions to get the end nodes of edges,
 		    /// to convert from arcs to edges and to get both direction of edges.
 		    class BaseGraphComponent : public BaseDigraphComponent {
 		    public:
 		      typedef BaseGraphComponent Graph;
 		      typedef BaseDigraphComponent::Node Node;
 		      typedef BaseDigraphComponent::Arc Arc;
 		      /// \brief Undirected edge class of the graph.
 		      ///
 		      /// This class represents the undirected edges of the graph.
 		      /// Undirected graphs can be used as directed graphs, each edge is
 		      /// represented by two opposite directed arcs.
 		      class Edge : public GraphItem<'e'> {
 		      public:
 		        typedef GraphItem<'e'> Parent;
 		      public:
 		        /// \brief Default constructor.
 		        ///
 		        /// Default constructor.
 		        /// \warning The default constructor is not required to set
 		        /// the item to some well-defined value. So you should consider it
 		        /// as uninitialized.
@@ -988,18 +991,16 @@
 		    /// This class describes the concept of standard graph maps, i.e.
 		    /// the \c NodeMap, \c ArcMap and \c EdgeMap subtypes of digraph and
 		    /// graph types, which can be used for associating data to graph items.
 		    /// The standard graph maps must conform to the ReferenceMap concept.
 		    template <typename GR, typename K, typename V>
 		    class GraphMap : public ReferenceMap<K, V, V&, const V&> {
 		      typedef ReferenceMap<K, V, V&, const V&> Parent;
 		    public:
 		      typedef ReadWriteMap<K, V> Parent;
 		      /// The graph type of the map.
 		      typedef GR Graph;
 		      /// The key type of the map.
 		      typedef K Key;
 		      /// The value type of the map.
 		      typedef V Value;
 		      /// The reference type of the map.
 		      typedef Value& Reference;
@@ -1009,17 +1010,17 @@
 		      // The reference map tag.
 		      typedef True ReferenceMapTag;
 		      /// \brief Construct a new map.
 		      ///
 		      /// Construct a new map for the graph.
-		      explicit GraphMap(const Graph&) {}
+		      explicit GraphMap(const GR&) {}
 		      /// \brief Construct a new map with default value.
 		      ///
 		      /// Construct a new map for the graph and initalize the values.
-		      GraphMap(const Graph&, const Value&) {}
+		      GraphMap(const GR&, const Value&) {}
 		    private:
 		      /// \brief Copy constructor.
 		      ///
 		      /// Copy Constructor.
 		      GraphMap(const GraphMap&) : Parent() {}
@@ -1054,13 +1055,13 @@
 		          ignore_unused_variable_warning(m1);
 		          ignore_unused_variable_warning(m2);
 		          // ignore_unused_variable_warning(m3);
+		        }
 		        const _Map &m;
-		        const Graph &g;
+		        const GR &g;
 		        const typename GraphMap::Value &t;
 		      };
 		    };
 		    /// \brief Skeleton class for mappable directed graphs.
@@ -1082,15 +1083,15 @@
 		      /// \brief Standard graph map for the nodes.
 		      ///
 		      /// Standard graph map for the nodes.
 		      /// It conforms to the ReferenceMap concept.
 		      template <typename V>
 		      class NodeMap : public GraphMap<MappableDigraphComponent, Node, V> {
 		      public:
 		        typedef GraphMap<MappableDigraphComponent, Node, V> Parent;
 		      public:
 		        /// \brief Construct a new map.
 		        ///
 		        /// Construct a new map for the digraph.
 		        explicit NodeMap(const MappableDigraphComponent& digraph)
 		          : Parent(digraph) {}
@@ -1120,15 +1121,15 @@
 		      /// \brief Standard graph map for the arcs.
 		      ///
 		      /// Standard graph map for the arcs.
 		      /// It conforms to the ReferenceMap concept.
 		      template <typename V>
 		      class ArcMap : public GraphMap<MappableDigraphComponent, Arc, V> {
 		      public:
 		        typedef GraphMap<MappableDigraphComponent, Arc, V> Parent;
 		      public:
 		        /// \brief Construct a new map.
 		        ///
 		        /// Construct a new map for the digraph.
 		        explicit ArcMap(const MappableDigraphComponent& digraph)
 		          : Parent(digraph) {}
@@ -1218,15 +1219,15 @@
 		      /// \brief Standard graph map for the edges.
 		      ///
 		      /// Standard graph map for the edges.
 		      /// It conforms to the ReferenceMap concept.
 		      template <typename V>
 		      class EdgeMap : public GraphMap<MappableGraphComponent, Edge, V> {
 		      public:
 		        typedef GraphMap<MappableGraphComponent, Edge, V> Parent;
 		      public:
 		        /// \brief Construct a new map.
 		        ///
 		        /// Construct a new map for the graph.
 		        explicit EdgeMap(const MappableGraphComponent& graph)
 		          : Parent(graph) {}

lemon/core.h

Show inline comments

@@ -1033,43 +1033,42 @@
 		  ///\endcode
 		  ///
 		  ///\sa findArc()
 		  ///\sa ArcLookUp, AllArcLookUp, DynArcLookUp
 		  template <typename GR>
 		  class ConArcIt : public GR::Arc {
 		    typedef typename GR::Arc Parent;
 		  public:
 		    typedef GR Graph;
 		    typedef typename Graph::Arc Parent;
 		    typedef typename Graph::Arc Arc;
-		    typedef typename Graph::Node Node;
+		    typedef typename GR::Arc Arc;
 		    typedef typename GR::Node Node;
 		    /// \brief Constructor.
 		    ///
 		    /// Construct a new ConArcIt iterating on the arcs that
 		    /// connects nodes \c u and \c v.
-		    ConArcIt(const Graph& g, Node u, Node v) : _graph(g) {
+		    ConArcIt(const GR& g, Node u, Node v) : _graph(g) {
 		      Parent::operator=(findArc(_graph, u, v));
+		    }
 		    /// \brief Constructor.
 		    ///
 		    /// Construct a new ConArcIt that continues the iterating from arc \c a.
-		    ConArcIt(const Graph& g, Arc a) : Parent(a), _graph(g) {}
+		    ConArcIt(const GR& g, Arc a) : Parent(a), _graph(g) {}
 		    /// \brief Increment operator.
 		    ///
 		    /// It increments the iterator and gives back the next arc.
 		    ConArcIt& operator++() {
 		      Parent::operator=(findArc(_graph, _graph.source(*this),
 		                                _graph.target(*this), *this));
 		      return *this;
+		    }
 		  private:
-		    const Graph& _graph;
+		    const GR& _graph;
 		  };
 		  namespace _core_bits {
 		    template <typename Graph, typename Enable = void>
 		    struct FindEdgeSelector {
@@ -1156,42 +1155,41 @@
 		  /// }
 		  ///\endcode
 		  ///
 		  ///\sa findEdge()
 		  template <typename GR>
 		  class ConEdgeIt : public GR::Edge {
 		    typedef typename GR::Edge Parent;
 		  public:
 		    typedef GR Graph;
 		    typedef typename Graph::Edge Parent;
 		    typedef typename Graph::Edge Edge;
-		    typedef typename Graph::Node Node;
+		    typedef typename GR::Edge Edge;
 		    typedef typename GR::Node Node;
 		    /// \brief Constructor.
 		    ///
 		    /// Construct a new ConEdgeIt iterating on the edges that
 		    /// connects nodes \c u and \c v.
-		    ConEdgeIt(const Graph& g, Node u, Node v) : _graph(g), _u(u), _v(v) {
+		    ConEdgeIt(const GR& g, Node u, Node v) : _graph(g), _u(u), _v(v) {
 		      Parent::operator=(findEdge(_graph, _u, _v));
+		    }
 		    /// \brief Constructor.
 		    ///
 		    /// Construct a new ConEdgeIt that continues iterating from edge \c e.
-		    ConEdgeIt(const Graph& g, Edge e) : Parent(e), _graph(g) {}
+		    ConEdgeIt(const GR& g, Edge e) : Parent(e), _graph(g) {}
 		    /// \brief Increment operator.
 		    ///
 		    /// It increments the iterator and gives back the next edge.
 		    ConEdgeIt& operator++() {
 		      Parent::operator=(findEdge(_graph, _u, _v, *this));
 		      return *this;
+		    }
 		  private:
-		    const Graph& _graph;
+		    const GR& _graph;
 		    Node _u, _v;
 		  };
 		  ///Dynamic arc look-up between given endpoints.
@@ -1216,26 +1214,29 @@
 		  ///\sa ArcLookUp
 		  ///\sa AllArcLookUp
 		  template <typename GR>
 		  class DynArcLookUp
 		    : protected ItemSetTraits<GR, typename GR::Arc>::ItemNotifier::ObserverBase
+		  {
 		  public:
 		    typedef typename ItemSetTraits<GR, typename GR::Arc>
 		    ::ItemNotifier::ObserverBase Parent;
 		    TEMPLATE_DIGRAPH_TYPEDEFS(GR);
 		  public:
 		    /// The Digraph type
 		    typedef GR Digraph;
 		  protected:
 		    class AutoNodeMap : public ItemSetTraits<GR, Node>::template Map<Arc>::Type {
 		      typedef typename ItemSetTraits<GR, Node>::template Map<Arc>::Type Parent;
 		    public:
 		      typedef typename ItemSetTraits<GR, Node>::template Map<Arc>::Type Parent;
 		      AutoNodeMap(const GR& digraph) : Parent(digraph, INVALID) {}
 		      virtual void add(const Node& node) {
 		        Parent::add(node);
 		        Parent::set(node, INVALID);
+		      }
@@ -1254,28 +1255,30 @@
 		        for (nf->first(it); it != INVALID; nf->next(it)) {
 		          Parent::set(it, INVALID);
+		        }
+		      }
 		    };
 		    const Digraph &_g;
 		    AutoNodeMap _head;
 		    typename Digraph::template ArcMap<Arc> _parent;
 		    typename Digraph::template ArcMap<Arc> _left;
 		    typename Digraph::template ArcMap<Arc> _right;
 		    class ArcLess {
 		      const Digraph &g;
 		    public:
 		      ArcLess(const Digraph &_g) : g(_g) {}
 		      bool operator()(Arc a,Arc b) const
+		      {
 		        return g.target(a)<g.target(b);
+		      }
 		    };
 		  protected:
 		    const Digraph &_g;
 		    AutoNodeMap _head;
 		    typename Digraph::template ArcMap<Arc> _parent;
 		    typename Digraph::template ArcMap<Arc> _left;
 		    typename Digraph::template ArcMap<Arc> _right;
 		  public:
 		    ///Constructor
 		    ///Constructor.
 		    ///
@@ -1627,14 +1630,17 @@
 		  ///
 		  ///\sa DynArcLookUp
 		  ///\sa AllArcLookUp
 		  template<class GR>
 		  class ArcLookUp
+		  {
 		    TEMPLATE_DIGRAPH_TYPEDEFS(GR);
 		  public:
-		    TEMPLATE_DIGRAPH_TYPEDEFS(GR);
 		    /// The Digraph type
 		    typedef GR Digraph;
 		  protected:
 		    const Digraph &_g;
 		    typename Digraph::template NodeMap<Arc> _head;
 		    typename Digraph::template ArcMap<Arc> _left;
@@ -1743,15 +1749,14 @@
 		    using ArcLookUp<GR>::_g;
 		    using ArcLookUp<GR>::_right;
 		    using ArcLookUp<GR>::_left;
 		    using ArcLookUp<GR>::_head;
 		    TEMPLATE_DIGRAPH_TYPEDEFS(GR);
 		    typedef GR Digraph;
-		    typename Digraph::template ArcMap<Arc> _next;
+		    typename GR::template ArcMap<Arc> _next;
 		    Arc refreshNext(Arc head,Arc next=INVALID)
+		    {
 		      if(head==INVALID) return next;
 		      else {
 		        next=refreshNext(_right[head],next);
@@ -1764,12 +1769,16 @@
 		    void refreshNext()
+		    {
 		      for(NodeIt n(_g);n!=INVALID;++n) refreshNext(_head[n]);
+		    }
 		  public:
 		    /// The Digraph type
 		    typedef GR Digraph;
 		    ///Constructor
 		    ///Constructor.
 		    ///
 		    ///It builds up the search database, which remains valid until the digraph
 		    ///changes.

lemon/edge_set.h

Show inline comments

@@ -30,13 +30,12 @@
 		namespace lemon {
 		  template <typename GR>
 		  class ListArcSetBase {
 		  public:
 		    typedef GR Graph;
 		    typedef typename GR::Node Node;
 		    typedef typename GR::NodeIt NodeIt;
 		  protected:
 		    struct NodeT {
@@ -205,16 +204,16 @@
 		    NodeNotifier& notifier(Node) const {
 		      return _graph->notifier(Node());
+		    }
 		    template <typename V>
 		    class NodeMap : public GR::template NodeMap<V> {
 		      typedef typename GR::template NodeMap<V> Parent;
 		    public:
 		      typedef typename GR::template NodeMap<V> Parent;
 		      explicit NodeMap(const ListArcSetBase<GR>& arcset)
 		        : Parent(*arcset._graph) {}
 		      NodeMap(const ListArcSetBase<GR>& arcset, const V& value)
 		        : Parent(*arcset._graph, value) {}
@@ -256,23 +255,19 @@
 		  /// concept.
 		  ///
 		  /// This class fully conforms to the \ref concepts::Digraph
 		  /// "Digraph" concept.
 		  template <typename GR>
 		  class ListArcSet : public ArcSetExtender<ListArcSetBase<GR> > {
 		    typedef ArcSetExtender<ListArcSetBase<GR> > Parent;
 		  public:
 		    typedef ArcSetExtender<ListArcSetBase<GR> > Parent;
 		    typedef typename Parent::Node Node;
 		    typedef typename Parent::Arc Arc;
 		    typedef GR Graph;
 		    typedef typename Parent::NodesImplBase NodesImplBase;
 		    void eraseNode(const Node& node) {
 		      Arc arc;
 		      Parent::firstOut(arc, node);
 		      while (arc != INVALID ) {
@@ -289,15 +284,15 @@
 		    void clearNodes() {
 		      Parent::clear();
+		    }
 		    class NodesImpl : public NodesImplBase {
 		    public:
 		      typedef NodesImplBase Parent;
 		    public:
 		      NodesImpl(const GR& graph, ListArcSet& arcset)
 		        : Parent(graph), _arcset(arcset) {}
 		      virtual ~NodesImpl() {}
 		    protected:
@@ -351,13 +346,12 @@
 		  };
 		  template <typename GR>
 		  class ListEdgeSetBase {
 		  public:
 		    typedef GR Graph;
 		    typedef typename GR::Node Node;
 		    typedef typename GR::NodeIt NodeIt;
 		  protected:
 		    struct NodeT {
@@ -634,16 +628,16 @@
 		    NodeNotifier& notifier(Node) const {
 		      return _graph->notifier(Node());
+		    }
 		    template <typename V>
 		    class NodeMap : public GR::template NodeMap<V> {
 		      typedef typename GR::template NodeMap<V> Parent;
 		    public:
 		      typedef typename GR::template NodeMap<V> Parent;
 		      explicit NodeMap(const ListEdgeSetBase<GR>& arcset)
 		        : Parent(*arcset._graph) {}
 		      NodeMap(const ListEdgeSetBase<GR>& arcset, const V& value)
 		        : Parent(*arcset._graph, value) {}
@@ -685,24 +679,20 @@
 		  /// concept.
 		  ///
 		  /// This class fully conforms to the \ref concepts::Graph "Graph"
 		  /// concept.
 		  template <typename GR>
 		  class ListEdgeSet : public EdgeSetExtender<ListEdgeSetBase<GR> > {
 		    typedef EdgeSetExtender<ListEdgeSetBase<GR> > Parent;
 		  public:
 		    typedef EdgeSetExtender<ListEdgeSetBase<GR> > Parent;
 		    typedef typename Parent::Node Node;
 		    typedef typename Parent::Arc Arc;
 		    typedef typename Parent::Edge Edge;
 		    typedef GR Graph;
 		    typedef typename Parent::NodesImplBase NodesImplBase;
 		    void eraseNode(const Node& node) {
 		      Arc arc;
 		      Parent::firstOut(arc, node);
 		      while (arc != INVALID ) {
@@ -714,15 +704,15 @@
 		    void clearNodes() {
 		      Parent::clear();
+		    }
 		    class NodesImpl : public NodesImplBase {
 		    public:
 		      typedef NodesImplBase Parent;
 		    public:
 		      NodesImpl(const GR& graph, ListEdgeSet& arcset)
 		        : Parent(graph), _arcset(arcset) {}
 		      virtual ~NodesImpl() {}
 		    protected:
@@ -776,15 +766,14 @@
 		  };
 		  template <typename GR>
 		  class SmartArcSetBase {
 		  public:
 		    typedef GR Graph;
 		    typedef typename Graph::Node Node;
-		    typedef typename Graph::NodeIt NodeIt;
+		    typedef typename GR::Node Node;
 		    typedef typename GR::NodeIt NodeIt;
 		  protected:
 		    struct NodeT {
 		      int first_out, first_in;
 		      NodeT() : first_out(-1), first_in(-1) {}
@@ -897,16 +886,16 @@
 		    NodeNotifier& notifier(Node) const {
 		      return _graph->notifier(Node());
+		    }
 		    template <typename V>
 		    class NodeMap : public GR::template NodeMap<V> {
 		      typedef typename GR::template NodeMap<V> Parent;
 		    public:
 		      typedef typename GR::template NodeMap<V> Parent;
 		      explicit NodeMap(const SmartArcSetBase<GR>& arcset)
 		        : Parent(*arcset._graph) { }
 		      NodeMap(const SmartArcSetBase<GR>& arcset, const V& value)
 		        : Parent(*arcset._graph, value) { }
@@ -953,22 +942,19 @@
 		  /// validity can be checked with the \c valid() member function.
 		  ///
 		  /// This class fully conforms to the \ref concepts::Digraph
 		  /// "Digraph" concept.
 		  template <typename GR>
 		  class SmartArcSet : public ArcSetExtender<SmartArcSetBase<GR> > {
 		    typedef ArcSetExtender<SmartArcSetBase<GR> > Parent;
 		  public:
 		    typedef ArcSetExtender<SmartArcSetBase<GR> > Parent;
 		    typedef typename Parent::Node Node;
 		    typedef typename Parent::Arc Arc;
 		    typedef GR Graph;
 		  protected:
 		    typedef typename Parent::NodesImplBase NodesImplBase;
 		    void eraseNode(const Node& node) {
 		      if (typename Parent::InArcIt(*this, node) == INVALID &&
@@ -980,15 +966,15 @@
 		    void clearNodes() {
 		      Parent::clear();
+		    }
 		    class NodesImpl : public NodesImplBase {
 		    public:
 		      typedef NodesImplBase Parent;
 		    public:
 		      NodesImpl(const GR& graph, SmartArcSet& arcset)
 		        : Parent(graph), _arcset(arcset) {}
 		      virtual ~NodesImpl() {}
 		      bool attached() const {
@@ -1059,13 +1045,12 @@
 		  template <typename GR>
 		  class SmartEdgeSetBase {
 		  public:
 		    typedef GR Graph;
 		    typedef typename GR::Node Node;
 		    typedef typename GR::NodeIt NodeIt;
 		  protected:
 		    struct NodeT {
@@ -1246,16 +1231,16 @@
 		    NodeNotifier& notifier(Node) const {
 		      return _graph->notifier(Node());
+		    }
 		    template <typename V>
 		    class NodeMap : public GR::template NodeMap<V> {
 		      typedef typename GR::template NodeMap<V> Parent;
 		    public:
 		      typedef typename GR::template NodeMap<V> Parent;
 		      explicit NodeMap(const SmartEdgeSetBase<GR>& arcset)
 		        : Parent(*arcset._graph) { }
 		      NodeMap(const SmartEdgeSetBase<GR>& arcset, const V& value)
 		        : Parent(*arcset._graph, value) { }
@@ -1301,23 +1286,20 @@
 		  /// be checked with the \c valid() member function.
 		  ///
 		  /// This class fully conforms to the \ref concepts::Graph
 		  /// "Graph" concept.
 		  template <typename GR>
 		  class SmartEdgeSet : public EdgeSetExtender<SmartEdgeSetBase<GR> > {
 		    typedef EdgeSetExtender<SmartEdgeSetBase<GR> > Parent;
 		  public:
 		    typedef EdgeSetExtender<SmartEdgeSetBase<GR> > Parent;
 		    typedef typename Parent::Node Node;
 		    typedef typename Parent::Arc Arc;
 		    typedef typename Parent::Edge Edge;
 		    typedef GR Graph;
 		  protected:
 		    typedef typename Parent::NodesImplBase NodesImplBase;
 		    void eraseNode(const Node& node) {
 		      if (typename Parent::IncEdgeIt(*this, node) == INVALID) {
@@ -1328,15 +1310,15 @@
 		    void clearNodes() {
 		      Parent::clear();
+		    }
 		    class NodesImpl : public NodesImplBase {
 		    public:
 		      typedef NodesImplBase Parent;
 		    public:
 		      NodesImpl(const GR& graph, SmartEdgeSet& arcset)
 		        : Parent(graph), _arcset(arcset) {}
 		      virtual ~NodesImpl() {}
 		      bool attached() const {

lemon/full_graph.h

Show inline comments

@@ -28,13 +28,13 @@
 		namespace lemon {
 		  class FullDigraphBase {
 		  public:
-		    typedef FullDigraphBase Graph;
+		    typedef FullDigraphBase Digraph;
 		    class Node;
 		    class Arc;
 		  protected:
@@ -166,16 +166,16 @@
 		  /// class conforms to the \ref concepts::Graph "Graph" concept,
 		  /// moreover \c FullGraph does not contain a loop arc for each
 		  /// node as \c FullDigraph does.
 		  ///
 		  /// \sa FullGraph
 		  class FullDigraph : public ExtendedFullDigraphBase {
 		    typedef ExtendedFullDigraphBase Parent;
 		  public:
 		    typedef ExtendedFullDigraphBase Parent;
 		    /// \brief Constructor
 		    FullDigraph() { construct(0); }
 		    /// \brief Constructor
 		    ///
 		    /// Constructor.
@@ -223,24 +223,25 @@
 		    /// \brief Number of arcs.
 		    int arcNum() const { return Parent::arcNum(); }
 		  };
 		  class FullGraphBase {
 		    int _node_num;
 		    int _edge_num;
 		  public:
 		    typedef FullGraphBase Graph;
 		    class Node;
 		    class Arc;
 		    class Edge;
 		  protected:
 		    int _node_num;
 		    int _edge_num;
 		    FullGraphBase() {}
 		    void construct(int n) { _node_num = n; _edge_num = n * (n - 1) / 2; }
 		    int _uid(int e) const {
 		      int u = e / _node_num;
@@ -534,16 +535,16 @@
 		  /// this class conforms to the \ref concepts::Graph "Graph" concept,
 		  /// moreover \c FullGraph does not contain a loop arc for each
 		  /// node as \c FullDigraph does.
 		  ///
 		  /// \sa FullDigraph
 		  class FullGraph : public ExtendedFullGraphBase {
 		    typedef ExtendedFullGraphBase Parent;
 		  public:
 		    typedef ExtendedFullGraphBase Parent;
 		    /// \brief Constructor
 		    FullGraph() { construct(0); }
 		    /// \brief Constructor
 		    ///
 		    /// Constructor.

lemon/graph_to_eps.h

Show inline comments

@@ -66,12 +66,13 @@
 		///
 		///\param GR is the type of the underlying graph.
 		template<class GR>
 		struct DefaultGraphToEpsTraits
+		{
 		  typedef GR Graph;
 		  typedef GR Digraph;
 		  typedef typename Graph::Node Node;
 		  typedef typename Graph::NodeIt NodeIt;
 		  typedef typename Graph::Arc Arc;
 		  typedef typename Graph::ArcIt ArcIt;
 		  typedef typename Graph::InArcIt InArcIt;
 		  typedef typename Graph::OutArcIt OutArcIt;
@@ -238,12 +239,13 @@
 		  using T::_negY;
 		  using T::_preScale;
 		  // dradnats ++C eht yb deriuqer si ti eveileb t'naC
 		  typedef typename T::Graph Graph;
 		  typedef typename T::Digraph Digraph;
 		  typedef typename Graph::Node Node;
 		  typedef typename Graph::NodeIt NodeIt;
 		  typedef typename Graph::Arc Arc;
 		  typedef typename Graph::ArcIt ArcIt;
 		  typedef typename Graph::InArcIt InArcIt;
 		  typedef typename Graph::OutArcIt OutArcIt;

lemon/grid_graph.h

Show inline comments

@@ -496,16 +496,16 @@
 		  /// }
 		  ///\endcode
 		  ///
 		  /// This graph type fully conforms to the \ref concepts::Graph
 		  /// "Graph concept".
 		  class GridGraph : public ExtendedGridGraphBase {
 		    typedef ExtendedGridGraphBase Parent;
 		  public:
 		    typedef ExtendedGridGraphBase Parent;
 		    /// \brief Map to get the indices of the nodes as dim2::Point<int>.
 		    ///
 		    /// Map to get the indices of the nodes as dim2::Point<int>.
 		    class IndexMap {
 		    public:
 		      /// \brief The key type of the map

lemon/hypercube_graph.h

Show inline comments

@@ -291,16 +291,16 @@
 		  /// reasons. Thus the maximum dimension of this implementation is 26
 		  /// (assuming that the size of \c int is 32 bit).
 		  ///
 		  /// This graph type fully conforms to the \ref concepts::Graph
 		  /// "Graph concept".
 		  class HypercubeGraph : public ExtendedHypercubeGraphBase {
 		    typedef ExtendedHypercubeGraphBase Parent;
 		  public:
 		    typedef ExtendedHypercubeGraphBase Parent;
 		    /// \brief Constructs a hypercube graph with \c dim dimensions.
 		    ///
 		    /// Constructs a hypercube graph with \c dim dimensions.
 		    HypercubeGraph(int dim) { construct(dim); }
 		    /// \brief The number of dimensions.

lemon/list_graph.h

Show inline comments

@@ -320,12 +320,14 @@
 		  ///Most of the member functions and nested classes are documented
 		  ///only in the concept class.
 		  ///
 		  ///\sa concepts::Digraph
 		  class ListDigraph : public ExtendedListDigraphBase {
 		    typedef ExtendedListDigraphBase Parent;
 		  private:
 		    ///ListDigraph is \e not copy constructible. Use copyDigraph() instead.
 		    ///ListDigraph is \e not copy constructible. Use copyDigraph() instead.
 		    ///
 		    ListDigraph(const ListDigraph &) :ExtendedListDigraphBase() {};
@@ -334,14 +336,12 @@
 		    ///Assignment of ListDigraph to another one is \e not allowed.
 		    ///Use copyDigraph() instead.
 		    void operator=(const ListDigraph &) {}
 		  public:
 		    typedef ExtendedListDigraphBase Parent;
 		    /// Constructor
 		    /// Constructor.
 		    ///
 		    ListDigraph() {}
@@ -790,13 +790,13 @@
 		    std::vector<ArcT> arcs;
 		    int first_free_arc;
 		  public:
-		    typedef ListGraphBase Digraph;
+		    typedef ListGraphBase Graph;
 		    class Node;
 		    class Arc;
 		    class Edge;
 		    class Node {
@@ -1173,12 +1173,14 @@
 		  ///Most of the member functions and nested classes are documented
 		  ///only in the concept class.
 		  ///
 		  ///\sa concepts::Graph
 		  class ListGraph : public ExtendedListGraphBase {
 		    typedef ExtendedListGraphBase Parent;
 		  private:
 		    ///ListGraph is \e not copy constructible. Use copyGraph() instead.
 		    ///ListGraph is \e not copy constructible. Use copyGraph() instead.
 		    ///
 		    ListGraph(const ListGraph &) :ExtendedListGraphBase()  {};
@@ -1192,14 +1194,12 @@
 		    /// Constructor
 		    /// Constructor.
 		    ///
 		    ListGraph() {}
 		    typedef ExtendedListGraphBase Parent;
 		    typedef Parent::OutArcIt IncEdgeIt;
 		    /// \brief Add a new node to the graph.
 		    ///
 		    /// Add a new node to the graph.
 		    /// \return The new node.

lemon/maps.h

Show inline comments

@@ -1835,12 +1835,13 @@
 		  /// \see RangeIdMap
 		  template <typename GR, typename K>
 		  class IdMap : public MapBase<K, int> {
 		  public:
 		    /// The graph type of IdMap.
 		    typedef GR Graph;
 		    typedef GR Digraph;
 		    /// The key type of IdMap (\c Node, \c Arc or \c Edge).
 		    typedef K Item;
 		    /// The key type of IdMap (\c Node, \c Arc or \c Edge).
 		    typedef K Key;
 		    /// The value type of IdMap.
 		    typedef int Value;
@@ -1926,12 +1927,13 @@
 		    Container _inv_map;
 		  public:
 		    /// The graph type of CrossRefMap.
 		    typedef GR Graph;
 		    typedef GR Digraph;
 		    /// The key type of CrossRefMap (\c Node, \c Arc or \c Edge).
 		    typedef K Item;
 		    /// The key type of CrossRefMap (\c Node, \c Arc or \c Edge).
 		    typedef K Key;
 		    /// The value type of CrossRefMap.
 		    typedef V Value;
@@ -2129,12 +2131,13 @@
 		    typedef typename ItemSetTraits<GR, K>::template Map<int>::Type Map;
 		  public:
 		    /// The graph type of RangeIdMap.
 		    typedef GR Graph;
 		    typedef GR Digraph;
 		    /// The key type of RangeIdMap (\c Node, \c Arc or \c Edge).
 		    typedef K Item;
 		    /// The key type of RangeIdMap (\c Node, \c Arc or \c Edge).
 		    typedef K Key;
 		    /// The value type of RangeIdMap.
 		    typedef int Value;
@@ -2491,13 +2494,14 @@
 		  class InDegMap
 		    : protected ItemSetTraits<GR, typename GR::Arc>
 		      ::ItemNotifier::ObserverBase {
 		  public:
-		    /// The digraph type
+		    /// The graph type of InDegMap
 		    typedef GR Graph;
 		    typedef GR Digraph;
 		    /// The key type
 		    typedef typename Digraph::Node Key;
 		    /// The value type
 		    typedef int Value;
@@ -2620,13 +2624,14 @@
 		  class OutDegMap
 		    : protected ItemSetTraits<GR, typename GR::Arc>
 		      ::ItemNotifier::ObserverBase {
 		  public:
-		    /// The digraph type
+		    /// The graph type of OutDegMap
 		    typedef GR Graph;
 		    typedef GR Digraph;
 		    /// The key type
 		    typedef typename Digraph::Node Key;
 		    /// The value type
 		    typedef int Value;

lemon/smart_graph.h

Show inline comments

@@ -52,13 +52,13 @@
 		    std::vector<NodeT> nodes;
 		    std::vector<ArcT> arcs;
 		  public:
-		    typedef SmartDigraphBase Graph;
+		    typedef SmartDigraphBase Digraph;
 		    class Node;
 		    class Arc;
 		  public:
@@ -192,14 +192,12 @@
 		  ///that <b> it does support only limited (only stack-like)
 		  ///node and arc deletions</b>.
 		  ///It fully conforms to the \ref concepts::Digraph "Digraph concept".
 		  ///
 		  ///\sa concepts::Digraph.
 		  class SmartDigraph : public ExtendedSmartDigraphBase {
 		  public:
 		    typedef ExtendedSmartDigraphBase Parent;
 		  private:
 		    ///SmartDigraph is \e not copy constructible. Use DigraphCopy() instead.
@@ -417,13 +415,13 @@
 		    std::vector<ArcT> arcs;
 		    int first_free_arc;
 		  public:
-		    typedef SmartGraphBase Digraph;
+		    typedef SmartGraphBase Graph;
 		    class Node;
 		    class Arc;
 		    class Edge;
 		    class Node {
@@ -628,12 +626,14 @@
 		  /// that <b> it does support only limited (only stack-like)
 		  /// node and arc deletions</b>.
 		  /// It fully conforms to the \ref concepts::Graph "Graph concept".
 		  ///
 		  /// \sa concepts::Graph.
 		  class SmartGraph : public ExtendedSmartGraphBase {
 		    typedef ExtendedSmartGraphBase Parent;
 		  private:
 		    ///SmartGraph is \e not copy constructible. Use GraphCopy() instead.
 		    ///SmartGraph is \e not copy constructible. Use GraphCopy() instead.
 		    ///
@@ -645,14 +645,12 @@
 		    ///Assignment of SmartGraph to another one is \e not allowed.
 		    ///Use GraphCopy() instead.
 		    void operator=(const SmartGraph &) {}
 		  public:
 		    typedef ExtendedSmartGraphBase Parent;
 		    /// Constructor
 		    /// Constructor.
 		    ///
 		    SmartGraph() {}

0 comments (0 inline)

RhodeCode

Login to your account