LEMON/LEMON-main Changeset - r617:4137ef9aacc6

Repositories » LEMON » LEMON-main

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

Changeset - r617:4137ef9aacc6

« 616:f2d6d3

618:b95898 »

r617: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 297 insertions and 276 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

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2009
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_ADAPTORS_H
 		#define LEMON_ADAPTORS_H
 		/// \ingroup graph_adaptors
 		/// \file
 		/// \brief Adaptor classes for digraphs and graphs
 		///
 		/// This file contains several useful adaptors for digraphs and graphs.
 		#include <lemon/core.h>
 		#include <lemon/maps.h>
 		#include <lemon/bits/variant.h>
 		#include <lemon/bits/graph_adaptor_extender.h>
 		#include <lemon/bits/map_extender.h>
 		#include <lemon/tolerance.h>
 		#include <algorithm>
 		namespace lemon {
 		#ifdef _MSC_VER
 		#define LEMON_SCOPE_FIX(OUTER, NESTED) OUTER::NESTED
 		#else
 		#define LEMON_SCOPE_FIX(OUTER, NESTED) typename OUTER::template NESTED
 		#endif
 		  template<typename DGR>
 		  class DigraphAdaptorBase {
 		  public:
 		    typedef DGR Digraph;
 		    typedef DigraphAdaptorBase Adaptor;
 		  protected:
 		    DGR* _digraph;
 		    DigraphAdaptorBase() : _digraph(0) { }
 		    void initialize(DGR& digraph) { _digraph = &digraph; }
 		  public:
 		    DigraphAdaptorBase(DGR& digraph) : _digraph(&digraph) { }
 		    typedef typename DGR::Node Node;
 		    typedef typename DGR::Arc Arc;
 		    void first(Node& i) const { _digraph->first(i); }
 		    void first(Arc& i) const { _digraph->first(i); }
 		    void firstIn(Arc& i, const Node& n) const { _digraph->firstIn(i, n); }
 		    void firstOut(Arc& i, const Node& n ) const { _digraph->firstOut(i, n); }
 		    void next(Node& i) const { _digraph->next(i); }
 		    void next(Arc& i) const { _digraph->next(i); }
 		    void nextIn(Arc& i) const { _digraph->nextIn(i); }
 		    void nextOut(Arc& i) const { _digraph->nextOut(i); }
 		    Node source(const Arc& a) const { return _digraph->source(a); }
 		    Node target(const Arc& a) const { return _digraph->target(a); }
 		    typedef NodeNumTagIndicator<DGR> NodeNumTag;
 		    int nodeNum() const { return _digraph->nodeNum(); }
 		    typedef ArcNumTagIndicator<DGR> ArcNumTag;
 		    int arcNum() const { return _digraph->arcNum(); }
 		    typedef FindArcTagIndicator<DGR> FindArcTag;
 		    Arc findArc(const Node& u, const Node& v, const Arc& prev = INVALID) const {
 		      return _digraph->findArc(u, v, prev);
+		    }
 		    Node addNode() { return _digraph->addNode(); }
 		    Arc addArc(const Node& u, const Node& v) { return _digraph->addArc(u, v); }
 		    void erase(const Node& n) { _digraph->erase(n); }
 		    void erase(const Arc& a) { _digraph->erase(a); }
 		    void clear() { _digraph->clear(); }
 		    int id(const Node& n) const { return _digraph->id(n); }
 		    int id(const Arc& a) const { return _digraph->id(a); }
 		    Node nodeFromId(int ix) const { return _digraph->nodeFromId(ix); }
 		    Arc arcFromId(int ix) const { return _digraph->arcFromId(ix); }
 		    int maxNodeId() const { return _digraph->maxNodeId(); }
 		    int maxArcId() const { return _digraph->maxArcId(); }
 		    typedef typename ItemSetTraits<DGR, Node>::ItemNotifier NodeNotifier;
 		    NodeNotifier& notifier(Node) const { return _digraph->notifier(Node()); }
 		    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);
+		      }
 		      template <typename CMap>
 		      NodeMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		    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);
+		      }
 		      template <typename CMap>
 		      ArcMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		  };
 		  template<typename GR>
 		  class GraphAdaptorBase {
 		  public:
 		    typedef GR Graph;
 		  protected:
 		    GR* _graph;
 		    GraphAdaptorBase() : _graph(0) {}
 		    void initialize(GR& graph) { _graph = &graph; }
 		  public:
 		    GraphAdaptorBase(GR& graph) : _graph(&graph) {}
 		    typedef typename GR::Node Node;
 		    typedef typename GR::Arc Arc;
 		    typedef typename GR::Edge Edge;
 		    void first(Node& i) const { _graph->first(i); }
 		    void first(Arc& i) const { _graph->first(i); }
 		    void first(Edge& i) const { _graph->first(i); }
 		    void firstIn(Arc& i, const Node& n) const { _graph->firstIn(i, n); }
 		    void firstOut(Arc& i, const Node& n ) const { _graph->firstOut(i, n); }
 		    void firstInc(Edge &i, bool &d, const Node &n) const {
 		      _graph->firstInc(i, d, n);
+		    }
 		    void next(Node& i) const { _graph->next(i); }
 		    void next(Arc& i) const { _graph->next(i); }
 		    void next(Edge& i) const { _graph->next(i); }
 		    void nextIn(Arc& i) const { _graph->nextIn(i); }
 		    void nextOut(Arc& i) const { _graph->nextOut(i); }
 		    void nextInc(Edge &i, bool &d) const { _graph->nextInc(i, d); }
 		    Node u(const Edge& e) const { return _graph->u(e); }
 		    Node v(const Edge& e) const { return _graph->v(e); }
 		    Node source(const Arc& a) const { return _graph->source(a); }
 		    Node target(const Arc& a) const { return _graph->target(a); }
 		    typedef NodeNumTagIndicator<Graph> NodeNumTag;
 		    int nodeNum() const { return _graph->nodeNum(); }
 		    typedef ArcNumTagIndicator<Graph> ArcNumTag;
 		    int arcNum() const { return _graph->arcNum(); }
 		    typedef EdgeNumTagIndicator<Graph> EdgeNumTag;
 		    int edgeNum() const { return _graph->edgeNum(); }
 		    typedef FindArcTagIndicator<Graph> FindArcTag;
 		    Arc findArc(const Node& u, const Node& v,
 		                const Arc& prev = INVALID) const {
 		      return _graph->findArc(u, v, prev);
+		    }
 		    typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
 		    Edge findEdge(const Node& u, const Node& v,
 		                  const Edge& prev = INVALID) const {
 		      return _graph->findEdge(u, v, prev);
+		    }
 		    Node addNode() { return _graph->addNode(); }
 		    Edge addEdge(const Node& u, const Node& v) { return _graph->addEdge(u, v); }
 		    void erase(const Node& i) { _graph->erase(i); }
 		    void erase(const Edge& i) { _graph->erase(i); }
 		    void clear() { _graph->clear(); }
 		    bool direction(const Arc& a) const { return _graph->direction(a); }
 		    Arc direct(const Edge& e, bool d) const { return _graph->direct(e, d); }
 		    int id(const Node& v) const { return _graph->id(v); }
 		    int id(const Arc& a) const { return _graph->id(a); }
 		    int id(const Edge& e) const { return _graph->id(e); }
 		    Node nodeFromId(int ix) const { return _graph->nodeFromId(ix); }
 		    Arc arcFromId(int ix) const { return _graph->arcFromId(ix); }
 		    Edge edgeFromId(int ix) const { return _graph->edgeFromId(ix); }
 		    int maxNodeId() const { return _graph->maxNodeId(); }
 		    int maxArcId() const { return _graph->maxArcId(); }
 		    int maxEdgeId() const { return _graph->maxEdgeId(); }
 		    typedef typename ItemSetTraits<GR, Node>::ItemNotifier NodeNotifier;
 		    NodeNotifier& notifier(Node) const { return _graph->notifier(Node()); }
 		    typedef typename ItemSetTraits<GR, Arc>::ItemNotifier ArcNotifier;
 		    ArcNotifier& notifier(Arc) const { return _graph->notifier(Arc()); }
 		    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:
 		      NodeMap& operator=(const NodeMap& cmap) {
 		        return operator=<NodeMap>(cmap);
+		      }
 		      template <typename CMap>
 		      NodeMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		    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:
 		      ArcMap& operator=(const ArcMap& cmap) {
 		        return operator=<ArcMap>(cmap);
+		      }
 		      template <typename CMap>
 		      ArcMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        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:
 		      EdgeMap& operator=(const EdgeMap& cmap) {
 		        return operator=<EdgeMap>(cmap);
+		      }
 		      template <typename CMap>
 		      EdgeMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		  };
 		  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;
 		    void firstIn(Arc& a, const Node& n) const { Parent::firstOut(a, n); }
 		    void firstOut(Arc& a, const Node& n ) const { Parent::firstIn(a, n); }
 		    void nextIn(Arc& a) const { Parent::nextOut(a); }
 		    void nextOut(Arc& a) const { Parent::nextIn(a); }
 		    Node source(const Arc& a) const { return Parent::target(a); }
 		    Node target(const Arc& a) const { return Parent::source(a); }
 		    Arc addArc(const Node& u, const Node& v) { return Parent::addArc(v, u); }
 		    typedef FindArcTagIndicator<DGR> FindArcTag;
 		    Arc findArc(const Node& u, const Node& v,
 		                const Arc& prev = INVALID) const {
 		      return Parent::findArc(v, u, prev);
+		    }
 		  };
 		  /// \ingroup graph_adaptors
 		  ///
 		  /// \brief Adaptor class for reversing the orientation of the arcs in
 		  /// a digraph.
 		  ///
 		  /// ReverseDigraph can be used for reversing the arcs in a digraph.
 		  /// It conforms to the \ref concepts::Digraph "Digraph" concept.
 		  ///
 		  /// The adapted digraph can also be modified through this adaptor
 		  /// by adding or removing nodes or arcs, unless the \c GR template
 		  /// parameter is set to be \c const.
 		  ///
 		  /// \tparam DGR The type of the adapted digraph.
 		  /// It must conform to the \ref concepts::Digraph "Digraph" concept.
 		  /// It can also be specified to be \c const.
 		  ///
 		  /// \note The \c Node and \c Arc types of this adaptor and the adapted
 		  /// digraph are convertible to each other.
 		  template<typename DGR>
 		#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
 		    ///
 		    /// Creates a reverse digraph adaptor for the given digraph.
 		    explicit ReverseDigraph(DGR& digraph) {
 		      Parent::initialize(digraph);
+		    }
 		  };
 		  /// \brief Returns a read-only ReverseDigraph adaptor
 		  ///
 		  /// This function just returns a read-only \ref ReverseDigraph adaptor.
 		  /// \ingroup graph_adaptors
 		  /// \relates ReverseDigraph
 		  template<typename DGR>
 		  ReverseDigraph<const DGR> reverseDigraph(const DGR& digraph) {
 		    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) { }
 		    void initialize(DGR& digraph, NF& node_filter, AF& arc_filter) {
 		      Parent::initialize(digraph);
 		      _node_filter = &node_filter;
 		      _arc_filter = &arc_filter;
+		    }
 		  public:
 		    typedef typename Parent::Node Node;
 		    typedef typename Parent::Arc Arc;
 		    void first(Node& i) const {
 		      Parent::first(i);
 		      while (i != INVALID && !(*_node_filter)[i]) Parent::next(i);
+		    }
 		    void first(Arc& i) const {
 		      Parent::first(i);
 		      while (i != INVALID && (!(*_arc_filter)[i]
 		                              || !(*_node_filter)[Parent::source(i)]
 		                              || !(*_node_filter)[Parent::target(i)]))
 		        Parent::next(i);
+		    }
 		    void firstIn(Arc& i, const Node& n) const {
 		      Parent::firstIn(i, n);
 		      while (i != INVALID && (!(*_arc_filter)[i]
 		                              || !(*_node_filter)[Parent::source(i)]))
 		        Parent::nextIn(i);
+		    }
 		    void firstOut(Arc& i, const Node& n) const {
 		      Parent::firstOut(i, n);
 		      while (i != INVALID && (!(*_arc_filter)[i]
 		                              || !(*_node_filter)[Parent::target(i)]))
 		        Parent::nextOut(i);
+		    }
 		    void next(Node& i) const {
 		      Parent::next(i);
 		      while (i != INVALID && !(*_node_filter)[i]) Parent::next(i);
+		    }
 		    void next(Arc& i) const {
 		      Parent::next(i);
 		      while (i != INVALID && (!(*_arc_filter)[i]
 		                              || !(*_node_filter)[Parent::source(i)]
 		                              || !(*_node_filter)[Parent::target(i)]))
 		        Parent::next(i);
+		    }
 		    void nextIn(Arc& i) const {
 		      Parent::nextIn(i);
 		      while (i != INVALID && (!(*_arc_filter)[i]
 		                              || !(*_node_filter)[Parent::source(i)]))
 		        Parent::nextIn(i);
+		    }
 		    void nextOut(Arc& i) const {
 		      Parent::nextOut(i);
 		      while (i != INVALID && (!(*_arc_filter)[i]
 		                              || !(*_node_filter)[Parent::target(i)]))
 		        Parent::nextOut(i);
+		    }
 		    void status(const Node& n, bool v) const { _node_filter->set(n, v); }
 		    void status(const Arc& a, bool v) const { _arc_filter->set(a, v); }
 		    bool status(const Node& n) const { return (*_node_filter)[n]; }
 		    bool status(const Arc& a) const { return (*_arc_filter)[a]; }
 		    typedef False NodeNumTag;
 		    typedef False ArcNumTag;
 		    typedef FindArcTagIndicator<DGR> FindArcTag;
 		    Arc findArc(const Node& source, const Node& target,
 		                const Arc& prev = INVALID) const {
 		      if (!(*_node_filter)[source] || !(*_node_filter)[target]) {
 		        return INVALID;
+		      }
 		      Arc arc = Parent::findArc(source, target, prev);
 		      while (arc != INVALID && !(*_arc_filter)[arc]) {
 		        arc = Parent::findArc(source, target, arc);
+		      }
 		      return arc;
+		    }
 		  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) {}
 		    private:
 		      NodeMap& operator=(const NodeMap& cmap) {
 		        return operator=<NodeMap>(cmap);
+		      }
 		      template <typename CMap>
 		      NodeMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		    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) {}
 		    private:
 		      ArcMap& operator=(const ArcMap& cmap) {
 		        return operator=<ArcMap>(cmap);
+		      }
 		      template <typename CMap>
 		      ArcMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		  };
 		  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) { }
 		    void initialize(DGR& digraph, NF& node_filter, AF& arc_filter) {
 		      Parent::initialize(digraph);
 		      _node_filter = &node_filter;
 		      _arc_filter = &arc_filter;
+		    }
 		  public:
 		    typedef typename Parent::Node Node;
 		    typedef typename Parent::Arc Arc;
 		    void first(Node& i) const {
 		      Parent::first(i);
 		      while (i!=INVALID && !(*_node_filter)[i]) Parent::next(i);
+		    }
 		    void first(Arc& i) const {
 		      Parent::first(i);
 		      while (i!=INVALID && !(*_arc_filter)[i]) Parent::next(i);
+		    }
 		    void firstIn(Arc& i, const Node& n) const {
 		      Parent::firstIn(i, n);
 		      while (i!=INVALID && !(*_arc_filter)[i]) Parent::nextIn(i);
+		    }
 		    void firstOut(Arc& i, const Node& n) const {
 		      Parent::firstOut(i, n);
 		      while (i!=INVALID && !(*_arc_filter)[i]) Parent::nextOut(i);
+		    }
 		    void next(Node& i) const {
 		      Parent::next(i);
 		      while (i!=INVALID && !(*_node_filter)[i]) Parent::next(i);
+		    }
 		    void next(Arc& i) const {
 		      Parent::next(i);
 		      while (i!=INVALID && !(*_arc_filter)[i]) Parent::next(i);
+		    }
 		    void nextIn(Arc& i) const {
 		      Parent::nextIn(i);
 		      while (i!=INVALID && !(*_arc_filter)[i]) Parent::nextIn(i);
+		    }
 		    void nextOut(Arc& i) const {
 		      Parent::nextOut(i);
 		      while (i!=INVALID && !(*_arc_filter)[i]) Parent::nextOut(i);
+		    }
 		    void status(const Node& n, bool v) const { _node_filter->set(n, v); }
 		    void status(const Arc& a, bool v) const { _arc_filter->set(a, v); }
 		    bool status(const Node& n) const { return (*_node_filter)[n]; }
 		    bool status(const Arc& a) const { return (*_arc_filter)[a]; }
 		    typedef False NodeNumTag;
 		    typedef False ArcNumTag;
 		    typedef FindArcTagIndicator<DGR> FindArcTag;
 		    Arc findArc(const Node& source, const Node& target,
 		                const Arc& prev = INVALID) const {
 		      if (!(*_node_filter)[source] || !(*_node_filter)[target]) {
 		        return INVALID;
+		      }
 		      Arc arc = Parent::findArc(source, target, prev);
 		      while (arc != INVALID && !(*_arc_filter)[arc]) {
 		        arc = Parent::findArc(source, target, arc);
+		      }
 		      return arc;
+		    }
 		    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) {}
 		    private:
 		      NodeMap& operator=(const NodeMap& cmap) {
 		        return operator=<NodeMap>(cmap);
+		      }
 		      template <typename CMap>
 		      NodeMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		    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) {}
 		    private:
 		      ArcMap& operator=(const ArcMap& cmap) {
 		        return operator=<ArcMap>(cmap);
+		      }
 		      template <typename CMap>
 		      ArcMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		  };
 		  /// \ingroup graph_adaptors
 		  ///
 		  /// \brief Adaptor class for hiding nodes and arcs in a digraph
 		  ///
 		  /// SubDigraph can be used for hiding nodes and arcs in a digraph.
 		  /// A \c bool node map and a \c bool arc map must be specified, which
 		  /// define the filters for nodes and arcs.
 		  /// Only the nodes and arcs with \c true filter value are
 		  /// shown in the subdigraph. The arcs that are incident to hidden
 		  /// nodes are also filtered out.
 		  /// This adaptor conforms to the \ref concepts::Digraph "Digraph" concept.
 		  ///
 		  /// The adapted digraph can also be modified through this adaptor
 		  /// by adding or removing nodes or arcs, unless the \c GR template
 		  /// parameter is set to be \c const.
 		  ///
 		  /// \tparam DGR The type of the adapted digraph.
 		  /// It must conform to the \ref concepts::Digraph "Digraph" concept.
 		  /// It can also be specified to be \c const.
 		  /// \tparam NF The type of the node filter map.
 		  /// It must be a \c bool (or convertible) node map of the
 		  /// adapted digraph. The default type is
 		  /// \ref concepts::Digraph::NodeMap "DGR::NodeMap<bool>".
 		  /// \tparam AF The type of the arc filter map.
 		  /// It must be \c bool (or convertible) arc map of the
 		  /// adapted digraph. The default type is
 		  /// \ref concepts::Digraph::ArcMap "DGR::ArcMap<bool>".
 		  ///
 		  /// \note The \c Node and \c Arc types of this adaptor and the adapted
 		  /// digraph are convertible to each other.
 		  ///
 		  /// \see FilterNodes
 		  /// \see FilterArcs
 		#ifdef DOXYGEN
 		  template<typename DGR, typename NF, typename AF>
 		  class SubDigraph {
 		#else
 		  template<typename DGR,
 		           typename NF = typename DGR::template NodeMap<bool>,
 		           typename AF = typename DGR::template ArcMap<bool> >
 		  class SubDigraph :
 		    public DigraphAdaptorExtender<SubDigraphBase<DGR, NF, AF, true> > {
 		#endif
 		  public:
 		    /// The type of the adapted digraph.
 		    typedef DGR Digraph;
 		    /// The type of the node filter map.
 		    typedef NF NodeFilterMap;
 		    /// The type of the arc filter map.
 		    typedef AF ArcFilterMap;
 		    typedef DigraphAdaptorExtender<SubDigraphBase<DGR, NF, AF, true> >
 		      Parent;
 		    typedef typename Parent::Node Node;
 		    typedef typename Parent::Arc Arc;
 		  protected:
 		    SubDigraph() { }
 		  public:
 		    /// \brief Constructor
 		    ///
 		    /// Creates a subdigraph for the given digraph with the
 		    /// given node and arc filter maps.
 		    SubDigraph(DGR& digraph, NF& node_filter, AF& arc_filter) {
 		      Parent::initialize(digraph, node_filter, arc_filter);
+		    }
 		    /// \brief Sets the status of the given node
 		    ///
 		    /// This function sets the status of the given node.
 		    /// It is done by simply setting the assigned value of \c n
 		    /// to \c v in the node filter map.
 		    void status(const Node& n, bool v) const { Parent::status(n, v); }
 		    /// \brief Sets the status of the given arc
 		    ///
 		    /// This function sets the status of the given arc.
 		    /// It is done by simply setting the assigned value of \c a
 		    /// to \c v in the arc filter map.
 		    void status(const Arc& a, bool v) const { Parent::status(a, v); }
 		    /// \brief Returns the status of the given node
 		    ///
 		    /// This function returns the status of the given node.
 		    /// It is \c true if the given node is enabled (i.e. not hidden).
 		    bool status(const Node& n) const { return Parent::status(n); }
 		    /// \brief Returns the status of the given arc
 		    ///
 		    /// This function returns the status of the given arc.
 		    /// It is \c true if the given arc is enabled (i.e. not hidden).
 		    bool status(const Arc& a) const { return Parent::status(a); }
 		    /// \brief Disables the given node
 		    ///
 		    /// This function disables the given node in the subdigraph,
 		    /// so the iteration jumps over it.
 		    /// It is the same as \ref status() "status(n, false)".
 		    void disable(const Node& n) const { Parent::status(n, false); }
 		    /// \brief Disables the given arc
 		    ///
 		    /// This function disables the given arc in the subdigraph,
 		    /// so the iteration jumps over it.
 		    /// It is the same as \ref status() "status(a, false)".
 		    void disable(const Arc& a) const { Parent::status(a, false); }
 		    /// \brief Enables the given node
 		    ///
 		    /// This function enables the given node in the subdigraph.
 		    /// It is the same as \ref status() "status(n, true)".
 		    void enable(const Node& n) const { Parent::status(n, true); }
 		    /// \brief Enables the given arc
 		    ///
 		    /// This function enables the given arc in the subdigraph.
 		    /// It is the same as \ref status() "status(a, true)".
 		    void enable(const Arc& a) const { Parent::status(a, true); }
 		  };
 		  /// \brief Returns a read-only SubDigraph adaptor
 		  ///
 		  /// This function just returns a read-only \ref SubDigraph adaptor.
 		  /// \ingroup graph_adaptors
 		  /// \relates SubDigraph
 		  template<typename DGR, typename NF, typename AF>
 		  SubDigraph<const DGR, NF, AF>
 		  subDigraph(const DGR& digraph,
 		             NF& node_filter, AF& arc_filter) {
 		    return SubDigraph<const DGR, NF, AF>
 		      (digraph, node_filter, arc_filter);
+		  }
 		  template<typename DGR, typename NF, typename AF>
 		  SubDigraph<const DGR, const NF, AF>
 		  subDigraph(const DGR& digraph,
 		             const NF& node_filter, AF& arc_filter) {
 		    return SubDigraph<const DGR, const NF, AF>
 		      (digraph, node_filter, arc_filter);
+		  }
 		  template<typename DGR, typename NF, typename AF>
 		  SubDigraph<const DGR, NF, const AF>
 		  subDigraph(const DGR& digraph,
 		             NF& node_filter, const AF& arc_filter) {
 		    return SubDigraph<const DGR, NF, const AF>
 		      (digraph, node_filter, arc_filter);
+		  }
 		  template<typename DGR, typename NF, typename AF>
 		  SubDigraph<const DGR, const NF, const AF>
 		  subDigraph(const DGR& digraph,
 		             const NF& node_filter, const AF& arc_filter) {
 		    return SubDigraph<const DGR, const NF, const AF>
 		      (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()
 		      : Parent(), _node_filter(0), _edge_filter(0) { }
 		    void initialize(GR& graph, NF& node_filter, EF& edge_filter) {
 		      Parent::initialize(graph);
 		      _node_filter = &node_filter;
 		      _edge_filter = &edge_filter;
+		    }
 		  public:
 		    typedef typename Parent::Node Node;
 		    typedef typename Parent::Arc Arc;
 		    typedef typename Parent::Edge Edge;
 		    void first(Node& i) const {
 		      Parent::first(i);
 		      while (i!=INVALID && !(*_node_filter)[i]) Parent::next(i);
+		    }
 		    void first(Arc& i) const {
 		      Parent::first(i);
 		      while (i!=INVALID && (!(*_edge_filter)[i]
 		                            || !(*_node_filter)[Parent::source(i)]
 		                            || !(*_node_filter)[Parent::target(i)]))
 		        Parent::next(i);
+		    }
 		    void first(Edge& i) const {
 		      Parent::first(i);
 		      while (i!=INVALID && (!(*_edge_filter)[i]
 		                            || !(*_node_filter)[Parent::u(i)]
 		                            || !(*_node_filter)[Parent::v(i)]))
 		        Parent::next(i);
+		    }
 		    void firstIn(Arc& i, const Node& n) const {
 		      Parent::firstIn(i, n);
 		      while (i!=INVALID && (!(*_edge_filter)[i]
 		                            || !(*_node_filter)[Parent::source(i)]))
 		        Parent::nextIn(i);
+		    }
 		    void firstOut(Arc& i, const Node& n) const {
 		      Parent::firstOut(i, n);
 		      while (i!=INVALID && (!(*_edge_filter)[i]
 		                            || !(*_node_filter)[Parent::target(i)]))
 		        Parent::nextOut(i);
+		    }
 		    void firstInc(Edge& i, bool& d, const Node& n) const {
 		      Parent::firstInc(i, d, n);
 		      while (i!=INVALID && (!(*_edge_filter)[i]
 		                            || !(*_node_filter)[Parent::u(i)]
 		                            || !(*_node_filter)[Parent::v(i)]))
 		        Parent::nextInc(i, d);
+		    }
 		    void next(Node& i) const {
 		      Parent::next(i);
 		      while (i!=INVALID && !(*_node_filter)[i]) Parent::next(i);
+		    }
 		    void next(Arc& i) const {
 		      Parent::next(i);
 		      while (i!=INVALID && (!(*_edge_filter)[i]
 		                            || !(*_node_filter)[Parent::source(i)]
 		                            || !(*_node_filter)[Parent::target(i)]))
 		        Parent::next(i);
+		    }
 		    void next(Edge& i) const {
 		      Parent::next(i);
 		      while (i!=INVALID && (!(*_edge_filter)[i]
 		                            || !(*_node_filter)[Parent::u(i)]
 		                            || !(*_node_filter)[Parent::v(i)]))
 		        Parent::next(i);
+		    }
 		    void nextIn(Arc& i) const {
 		      Parent::nextIn(i);
 		      while (i!=INVALID && (!(*_edge_filter)[i]
 		                            || !(*_node_filter)[Parent::source(i)]))
 		        Parent::nextIn(i);
+		    }
 		    void nextOut(Arc& i) const {
 		      Parent::nextOut(i);
 		      while (i!=INVALID && (!(*_edge_filter)[i]
 		                            || !(*_node_filter)[Parent::target(i)]))
 		        Parent::nextOut(i);
+		    }
 		    void nextInc(Edge& i, bool& d) const {
 		      Parent::nextInc(i, d);
 		      while (i!=INVALID && (!(*_edge_filter)[i]
 		                            || !(*_node_filter)[Parent::u(i)]
 		                            || !(*_node_filter)[Parent::v(i)]))
 		        Parent::nextInc(i, d);
+		    }
 		    void status(const Node& n, bool v) const { _node_filter->set(n, v); }
 		    void status(const Edge& e, bool v) const { _edge_filter->set(e, v); }
 		    bool status(const Node& n) const { return (*_node_filter)[n]; }
 		    bool status(const Edge& e) const { return (*_edge_filter)[e]; }
 		    typedef False NodeNumTag;
 		    typedef False ArcNumTag;
 		    typedef False EdgeNumTag;
 		    typedef FindArcTagIndicator<Graph> FindArcTag;
 		    Arc findArc(const Node& u, const Node& v,
 		                const Arc& prev = INVALID) const {
 		      if (!(*_node_filter)[u] || !(*_node_filter)[v]) {
 		        return INVALID;
+		      }
 		      Arc arc = Parent::findArc(u, v, prev);
 		      while (arc != INVALID && !(*_edge_filter)[arc]) {
 		        arc = Parent::findArc(u, v, arc);
+		      }
 		      return arc;
+		    }
 		    typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
 		    Edge findEdge(const Node& u, const Node& v,
 		                  const Edge& prev = INVALID) const {
 		      if (!(*_node_filter)[u] || !(*_node_filter)[v]) {
 		        return INVALID;
+		      }
 		      Edge edge = Parent::findEdge(u, v, prev);
 		      while (edge != INVALID && !(*_edge_filter)[edge]) {
 		        edge = Parent::findEdge(u, v, edge);
+		      }
 		      return edge;
+		    }
 		    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) {}
 		    private:
 		      NodeMap& operator=(const NodeMap& cmap) {
 		        return operator=<NodeMap>(cmap);
+		      }
 		      template <typename CMap>
 		      NodeMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		    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) {}
 		    private:
 		      ArcMap& operator=(const ArcMap& cmap) {
 		        return operator=<ArcMap>(cmap);
+		      }
 		      template <typename CMap>
 		      ArcMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		    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) {}
 		    private:
 		      EdgeMap& operator=(const EdgeMap& cmap) {
 		        return operator=<EdgeMap>(cmap);
+		      }
 		      template <typename CMap>
 		      EdgeMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		  };
 		  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) { }
 		    void initialize(GR& graph, NF& node_filter, EF& edge_filter) {
 		      Parent::initialize(graph);
 		      _node_filter = &node_filter;
 		      _edge_filter = &edge_filter;
+		    }
 		  public:
 		    typedef typename Parent::Node Node;
 		    typedef typename Parent::Arc Arc;
 		    typedef typename Parent::Edge Edge;
 		    void first(Node& i) const {
 		      Parent::first(i);
 		      while (i!=INVALID && !(*_node_filter)[i]) Parent::next(i);
+		    }
 		    void first(Arc& i) const {
 		      Parent::first(i);
 		      while (i!=INVALID && !(*_edge_filter)[i]) Parent::next(i);
+		    }
 		    void first(Edge& i) const {
 		      Parent::first(i);
 		      while (i!=INVALID && !(*_edge_filter)[i]) Parent::next(i);
+		    }
 		    void firstIn(Arc& i, const Node& n) const {
 		      Parent::firstIn(i, n);
 		      while (i!=INVALID && !(*_edge_filter)[i]) Parent::nextIn(i);
+		    }
 		    void firstOut(Arc& i, const Node& n) const {
 		      Parent::firstOut(i, n);
 		      while (i!=INVALID && !(*_edge_filter)[i]) Parent::nextOut(i);
+		    }
 		    void firstInc(Edge& i, bool& d, const Node& n) const {
 		      Parent::firstInc(i, d, n);
 		      while (i!=INVALID && !(*_edge_filter)[i]) Parent::nextInc(i, d);
+		    }
 		    void next(Node& i) const {
 		      Parent::next(i);
 		      while (i!=INVALID && !(*_node_filter)[i]) Parent::next(i);
+		    }
 		    void next(Arc& i) const {
 		      Parent::next(i);
 		      while (i!=INVALID && !(*_edge_filter)[i]) Parent::next(i);
+		    }
 		    void next(Edge& i) const {
 		      Parent::next(i);
 		      while (i!=INVALID && !(*_edge_filter)[i]) Parent::next(i);
+		    }
 		    void nextIn(Arc& i) const {
 		      Parent::nextIn(i);
 		      while (i!=INVALID && !(*_edge_filter)[i]) Parent::nextIn(i);
+		    }
 		    void nextOut(Arc& i) const {
 		      Parent::nextOut(i);
 		      while (i!=INVALID && !(*_edge_filter)[i]) Parent::nextOut(i);
+		    }
 		    void nextInc(Edge& i, bool& d) const {
 		      Parent::nextInc(i, d);
 		      while (i!=INVALID && !(*_edge_filter)[i]) Parent::nextInc(i, d);
+		    }
 		    void status(const Node& n, bool v) const { _node_filter->set(n, v); }
 		    void status(const Edge& e, bool v) const { _edge_filter->set(e, v); }
 		    bool status(const Node& n) const { return (*_node_filter)[n]; }
 		    bool status(const Edge& e) const { return (*_edge_filter)[e]; }
 		    typedef False NodeNumTag;
 		    typedef False ArcNumTag;
 		    typedef False EdgeNumTag;
 		    typedef FindArcTagIndicator<Graph> FindArcTag;
 		    Arc findArc(const Node& u, const Node& v,
 		                const Arc& prev = INVALID) const {
 		      Arc arc = Parent::findArc(u, v, prev);
 		      while (arc != INVALID && !(*_edge_filter)[arc]) {
 		        arc = Parent::findArc(u, v, arc);
+		      }
 		      return arc;
+		    }
 		    typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
 		    Edge findEdge(const Node& u, const Node& v,
 		                  const Edge& prev = INVALID) const {
 		      Edge edge = Parent::findEdge(u, v, prev);
 		      while (edge != INVALID && !(*_edge_filter)[edge]) {
 		        edge = Parent::findEdge(u, v, edge);
+		      }
 		      return edge;
+		    }
 		    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) {}
 		    private:
 		      NodeMap& operator=(const NodeMap& cmap) {
 		        return operator=<NodeMap>(cmap);
+		      }
 		      template <typename CMap>
 		      NodeMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		    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) {}
 		    private:
 		      ArcMap& operator=(const ArcMap& cmap) {
 		        return operator=<ArcMap>(cmap);
+		      }
 		      template <typename CMap>
 		      ArcMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		    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) {}
 		    private:
 		      EdgeMap& operator=(const EdgeMap& cmap) {
 		        return operator=<EdgeMap>(cmap);
+		      }
 		      template <typename CMap>
 		      EdgeMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		  };
 		  /// \ingroup graph_adaptors
 		  ///
 		  /// \brief Adaptor class for hiding nodes and edges in an undirected
 		  /// graph.
 		  ///
 		  /// SubGraph can be used for hiding nodes and edges in a graph.
 		  /// A \c bool node map and a \c bool edge map must be specified, which
 		  /// define the filters for nodes and edges.
 		  /// Only the nodes and edges with \c true filter value are
 		  /// shown in the subgraph. The edges that are incident to hidden
 		  /// nodes are also filtered out.
 		  /// This adaptor conforms to the \ref concepts::Graph "Graph" concept.
 		  ///
 		  /// The adapted graph can also be modified through this adaptor
 		  /// by adding or removing nodes or edges, unless the \c GR template
 		  /// parameter is set to be \c const.
 		  ///
 		  /// \tparam GR The type of the adapted graph.
 		  /// It must conform to the \ref concepts::Graph "Graph" concept.
 		  /// It can also be specified to be \c const.
 		  /// \tparam NF The type of the node filter map.
 		  /// It must be a \c bool (or convertible) node map of the
 		  /// adapted graph. The default type is
 		  /// \ref concepts::Graph::NodeMap "GR::NodeMap<bool>".
 		  /// \tparam EF The type of the edge filter map.
 		  /// It must be a \c bool (or convertible) edge map of the
 		  /// adapted graph. The default type is
 		  /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<bool>".
 		  ///
 		  /// \note The \c Node, \c Edge and \c Arc types of this adaptor and the
 		  /// adapted graph are convertible to each other.
 		  ///
 		  /// \see FilterNodes
 		  /// \see FilterEdges
 		#ifdef DOXYGEN
 		  template<typename GR, typename NF, typename EF>
 		  class SubGraph {
 		#else
 		  template<typename GR,
 		           typename NF = typename GR::template NodeMap<bool>,
 		           typename EF = typename GR::template EdgeMap<bool> >
 		  class SubGraph :
 		    public GraphAdaptorExtender<SubGraphBase<GR, NF, EF, true> > {
 		#endif
 		  public:
 		    /// The type of the adapted graph.
 		    typedef GR Graph;
 		    /// The type of the node filter map.
 		    typedef NF NodeFilterMap;
 		    /// The type of the edge filter map.
 		    typedef EF EdgeFilterMap;
 		    typedef GraphAdaptorExtender<SubGraphBase<GR, NF, EF, true> >
 		      Parent;
 		    typedef typename Parent::Node Node;
 		    typedef typename Parent::Edge Edge;
 		  protected:
 		    SubGraph() { }
 		  public:
 		    /// \brief Constructor
 		    ///
 		    /// Creates a subgraph for the given graph with the given node
 		    /// and edge filter maps.
 		    SubGraph(GR& graph, NF& node_filter, EF& edge_filter) {
 		      initialize(graph, node_filter, edge_filter);
+		    }
 		    /// \brief Sets the status of the given node
 		    ///
 		    /// This function sets the status of the given node.
 		    /// It is done by simply setting the assigned value of \c n
 		    /// to \c v in the node filter map.
 		    void status(const Node& n, bool v) const { Parent::status(n, v); }
 		    /// \brief Sets the status of the given edge
 		    ///
 		    /// This function sets the status of the given edge.
 		    /// It is done by simply setting the assigned value of \c e
 		    /// to \c v in the edge filter map.
 		    void status(const Edge& e, bool v) const { Parent::status(e, v); }
 		    /// \brief Returns the status of the given node
 		    ///
 		    /// This function returns the status of the given node.
 		    /// It is \c true if the given node is enabled (i.e. not hidden).
 		    bool status(const Node& n) const { return Parent::status(n); }
 		    /// \brief Returns the status of the given edge
 		    ///
 		    /// This function returns the status of the given edge.
 		    /// It is \c true if the given edge is enabled (i.e. not hidden).
 		    bool status(const Edge& e) const { return Parent::status(e); }
 		    /// \brief Disables the given node
 		    ///
 		    /// This function disables the given node in the subdigraph,
 		    /// so the iteration jumps over it.
 		    /// It is the same as \ref status() "status(n, false)".
 		    void disable(const Node& n) const { Parent::status(n, false); }
 		    /// \brief Disables the given edge
 		    ///
 		    /// This function disables the given edge in the subgraph,
 		    /// so the iteration jumps over it.
 		    /// It is the same as \ref status() "status(e, false)".
 		    void disable(const Edge& e) const { Parent::status(e, false); }
 		    /// \brief Enables the given node
 		    ///
 		    /// This function enables the given node in the subdigraph.
 		    /// It is the same as \ref status() "status(n, true)".
 		    void enable(const Node& n) const { Parent::status(n, true); }
 		    /// \brief Enables the given edge
 		    ///
 		    /// This function enables the given edge in the subgraph.
 		    /// It is the same as \ref status() "status(e, true)".
 		    void enable(const Edge& e) const { Parent::status(e, true); }
 		  };
 		  /// \brief Returns a read-only SubGraph adaptor
 		  ///
 		  /// This function just returns a read-only \ref SubGraph adaptor.
 		  /// \ingroup graph_adaptors
 		  /// \relates SubGraph
 		  template<typename GR, typename NF, typename EF>
 		  SubGraph<const GR, NF, EF>
 		  subGraph(const GR& graph, NF& node_filter, EF& edge_filter) {
 		    return SubGraph<const GR, NF, EF>
 		      (graph, node_filter, edge_filter);
+		  }
 		  template<typename GR, typename NF, typename EF>
 		  SubGraph<const GR, const NF, EF>
 		  subGraph(const GR& graph, const NF& node_filter, EF& edge_filter) {
 		    return SubGraph<const GR, const NF, EF>
 		      (graph, node_filter, edge_filter);
+		  }
 		  template<typename GR, typename NF, typename EF>
 		  SubGraph<const GR, NF, const EF>
 		  subGraph(const GR& graph, NF& node_filter, const EF& edge_filter) {
 		    return SubGraph<const GR, NF, const EF>
 		      (graph, node_filter, edge_filter);
+		  }
 		  template<typename GR, typename NF, typename EF>
 		  SubGraph<const GR, const NF, const EF>
 		  subGraph(const GR& graph, const NF& node_filter, const EF& edge_filter) {
 		    return SubGraph<const GR, const NF, const EF>
 		      (graph, node_filter, edge_filter);
+		  }
 		  /// \ingroup graph_adaptors
 		  ///
 		  /// \brief Adaptor class for hiding nodes in a digraph or a graph.
 		  ///
 		  /// FilterNodes adaptor can be used for hiding nodes in a digraph or a
 		  /// graph. A \c bool node map must be specified, which defines the filter
 		  /// for the nodes. Only the nodes with \c true filter value and the
 		  /// arcs/edges incident to nodes both with \c true filter value are shown
 		  /// in the subgraph. This adaptor conforms to the \ref concepts::Digraph
 		  /// "Digraph" concept or the \ref concepts::Graph "Graph" concept
 		  /// depending on the \c GR template parameter.
 		  ///
 		  /// The adapted (di)graph can also be modified through this adaptor
 		  /// by adding or removing nodes or arcs/edges, unless the \c GR template
 		  /// parameter is set to be \c const.
 		  ///
 		  /// \tparam GR The type of the adapted digraph or graph.
 		  /// It must conform to the \ref concepts::Digraph "Digraph" concept
 		  /// or the \ref concepts::Graph "Graph" concept.
 		  /// It can also be specified to be \c const.
 		  /// \tparam NF The type of the node filter map.
 		  /// It must be a \c bool (or convertible) node map of the
 		  /// adapted (di)graph. The default type is
 		  /// \ref concepts::Graph::NodeMap "GR::NodeMap<bool>".
 		  ///
 		  /// \note The \c Node and <tt>Arc/Edge</tt> types of this adaptor and the
 		  /// adapted (di)graph are convertible to each other.
 		#ifdef DOXYGEN
 		  template<typename GR, typename NF>
 		  class FilterNodes {
 		#else
 		  template<typename GR,
 		           typename NF = typename GR::template NodeMap<bool>,
 		           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() {}
 		  public:
 		    /// \brief Constructor
 		    ///
 		    /// Creates a subgraph for the given digraph or graph with the
 		    /// given node filter map.
 		    FilterNodes(GR& graph, NF& node_filter)
 		      : Parent(), const_true_map()
+		    {
 		      Parent::initialize(graph, node_filter, const_true_map);
+		    }
 		    /// \brief Sets the status of the given node
 		    ///
 		    /// This function sets the status of the given node.
 		    /// It is done by simply setting the assigned value of \c n
 		    /// to \c v in the node filter map.
 		    void status(const Node& n, bool v) const { Parent::status(n, v); }
 		    /// \brief Returns the status of the given node
 		    ///
 		    /// This function returns the status of the given node.
 		    /// It is \c true if the given node is enabled (i.e. not hidden).
 		    bool status(const Node& n) const { return Parent::status(n); }
 		    /// \brief Disables the given node
 		    ///
 		    /// This function disables the given node, so the iteration
 		    /// jumps over it.
 		    /// It is the same as \ref status() "status(n, false)".
 		    void disable(const Node& n) const { Parent::status(n, false); }
 		    /// \brief Enables the given node
 		    ///
 		    /// This function enables the given node.
 		    /// It is the same as \ref status() "status(n, true)".
 		    void enable(const Node& n) const { Parent::status(n, true); }
 		  };
 		  template<typename GR, typename NF>
 		  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:
 		    FilterNodes(GR& graph, NodeFilterMap& node_filter) :
 		      Parent(), const_true_map() {
 		      Parent::initialize(graph, node_filter, const_true_map);
+		    }
 		    void status(const Node& n, bool v) const { Parent::status(n, v); }
 		    bool status(const Node& n) const { return Parent::status(n); }
 		    void disable(const Node& n) const { Parent::status(n, false); }
 		    void enable(const Node& n) const { Parent::status(n, true); }
 		  };
 		  /// \brief Returns a read-only FilterNodes adaptor
 		  ///
 		  /// This function just returns a read-only \ref FilterNodes adaptor.
 		  /// \ingroup graph_adaptors
 		  /// \relates FilterNodes
 		  template<typename GR, typename NF>
 		  FilterNodes<const GR, NF>
 		  filterNodes(const GR& graph, NF& node_filter) {
 		    return FilterNodes<const GR, NF>(graph, node_filter);
+		  }
 		  template<typename GR, typename NF>
 		  FilterNodes<const GR, const NF>
 		  filterNodes(const GR& graph, const NF& node_filter) {
 		    return FilterNodes<const GR, const NF>(graph, node_filter);
+		  }
 		  /// \ingroup graph_adaptors
 		  ///
 		  /// \brief Adaptor class for hiding arcs in a digraph.
 		  ///
 		  /// FilterArcs adaptor can be used for hiding arcs in a digraph.
 		  /// A \c bool arc map must be specified, which defines the filter for
 		  /// the arcs. Only the arcs with \c true filter value are shown in the
 		  /// subdigraph. This adaptor conforms to the \ref concepts::Digraph
 		  /// "Digraph" concept.
 		  ///
 		  /// The adapted digraph can also be modified through this adaptor
 		  /// by adding or removing nodes or arcs, unless the \c GR template
 		  /// parameter is set to be \c const.
 		  ///
 		  /// \tparam DGR The type of the adapted digraph.
 		  /// It must conform to the \ref concepts::Digraph "Digraph" concept.
 		  /// It can also be specified to be \c const.
 		  /// \tparam AF The type of the arc filter map.
 		  /// It must be a \c bool (or convertible) arc map of the
 		  /// adapted digraph. The default type is
 		  /// \ref concepts::Digraph::ArcMap "DGR::ArcMap<bool>".
 		  ///
 		  /// \note The \c Node and \c Arc types of this adaptor and the adapted
 		  /// digraph are convertible to each other.
 		#ifdef DOXYGEN
 		  template<typename DGR,
 		           typename AF>
 		  class FilterArcs {
 		#else
 		  template<typename DGR,
 		           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() {}
 		  public:
 		    /// \brief Constructor
 		    ///
 		    /// Creates a subdigraph for the given digraph with the given arc
 		    /// filter map.
 		    FilterArcs(DGR& digraph, ArcFilterMap& arc_filter)
 		      : Parent(), const_true_map() {
 		      Parent::initialize(digraph, const_true_map, arc_filter);
+		    }
 		    /// \brief Sets the status of the given arc
 		    ///
 		    /// This function sets the status of the given arc.
 		    /// It is done by simply setting the assigned value of \c a
 		    /// to \c v in the arc filter map.
 		    void status(const Arc& a, bool v) const { Parent::status(a, v); }
 		    /// \brief Returns the status of the given arc
 		    ///
 		    /// This function returns the status of the given arc.
 		    /// It is \c true if the given arc is enabled (i.e. not hidden).
 		    bool status(const Arc& a) const { return Parent::status(a); }
 		    /// \brief Disables the given arc
 		    ///
 		    /// This function disables the given arc in the subdigraph,
 		    /// so the iteration jumps over it.
 		    /// It is the same as \ref status() "status(a, false)".
 		    void disable(const Arc& a) const { Parent::status(a, false); }
 		    /// \brief Enables the given arc
 		    ///
 		    /// This function enables the given arc in the subdigraph.
 		    /// It is the same as \ref status() "status(a, true)".
 		    void enable(const Arc& a) const { Parent::status(a, true); }
 		  };
 		  /// \brief Returns a read-only FilterArcs adaptor
 		  ///
 		  /// This function just returns a read-only \ref FilterArcs adaptor.
 		  /// \ingroup graph_adaptors
 		  /// \relates FilterArcs
 		  template<typename DGR, typename AF>
 		  FilterArcs<const DGR, AF>
 		  filterArcs(const DGR& digraph, AF& arc_filter) {
 		    return FilterArcs<const DGR, AF>(digraph, arc_filter);
+		  }
 		  template<typename DGR, typename AF>
 		  FilterArcs<const DGR, const AF>
 		  filterArcs(const DGR& digraph, const AF& arc_filter) {
 		    return FilterArcs<const DGR, const AF>(digraph, arc_filter);
+		  }
 		  /// \ingroup graph_adaptors
 		  ///
 		  /// \brief Adaptor class for hiding edges in a graph.
 		  ///
 		  /// FilterEdges adaptor can be used for hiding edges in a graph.
 		  /// A \c bool edge map must be specified, which defines the filter for
 		  /// the edges. Only the edges with \c true filter value are shown in the
 		  /// subgraph. This adaptor conforms to the \ref concepts::Graph
 		  /// "Graph" concept.
 		  ///
 		  /// The adapted graph can also be modified through this adaptor
 		  /// by adding or removing nodes or edges, unless the \c GR template
 		  /// parameter is set to be \c const.
 		  ///
 		  /// \tparam GR The type of the adapted graph.
 		  /// It must conform to the \ref concepts::Graph "Graph" concept.
 		  /// It can also be specified to be \c const.
 		  /// \tparam EF The type of the edge filter map.
 		  /// It must be a \c bool (or convertible) edge map of the
 		  /// adapted graph. The default type is
 		  /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<bool>".
 		  ///
 		  /// \note The \c Node, \c Edge and \c Arc types of this adaptor and the
 		  /// adapted graph are convertible to each other.
 		#ifdef DOXYGEN
 		  template<typename GR,
 		           typename EF>
 		  class FilterEdges {
 		#else
 		  template<typename GR,
 		           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) {
 		      Parent::setNodeFilterMap(const_true_map);
+		    }
 		  public:
 		    /// \brief Constructor
 		    ///
 		    /// Creates a subgraph for the given graph with the given edge
 		    /// filter map.
 		    FilterEdges(GR& graph, EF& edge_filter)
 		      : Parent(), const_true_map() {
 		      Parent::initialize(graph, const_true_map, edge_filter);
+		    }
 		    /// \brief Sets the status of the given edge
 		    ///
 		    /// This function sets the status of the given edge.
 		    /// It is done by simply setting the assigned value of \c e
 		    /// to \c v in the edge filter map.
 		    void status(const Edge& e, bool v) const { Parent::status(e, v); }
 		    /// \brief Returns the status of the given edge
 		    ///
 		    /// This function returns the status of the given edge.
 		    /// It is \c true if the given edge is enabled (i.e. not hidden).
 		    bool status(const Edge& e) const { return Parent::status(e); }
 		    /// \brief Disables the given edge
 		    ///
 		    /// This function disables the given edge in the subgraph,
 		    /// so the iteration jumps over it.
 		    /// It is the same as \ref status() "status(e, false)".
 		    void disable(const Edge& e) const { Parent::status(e, false); }
 		    /// \brief Enables the given edge
 		    ///
 		    /// This function enables the given edge in the subgraph.
 		    /// It is the same as \ref status() "status(e, true)".
 		    void enable(const Edge& e) const { Parent::status(e, true); }
 		  };
 		  /// \brief Returns a read-only FilterEdges adaptor
 		  ///
 		  /// This function just returns a read-only \ref FilterEdges adaptor.
 		  /// \ingroup graph_adaptors
 		  /// \relates FilterEdges
 		  template<typename GR, typename EF>
 		  FilterEdges<const GR, EF>
 		  filterEdges(const GR& graph, EF& edge_filter) {
 		    return FilterEdges<const GR, EF>(graph, edge_filter);
+		  }
 		  template<typename GR, typename EF>
 		  FilterEdges<const GR, const EF>
 		  filterEdges(const GR& graph, const EF& edge_filter) {
 		    return FilterEdges<const GR, const EF>(graph, edge_filter);
+		  }
 		  template <typename DGR>
 		  class UndirectorBase {
 		  public:
 		    typedef DGR Digraph;
 		    typedef UndirectorBase Adaptor;
 		    typedef True UndirectedTag;
 		    typedef typename Digraph::Arc Edge;
 		    typedef typename Digraph::Node Node;
 		    class Arc : public Edge {
 		      friend class UndirectorBase;
 		    protected:
 		      bool _forward;
 		      Arc(const Edge& edge, bool forward) :
 		        Edge(edge), _forward(forward) {}
 		    public:
 		      Arc() {}
 		      Arc(Invalid) : Edge(INVALID), _forward(true) {}
 		      bool operator==(const Arc &other) const {
 		        return _forward == other._forward &&
 		          static_cast<const Edge&>(*this) == static_cast<const Edge&>(other);
+		      }
 		      bool operator!=(const Arc &other) const {
 		        return _forward != other._forward ||
 		          static_cast<const Edge&>(*this) != static_cast<const Edge&>(other);
+		      }
 		      bool operator<(const Arc &other) const {
 		        return _forward < other._forward ||
 		          (_forward == other._forward &&
 		           static_cast<const Edge&>(*this) < static_cast<const Edge&>(other));
+		      }
 		    };
 		    void first(Node& n) const {
 		      _digraph->first(n);
+		    }
 		    void next(Node& n) const {
 		      _digraph->next(n);
+		    }
 		    void first(Arc& a) const {
 		      _digraph->first(a);
 		      a._forward = true;
+		    }
 		    void next(Arc& a) const {
 		      if (a._forward) {
 		        a._forward = false;
 		      } else {
 		        _digraph->next(a);
 		        a._forward = true;
+		      }
+		    }
 		    void first(Edge& e) const {
 		      _digraph->first(e);
+		    }
 		    void next(Edge& e) const {
 		      _digraph->next(e);
+		    }
 		    void firstOut(Arc& a, const Node& n) const {
 		      _digraph->firstIn(a, n);
 		      if( static_cast<const Edge&>(a) != INVALID ) {
 		        a._forward = false;
 		      } else {
 		        _digraph->firstOut(a, n);
 		        a._forward = true;
+		      }
+		    }
 		    void nextOut(Arc &a) const {
 		      if (!a._forward) {
 		        Node n = _digraph->target(a);
 		        _digraph->nextIn(a);
 		        if (static_cast<const Edge&>(a) == INVALID ) {
 		          _digraph->firstOut(a, n);
 		          a._forward = true;
+		        }
+		      }
 		      else {
 		        _digraph->nextOut(a);
+		      }
+		    }
 		    void firstIn(Arc &a, const Node &n) const {
 		      _digraph->firstOut(a, n);
 		      if (static_cast<const Edge&>(a) != INVALID ) {
 		        a._forward = false;
 		      } else {
 		        _digraph->firstIn(a, n);
 		        a._forward = true;
+		      }
+		    }
 		    void nextIn(Arc &a) const {
 		      if (!a._forward) {
 		        Node n = _digraph->source(a);
 		        _digraph->nextOut(a);
 		        if( static_cast<const Edge&>(a) == INVALID ) {
 		          _digraph->firstIn(a, n);
 		          a._forward = true;
+		        }
+		      }
 		      else {
 		        _digraph->nextIn(a);
+		      }
+		    }
 		    void firstInc(Edge &e, bool &d, const Node &n) const {
 		      d = true;
 		      _digraph->firstOut(e, n);
 		      if (e != INVALID) return;
 		      d = false;
 		      _digraph->firstIn(e, n);
+		    }
 		    void nextInc(Edge &e, bool &d) const {
 		      if (d) {
 		        Node s = _digraph->source(e);
 		        _digraph->nextOut(e);
 		        if (e != INVALID) return;
 		        d = false;
 		        _digraph->firstIn(e, s);
 		      } else {
 		        _digraph->nextIn(e);
+		      }
+		    }
 		    Node u(const Edge& e) const {
 		      return _digraph->source(e);
+		    }
 		    Node v(const Edge& e) const {
 		      return _digraph->target(e);
+		    }
 		    Node source(const Arc &a) const {
 		      return a._forward ? _digraph->source(a) : _digraph->target(a);
+		    }
 		    Node target(const Arc &a) const {
 		      return a._forward ? _digraph->target(a) : _digraph->source(a);
+		    }
 		    static Arc direct(const Edge &e, bool d) {
 		      return Arc(e, d);
+		    }
 		    Arc direct(const Edge &e, const Node& n) const {
 		      return Arc(e, _digraph->source(e) == n);
+		    }
 		    static bool direction(const Arc &a) { return a._forward; }
 		    Node nodeFromId(int ix) const { return _digraph->nodeFromId(ix); }
 		    Arc arcFromId(int ix) const {
 		      return direct(_digraph->arcFromId(ix >> 1), bool(ix & 1));
+		    }
 		    Edge edgeFromId(int ix) const { return _digraph->arcFromId(ix); }
 		    int id(const Node &n) const { return _digraph->id(n); }
 		    int id(const Arc &a) const {
 		      return  (_digraph->id(a) << 1) | (a._forward ? 1 : 0);
+		    }
 		    int id(const Edge &e) const { return _digraph->id(e); }
 		    int maxNodeId() const { return _digraph->maxNodeId(); }
 		    int maxArcId() const { return (_digraph->maxArcId() << 1) | 1; }
 		    int maxEdgeId() const { return _digraph->maxArcId(); }
 		    Node addNode() { return _digraph->addNode(); }
 		    Edge addEdge(const Node& u, const Node& v) {
 		      return _digraph->addArc(u, v);
+		    }
 		    void erase(const Node& i) { _digraph->erase(i); }
 		    void erase(const Edge& i) { _digraph->erase(i); }
 		    void clear() { _digraph->clear(); }
 		    typedef NodeNumTagIndicator<Digraph> NodeNumTag;
 		    int nodeNum() const { return _digraph->nodeNum(); }
 		    typedef ArcNumTagIndicator<Digraph> ArcNumTag;
 		    int arcNum() const { return 2 * _digraph->arcNum(); }
 		    typedef ArcNumTag EdgeNumTag;
 		    int edgeNum() const { return _digraph->arcNum(); }
 		    typedef FindArcTagIndicator<Digraph> FindArcTag;
 		    Arc findArc(Node s, Node t, Arc p = INVALID) const {
 		      if (p == INVALID) {
 		        Edge arc = _digraph->findArc(s, t);
 		        if (arc != INVALID) return direct(arc, true);
 		        arc = _digraph->findArc(t, s);
 		        if (arc != INVALID) return direct(arc, false);
 		      } else if (direction(p)) {
 		        Edge arc = _digraph->findArc(s, t, p);
 		        if (arc != INVALID) return direct(arc, true);
 		        arc = _digraph->findArc(t, s);
 		        if (arc != INVALID) return direct(arc, false);
 		      } else {
 		        Edge arc = _digraph->findArc(t, s, p);
 		        if (arc != INVALID) return direct(arc, false);
+		      }
 		      return INVALID;
+		    }
 		    typedef FindArcTag FindEdgeTag;
 		    Edge findEdge(Node s, Node t, Edge p = INVALID) const {
 		      if (s != t) {
 		        if (p == INVALID) {
 		          Edge arc = _digraph->findArc(s, t);
 		          if (arc != INVALID) return arc;
 		          arc = _digraph->findArc(t, s);
 		          if (arc != INVALID) return arc;
 		        } else if (_digraph->source(p) == s) {
 		          Edge arc = _digraph->findArc(s, t, p);
 		          if (arc != INVALID) return arc;
 		          arc = _digraph->findArc(t, s);
 		          if (arc != INVALID) return arc;
 		        } else {
 		          Edge arc = _digraph->findArc(t, s, p);
 		          if (arc != INVALID) return arc;
+		        }
 		      } else {
 		        return _digraph->findArc(s, t, p);
+		      }
 		      return INVALID;
+		    }
 		  private:
 		    template <typename V>
 		    class ArcMapBase {
 		    private:
 		      typedef typename DGR::template ArcMap<V> MapImpl;
 		    public:
 		      typedef typename MapTraits<MapImpl>::ReferenceMapTag ReferenceMapTag;
 		      typedef V Value;
 		      typedef Arc Key;
 		      typedef typename MapTraits<MapImpl>::ConstReturnValue ConstReturnValue;
 		      typedef typename MapTraits<MapImpl>::ReturnValue ReturnValue;
 		      typedef typename MapTraits<MapImpl>::ConstReturnValue ConstReference;
 		      typedef typename MapTraits<MapImpl>::ReturnValue Reference;
 		      ArcMapBase(const UndirectorBase<DGR>& adaptor) :
 		        _forward(*adaptor._digraph), _backward(*adaptor._digraph) {}
 		      ArcMapBase(const UndirectorBase<DGR>& adaptor, const V& value)
 		        : _forward(*adaptor._digraph, value),
 		          _backward(*adaptor._digraph, value) {}
 		      void set(const Arc& a, const V& value) {
 		        if (direction(a)) {
 		          _forward.set(a, value);
 		        } else {
 		          _backward.set(a, value);
+		        }
+		      }
 		      ConstReturnValue operator[](const Arc& a) const {
 		        if (direction(a)) {
 		          return _forward[a];
 		        } else {
 		          return _backward[a];
+		        }
+		      }
 		      ReturnValue operator[](const Arc& a) {
 		        if (direction(a)) {
 		          return _forward[a];
 		        } else {
 		          return _backward[a];
+		        }
+		      }
 		    protected:
 		      MapImpl _forward, _backward;
 		    };
 		  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) { }
 		    private:
 		      NodeMap& operator=(const NodeMap& cmap) {
 		        return operator=<NodeMap>(cmap);
+		      }
 		      template <typename CMap>
 		      NodeMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		    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) {}
 		    private:
 		      ArcMap& operator=(const ArcMap& cmap) {
 		        return operator=<ArcMap>(cmap);
+		      }
 		      template <typename CMap>
 		      ArcMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        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) {}
 		    private:
 		      EdgeMap& operator=(const EdgeMap& cmap) {
 		        return operator=<EdgeMap>(cmap);
+		      }
 		      template <typename CMap>
 		      EdgeMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		    typedef typename ItemSetTraits<DGR, Node>::ItemNotifier NodeNotifier;
 		    NodeNotifier& notifier(Node) const { return _digraph->notifier(Node()); }
 		    typedef typename ItemSetTraits<DGR, Edge>::ItemNotifier EdgeNotifier;
 		    EdgeNotifier& notifier(Edge) const { return _digraph->notifier(Edge()); }
 		    typedef EdgeNotifier ArcNotifier;
 		    ArcNotifier& notifier(Arc) const { return _digraph->notifier(Edge()); }
 		  protected:
 		    UndirectorBase() : _digraph(0) {}
 		    DGR* _digraph;
 		    void initialize(DGR& digraph) {
 		      _digraph = &digraph;
+		    }
 		  };
 		  /// \ingroup graph_adaptors
 		  ///
 		  /// \brief Adaptor class for viewing a digraph as an undirected graph.
 		  ///
 		  /// Undirector adaptor can be used for viewing a digraph as an undirected
 		  /// graph. All arcs of the underlying digraph are showed in the
 		  /// adaptor as an edge (and also as a pair of arcs, of course).
 		  /// This adaptor conforms to the \ref concepts::Graph "Graph" concept.
 		  ///
 		  /// The adapted digraph can also be modified through this adaptor
 		  /// by adding or removing nodes or edges, unless the \c GR template
 		  /// parameter is set to be \c const.
 		  ///
 		  /// \tparam DGR The type of the adapted digraph.
 		  /// It must conform to the \ref concepts::Digraph "Digraph" concept.
 		  /// It can also be specified to be \c const.
 		  ///
 		  /// \note The \c Node type of this adaptor and the adapted digraph are
 		  /// convertible to each other, moreover the \c Edge type of the adaptor
 		  /// and the \c Arc type of the adapted digraph are also convertible to
 		  /// each other.
 		  /// (Thus the \c Arc type of the adaptor is convertible to the \c Arc type
 		  /// of the adapted digraph.)
 		  template<typename DGR>
 		#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
 		    ///
 		    /// Creates an undirected graph from the given digraph.
 		    Undirector(DGR& digraph) {
 		      initialize(digraph);
+		    }
 		    /// \brief Arc map combined from two original arc maps
 		    ///
 		    /// This map adaptor class adapts two arc maps of the underlying
 		    /// digraph to get an arc map of the undirected graph.
 		    /// Its value type is inherited from the first arc map type (\c FW).
 		    /// \tparam FW The type of the "foward" arc map.
 		    /// \tparam BK The type of the "backward" arc map.
 		    template <typename FW, typename BK>
 		    class CombinedArcMap {
 		    public:
 		      /// The key type of the map
 		      typedef typename Parent::Arc Key;
 		      /// The value type of the map
 		      typedef typename FW::Value Value;
 		      typedef typename MapTraits<FW>::ReferenceMapTag ReferenceMapTag;
 		      typedef typename MapTraits<FW>::ReturnValue ReturnValue;
 		      typedef typename MapTraits<FW>::ConstReturnValue ConstReturnValue;
 		      typedef typename MapTraits<FW>::ReturnValue Reference;
 		      typedef typename MapTraits<FW>::ConstReturnValue ConstReference;
 		      /// Constructor
 		      CombinedArcMap(FW& forward, BK& backward)
 		        : _forward(&forward), _backward(&backward) {}
 		      /// Sets the value associated with the given key.
 		      void set(const Key& e, const Value& a) {
 		        if (Parent::direction(e)) {
 		          _forward->set(e, a);
 		        } else {
 		          _backward->set(e, a);
+		        }
+		      }
 		      /// Returns the value associated with the given key.
 		      ConstReturnValue operator[](const Key& e) const {
 		        if (Parent::direction(e)) {
 		          return (*_forward)[e];
 		        } else {
 		          return (*_backward)[e];
+		        }
+		      }
 		      /// Returns a reference to the value associated with the given key.
 		      ReturnValue operator[](const Key& e) {
 		        if (Parent::direction(e)) {
 		          return (*_forward)[e];
 		        } else {
 		          return (*_backward)[e];
+		        }
+		      }
 		    protected:
 		      FW* _forward;
 		      BK* _backward;
 		    };
 		    /// \brief Returns a combined arc map
 		    ///
 		    /// This function just returns a combined arc map.
 		    template <typename FW, typename BK>
 		    static CombinedArcMap<FW, BK>
 		    combinedArcMap(FW& forward, BK& backward) {
 		      return CombinedArcMap<FW, BK>(forward, backward);
+		    }
 		    template <typename FW, typename BK>
 		    static CombinedArcMap<const FW, BK>
 		    combinedArcMap(const FW& forward, BK& backward) {
 		      return CombinedArcMap<const FW, BK>(forward, backward);
+		    }
 		    template <typename FW, typename BK>
 		    static CombinedArcMap<FW, const BK>
 		    combinedArcMap(FW& forward, const BK& backward) {
 		      return CombinedArcMap<FW, const BK>(forward, backward);
+		    }
 		    template <typename FW, typename BK>
 		    static CombinedArcMap<const FW, const BK>
 		    combinedArcMap(const FW& forward, const BK& backward) {
 		      return CombinedArcMap<const FW, const BK>(forward, backward);
+		    }
 		  };
 		  /// \brief Returns a read-only Undirector adaptor
 		  ///
 		  /// This function just returns a read-only \ref Undirector adaptor.
 		  /// \ingroup graph_adaptors
 		  /// \relates Undirector
 		  template<typename DGR>
 		  Undirector<const DGR> undirector(const DGR& digraph) {
 		    return Undirector<const DGR>(digraph);
+		  }
 		  template <typename GR, typename DM>
 		  class OrienterBase {
 		  public:
 		    typedef GR Graph;
 		    typedef DM DirectionMap;
 		    typedef typename GR::Node Node;
 		    typedef typename GR::Edge Arc;
 		    void reverseArc(const Arc& arc) {
 		      _direction->set(arc, !(*_direction)[arc]);
+		    }
 		    void first(Node& i) const { _graph->first(i); }
 		    void first(Arc& i) const { _graph->first(i); }
 		    void firstIn(Arc& i, const Node& n) const {
 		      bool d = true;
 		      _graph->firstInc(i, d, n);
 		      while (i != INVALID && d == (*_direction)[i]) _graph->nextInc(i, d);
+		    }
 		    void firstOut(Arc& i, const Node& n ) const {
 		      bool d = true;
 		      _graph->firstInc(i, d, n);
 		      while (i != INVALID && d != (*_direction)[i]) _graph->nextInc(i, d);
+		    }
 		    void next(Node& i) const { _graph->next(i); }
 		    void next(Arc& i) const { _graph->next(i); }
 		    void nextIn(Arc& i) const {
 		      bool d = !(*_direction)[i];
 		      _graph->nextInc(i, d);
 		      while (i != INVALID && d == (*_direction)[i]) _graph->nextInc(i, d);
+		    }
 		    void nextOut(Arc& i) const {
 		      bool d = (*_direction)[i];
 		      _graph->nextInc(i, d);
 		      while (i != INVALID && d != (*_direction)[i]) _graph->nextInc(i, d);
+		    }
 		    Node source(const Arc& e) const {
 		      return (*_direction)[e] ? _graph->u(e) : _graph->v(e);
+		    }
 		    Node target(const Arc& e) const {
 		      return (*_direction)[e] ? _graph->v(e) : _graph->u(e);
+		    }
 		    typedef NodeNumTagIndicator<Graph> NodeNumTag;
 		    int nodeNum() const { return _graph->nodeNum(); }
 		    typedef EdgeNumTagIndicator<Graph> ArcNumTag;
 		    int arcNum() const { return _graph->edgeNum(); }
 		    typedef FindEdgeTagIndicator<Graph> FindArcTag;
 		    Arc findArc(const Node& u, const Node& v,
 		                const Arc& prev = INVALID) const {
 		      Arc arc = _graph->findEdge(u, v, prev);
 		      while (arc != INVALID && source(arc) != u) {
 		        arc = _graph->findEdge(u, v, arc);
+		      }
 		      return arc;
+		    }
 		    Node addNode() {
 		      return Node(_graph->addNode());
+		    }
 		    Arc addArc(const Node& u, const Node& v) {
 		      Arc arc = _graph->addEdge(u, v);
 		      _direction->set(arc, _graph->u(arc) == u);
 		      return arc;
+		    }
 		    void erase(const Node& i) { _graph->erase(i); }
 		    void erase(const Arc& i) { _graph->erase(i); }
 		    void clear() { _graph->clear(); }
 		    int id(const Node& v) const { return _graph->id(v); }
 		    int id(const Arc& e) const { return _graph->id(e); }
 		    Node nodeFromId(int idx) const { return _graph->nodeFromId(idx); }
 		    Arc arcFromId(int idx) const { return _graph->edgeFromId(idx); }
 		    int maxNodeId() const { return _graph->maxNodeId(); }
 		    int maxArcId() const { return _graph->maxEdgeId(); }
 		    typedef typename ItemSetTraits<GR, Node>::ItemNotifier NodeNotifier;
 		    NodeNotifier& notifier(Node) const { return _graph->notifier(Node()); }
 		    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) {}
 		    private:
 		      NodeMap& operator=(const NodeMap& cmap) {
 		        return operator=<NodeMap>(cmap);
+		      }
 		      template <typename CMap>
 		      NodeMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		    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) { }
 		    private:
 		      ArcMap& operator=(const ArcMap& cmap) {
 		        return operator=<ArcMap>(cmap);
+		      }
 		      template <typename CMap>
 		      ArcMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		  protected:
 		    Graph* _graph;
 		    DM* _direction;
 		    void initialize(GR& graph, DM& direction) {
 		      _graph = &graph;
 		      _direction = &direction;
+		    }
 		  };
 		  /// \ingroup graph_adaptors
 		  ///
 		  /// \brief Adaptor class for orienting the edges of a graph to get a digraph
 		  ///
 		  /// Orienter adaptor can be used for orienting the edges of a graph to
 		  /// get a digraph. A \c bool edge map of the underlying graph must be
 		  /// specified, which define the direction of the arcs in the adaptor.
 		  /// The arcs can be easily reversed by the \c reverseArc() member function
 		  /// of the adaptor.
 		  /// This class conforms to the \ref concepts::Digraph "Digraph" concept.
 		  ///
 		  /// The adapted graph can also be modified through this adaptor
 		  /// by adding or removing nodes or arcs, unless the \c GR template
 		  /// parameter is set to be \c const.
 		  ///
 		  /// \tparam GR The type of the adapted graph.
 		  /// It must conform to the \ref concepts::Graph "Graph" concept.
 		  /// It can also be specified to be \c const.
 		  /// \tparam DM The type of the direction map.
 		  /// It must be a \c bool (or convertible) edge map of the
 		  /// adapted graph. The default type is
 		  /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<bool>".
 		  ///
 		  /// \note The \c Node type of this adaptor and the adapted graph are
 		  /// convertible to each other, moreover the \c Arc type of the adaptor
 		  /// and the \c Edge type of the adapted graph are also convertible to
 		  /// each other.
 		#ifdef DOXYGEN
 		  template<typename GR,
 		           typename DM>
 		  class Orienter {
 		#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) {
 		      Parent::initialize(graph, direction);
+		    }
 		    /// \brief Reverses the given arc
 		    ///
 		    /// This function reverses the given arc.
 		    /// It is done by simply negate the assigned value of \c a
 		    /// in the direction map.
 		    void reverseArc(const Arc& a) {
 		      Parent::reverseArc(a);
+		    }
 		  };
 		  /// \brief Returns a read-only Orienter adaptor
 		  ///
 		  /// This function just returns a read-only \ref Orienter adaptor.
 		  /// \ingroup graph_adaptors
 		  /// \relates Orienter
 		  template<typename GR, typename DM>
 		  Orienter<const GR, DM>
 		  orienter(const GR& graph, DM& direction) {
 		    return Orienter<const GR, DM>(graph, direction);
+		  }
 		  template<typename GR, typename DM>
 		  Orienter<const GR, const DM>
 		  orienter(const GR& graph, const DM& direction) {
 		    return Orienter<const GR, const DM>(graph, direction);
+		  }
 		  namespace _adaptor_bits {
 		    template <typename DGR, typename CM, typename FM, typename TL>
 		    class ResForwardFilter {
 		    public:
 		      typedef typename DGR::Arc Key;
 		      typedef bool Value;
 		    private:
 		      const CM* _capacity;
 		      const FM* _flow;
 		      TL _tolerance;
 		    public:
 		      ResForwardFilter(const CM& capacity, const FM& flow,
 		                       const TL& tolerance = TL())
 		        : _capacity(&capacity), _flow(&flow), _tolerance(tolerance) { }
 		      bool operator[](const typename DGR::Arc& a) const {
 		        return _tolerance.positive((*_capacity)[a] - (*_flow)[a]);
+		      }
 		    };
 		    template<typename DGR,typename CM, typename FM, typename TL>
 		    class ResBackwardFilter {
 		    public:
 		      typedef typename DGR::Arc Key;
 		      typedef bool Value;
 		    private:
 		      const CM* _capacity;
 		      const FM* _flow;
 		      TL _tolerance;
 		    public:
 		      ResBackwardFilter(const CM& capacity, const FM& flow,
 		                        const TL& tolerance = TL())
 		        : _capacity(&capacity), _flow(&flow), _tolerance(tolerance) { }
 		      bool operator[](const typename DGR::Arc& a) const {
 		        return _tolerance.positive((*_flow)[a]);
+		      }
 		    };
+		  }
 		  /// \ingroup graph_adaptors
 		  ///
 		  /// \brief Adaptor class for composing the residual digraph for directed
 		  /// flow and circulation problems.
 		  ///
 		  /// ResidualDigraph can be used for composing the \e residual digraph
 		  /// for directed flow and circulation problems. Let \f$ G=(V, A) \f$
 		  /// be a directed graph and let \f$ F \f$ be a number type.
 		  /// Let \f$ flow, cap: A\to F \f$ be functions on the arcs.
 		  /// This adaptor implements a digraph structure with node set \f$ V \f$
 		  /// and arc set \f$ A_{forward}\cup A_{backward} \f$,
 		  /// where \f$ A_{forward}=\{uv : uv\in A, flow(uv)<cap(uv)\} \f$ and
 		  /// \f$ A_{backward}=\{vu : uv\in A, flow(uv)>0\} \f$, i.e. the so
 		  /// called residual digraph.
 		  /// When the union \f$ A_{forward}\cup A_{backward} \f$ is taken,
 		  /// multiplicities are counted, i.e. the adaptor has exactly
 		  /// \f$ |A_{forward}| + |A_{backward}|\f$ arcs (it may have parallel
 		  /// arcs).
 		  /// This class conforms to the \ref concepts::Digraph "Digraph" concept.
 		  ///
 		  /// \tparam DGR The type of the adapted digraph.
 		  /// It must conform to the \ref concepts::Digraph "Digraph" concept.
 		  /// It is implicitly \c const.
 		  /// \tparam CM The type of the capacity map.
 		  /// It must be an arc map of some numerical type, which defines
 		  /// the capacities in the flow problem. It is implicitly \c const.
 		  /// The default type is
 		  /// \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
 		  /// \tparam FM The type of the flow map.
 		  /// It must be an arc map of some numerical type, which defines
 		  /// the flow values in the flow problem. The default type is \c CM.
 		  /// \tparam TL The tolerance type for handling inexact computation.
 		  /// The default tolerance type depends on the value type of the
 		  /// capacity map.
 		  ///
 		  /// \note This adaptor is implemented using Undirector and FilterArcs
 		  /// adaptors.
 		  ///
 		  /// \note The \c Node type of this adaptor and the adapted digraph are
 		  /// convertible to each other, moreover the \c Arc type of the adaptor
 		  /// is convertible to the \c Arc type of the adapted digraph.
 		#ifdef DOXYGEN
 		  template<typename DGR, typename CM, typename FM, typename TL>
 		  class ResidualDigraph
 		#else
 		  template<typename DGR,
 		           typename CM = typename DGR::template ArcMap<int>,
 		           typename FM = CM,
 		           typename TL = Tolerance<typename CM::Value> >
 		  class ResidualDigraph
 		    : public SubDigraph<
 		        Undirector<const DGR>,
 		        ConstMap<typename DGR::Node, Const<bool, true> >,
 		        typename Undirector<const DGR>::template CombinedArcMap<
 		          _adaptor_bits::ResForwardFilter<const DGR, CM, FM, TL>,
 		          _adaptor_bits::ResBackwardFilter<const DGR, CM, FM, TL> > >
 		#endif
+		  {
 		  public:
 		    /// The type of the underlying digraph.
 		    typedef DGR Digraph;
 		    /// The type of the capacity map.
 		    typedef CM CapacityMap;
 		    /// The type of the flow map.
 		    typedef FM FlowMap;
 		    /// The tolerance type.
 		    typedef TL Tolerance;
 		    typedef typename CapacityMap::Value Value;
 		    typedef ResidualDigraph Adaptor;
 		  protected:
 		    typedef Undirector<const Digraph> Undirected;
 		    typedef ConstMap<typename DGR::Node, Const<bool, true> > NodeFilter;
 		    typedef _adaptor_bits::ResForwardFilter<const DGR, CM,
 		                                            FM, TL> ForwardFilter;
 		    typedef _adaptor_bits::ResBackwardFilter<const DGR, CM,
 		                                             FM, TL> BackwardFilter;
 		    typedef typename Undirected::
 		      template CombinedArcMap<ForwardFilter, BackwardFilter> ArcFilter;
 		    typedef SubDigraph<Undirected, NodeFilter, ArcFilter> Parent;
 		    const CapacityMap* _capacity;
 		    FlowMap* _flow;
 		    Undirected _graph;
 		    NodeFilter _node_filter;
 		    ForwardFilter _forward_filter;
 		    BackwardFilter _backward_filter;
 		    ArcFilter _arc_filter;
 		  public:
 		    /// \brief Constructor
 		    ///
 		    /// Constructor of the residual digraph adaptor. The parameters are the
 		    /// digraph, the capacity map, the flow map, and a tolerance object.
 		    ResidualDigraph(const DGR& digraph, const CM& capacity,
 		                    FM& flow, const TL& tolerance = Tolerance())
 		      : Parent(), _capacity(&capacity), _flow(&flow),
 		        _graph(digraph), _node_filter(),
 		        _forward_filter(capacity, flow, tolerance),
 		        _backward_filter(capacity, flow, tolerance),
 		        _arc_filter(_forward_filter, _backward_filter)
+		    {
 		      Parent::initialize(_graph, _node_filter, _arc_filter);
+		    }
 		    typedef typename Parent::Arc Arc;
 		    /// \brief Returns the residual capacity of the given arc.
 		    ///
 		    /// Returns the residual capacity of the given arc.
 		    Value residualCapacity(const Arc& a) const {
 		      if (Undirected::direction(a)) {
 		        return (*_capacity)[a] - (*_flow)[a];
 		      } else {
 		        return (*_flow)[a];
+		      }
+		    }
 		    /// \brief Augments on the given arc in the residual digraph.
 		    ///
 		    /// Augments on the given arc in the residual digraph. It increases
 		    /// or decreases the flow value on the original arc according to the
 		    /// direction of the residual arc.
 		    void augment(const Arc& a, const Value& v) const {
 		      if (Undirected::direction(a)) {
 		        _flow->set(a, (*_flow)[a] + v);
 		      } else {
 		        _flow->set(a, (*_flow)[a] - v);
+		      }
+		    }
 		    /// \brief Returns \c true if the given residual arc is a forward arc.
 		    ///
 		    /// Returns \c true if the given residual arc has the same orientation
 		    /// as the original arc, i.e. it is a so called forward arc.
 		    static bool forward(const Arc& a) {
 		      return Undirected::direction(a);
+		    }
 		    /// \brief Returns \c true if the given residual arc is a backward arc.
 		    ///
 		    /// Returns \c true if the given residual arc has the opposite orientation
 		    /// than the original arc, i.e. it is a so called backward arc.
 		    static bool backward(const Arc& a) {
 		      return !Undirected::direction(a);
+		    }
 		    /// \brief Returns the forward oriented residual arc.
 		    ///
 		    /// Returns the forward oriented residual arc related to the given
 		    /// arc of the underlying digraph.
 		    static Arc forward(const typename Digraph::Arc& a) {
 		      return Undirected::direct(a, true);
+		    }
 		    /// \brief Returns the backward oriented residual arc.
 		    ///
 		    /// Returns the backward oriented residual arc related to the given
 		    /// arc of the underlying digraph.
 		    static Arc backward(const typename Digraph::Arc& a) {
 		      return Undirected::direct(a, false);
+		    }
 		    /// \brief Residual capacity map.
 		    ///
 		    /// This map adaptor class can be used for obtaining the residual
 		    /// capacities as an arc map of the residual digraph.
 		    /// Its value type is inherited from the capacity map.
 		    class ResidualCapacity {
 		    protected:
 		      const Adaptor* _adaptor;
 		    public:
 		      /// The key type of the map
 		      typedef Arc Key;
 		      /// The value type of the map
 		      typedef typename CapacityMap::Value Value;
 		      /// Constructor
 		      ResidualCapacity(const ResidualDigraph<DGR, CM, FM, TL>& adaptor)
 		        : _adaptor(&adaptor) {}
 		      /// Returns the value associated with the given residual arc
 		      Value operator[](const Arc& a) const {
 		        return _adaptor->residualCapacity(a);
+		      }
 		    };
 		    /// \brief Returns a residual capacity map
 		    ///
 		    /// This function just returns a residual capacity map.
 		    ResidualCapacity residualCapacity() const {
 		      return ResidualCapacity(*this);
+		    }
 		  };
 		  /// \brief Returns a (read-only) Residual adaptor
 		  ///
 		  /// This function just returns a (read-only) \ref ResidualDigraph adaptor.
 		  /// \ingroup graph_adaptors
 		  /// \relates ResidualDigraph
 		    template<typename DGR, typename CM, typename FM>
 		  ResidualDigraph<DGR, CM, FM>
 		  residualDigraph(const DGR& digraph, const CM& capacity_map, FM& flow_map) {
 		    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;
 		    class Arc;
 		  private:
 		    template <typename T> class NodeMapBase;
 		    template <typename T> class ArcMapBase;
 		  public:
 		    class Node : public DigraphNode {
 		      friend class SplitNodesBase;
 		      template <typename T> friend class NodeMapBase;
 		    private:
 		      bool _in;
 		      Node(DigraphNode node, bool in)
 		        : DigraphNode(node), _in(in) {}
 		    public:
 		      Node() {}
 		      Node(Invalid) : DigraphNode(INVALID), _in(true) {}
 		      bool operator==(const Node& node) const {
 		        return DigraphNode::operator==(node) && _in == node._in;
+		      }
 		      bool operator!=(const Node& node) const {
 		        return !(*this == node);
+		      }
 		      bool operator<(const Node& node) const {
 		        return DigraphNode::operator<(node) ||
 		          (DigraphNode::operator==(node) && _in < node._in);
+		      }
 		    };
 		    class Arc {
 		      friend class SplitNodesBase;
 		      template <typename T> friend class ArcMapBase;
 		    private:
 		      typedef BiVariant<DigraphArc, DigraphNode> ArcImpl;
 		      explicit Arc(const DigraphArc& arc) : _item(arc) {}
 		      explicit Arc(const DigraphNode& node) : _item(node) {}
 		      ArcImpl _item;
 		    public:
 		      Arc() {}
 		      Arc(Invalid) : _item(DigraphArc(INVALID)) {}
 		      bool operator==(const Arc& arc) const {
 		        if (_item.firstState()) {
 		          if (arc._item.firstState()) {
 		            return _item.first() == arc._item.first();
+		          }
 		        } else {
 		          if (arc._item.secondState()) {
 		            return _item.second() == arc._item.second();
+		          }
+		        }
 		        return false;
+		      }
 		      bool operator!=(const Arc& arc) const {
 		        return !(*this == arc);
+		      }
 		      bool operator<(const Arc& arc) const {
 		        if (_item.firstState()) {
 		          if (arc._item.firstState()) {
 		            return _item.first() < arc._item.first();
+		          }
 		          return false;
 		        } else {
 		          if (arc._item.secondState()) {
 		            return _item.second() < arc._item.second();
+		          }
 		          return true;
+		        }
+		      }
 		      operator DigraphArc() const { return _item.first(); }
 		      operator DigraphNode() const { return _item.second(); }
 		    };
 		    void first(Node& n) const {
 		      _digraph->first(n);
 		      n._in = true;
+		    }
 		    void next(Node& n) const {
 		      if (n._in) {
 		        n._in = false;
 		      } else {
 		        n._in = true;
 		        _digraph->next(n);
+		      }
+		    }
 		    void first(Arc& e) const {
 		      e._item.setSecond();
 		      _digraph->first(e._item.second());
 		      if (e._item.second() == INVALID) {
 		        e._item.setFirst();
 		        _digraph->first(e._item.first());
+		      }
+		    }
 		    void next(Arc& e) const {
 		      if (e._item.secondState()) {
 		        _digraph->next(e._item.second());
 		        if (e._item.second() == INVALID) {
 		          e._item.setFirst();
 		          _digraph->first(e._item.first());
+		        }
 		      } else {
 		        _digraph->next(e._item.first());
+		      }
+		    }
 		    void firstOut(Arc& e, const Node& n) const {
 		      if (n._in) {
 		        e._item.setSecond(n);
 		      } else {
 		        e._item.setFirst();
 		        _digraph->firstOut(e._item.first(), n);
+		      }
+		    }
 		    void nextOut(Arc& e) const {
 		      if (!e._item.firstState()) {
 		        e._item.setFirst(INVALID);
 		      } else {
 		        _digraph->nextOut(e._item.first());
+		      }
+		    }
 		    void firstIn(Arc& e, const Node& n) const {
 		      if (!n._in) {
 		        e._item.setSecond(n);
 		      } else {
 		        e._item.setFirst();
 		        _digraph->firstIn(e._item.first(), n);
+		      }
+		    }
 		    void nextIn(Arc& e) const {
 		      if (!e._item.firstState()) {
 		        e._item.setFirst(INVALID);
 		      } else {
 		        _digraph->nextIn(e._item.first());
+		      }
+		    }
 		    Node source(const Arc& e) const {
 		      if (e._item.firstState()) {
 		        return Node(_digraph->source(e._item.first()), false);
 		      } else {
 		        return Node(e._item.second(), true);
+		      }
+		    }
 		    Node target(const Arc& e) const {
 		      if (e._item.firstState()) {
 		        return Node(_digraph->target(e._item.first()), true);
 		      } else {
 		        return Node(e._item.second(), false);
+		      }
+		    }
 		    int id(const Node& n) const {
 		      return (_digraph->id(n) << 1) | (n._in ? 0 : 1);
+		    }
 		    Node nodeFromId(int ix) const {
 		      return Node(_digraph->nodeFromId(ix >> 1), (ix & 1) == 0);
+		    }
 		    int maxNodeId() const {
 		      return 2 * _digraph->maxNodeId() + 1;
+		    }
 		    int id(const Arc& e) const {
 		      if (e._item.firstState()) {
 		        return _digraph->id(e._item.first()) << 1;
 		      } else {
 		        return (_digraph->id(e._item.second()) << 1) | 1;
+		      }
+		    }
 		    Arc arcFromId(int ix) const {
 		      if ((ix & 1) == 0) {
 		        return Arc(_digraph->arcFromId(ix >> 1));
 		      } else {
 		        return Arc(_digraph->nodeFromId(ix >> 1));
+		      }
+		    }
 		    int maxArcId() const {
 		      return std::max(_digraph->maxNodeId() << 1,
 		                      (_digraph->maxArcId() << 1) | 1);
+		    }
 		    static bool inNode(const Node& n) {
 		      return n._in;
+		    }
 		    static bool outNode(const Node& n) {
 		      return !n._in;
+		    }
 		    static bool origArc(const Arc& e) {
 		      return e._item.firstState();
+		    }
 		    static bool bindArc(const Arc& e) {
 		      return e._item.secondState();
+		    }
 		    static Node inNode(const DigraphNode& n) {
 		      return Node(n, true);
+		    }
 		    static Node outNode(const DigraphNode& n) {
 		      return Node(n, false);
+		    }
 		    static Arc arc(const DigraphNode& n) {
 		      return Arc(n);
+		    }
 		    static Arc arc(const DigraphArc& e) {
 		      return Arc(e);
+		    }
 		    typedef True NodeNumTag;
 		    int nodeNum() const {
 		      return  2 * countNodes(*_digraph);
+		    }
 		    typedef True ArcNumTag;
 		    int arcNum() const {
 		      return countArcs(*_digraph) + countNodes(*_digraph);
+		    }
 		    typedef True FindArcTag;
 		    Arc findArc(const Node& u, const Node& v,
 		                const Arc& prev = INVALID) const {
 		      if (inNode(u) && outNode(v)) {
 		        if (static_cast<const DigraphNode&>(u) ==
 		            static_cast<const DigraphNode&>(v) && prev == INVALID) {
 		          return Arc(u);
+		        }
+		      }
 		      else if (outNode(u) && inNode(v)) {
 		        return Arc(::lemon::findArc(*_digraph, u, v, prev));
+		      }
 		      return INVALID;
+		    }
 		  private:
 		    template <typename V>
 		    class NodeMapBase
 		      : public MapTraits<typename Parent::template NodeMap<V> > {
 		      typedef typename Parent::template NodeMap<V> NodeImpl;
 		    public:
 		      typedef Node Key;
 		      typedef V Value;
 		      typedef typename MapTraits<NodeImpl>::ReferenceMapTag ReferenceMapTag;
 		      typedef typename MapTraits<NodeImpl>::ReturnValue ReturnValue;
 		      typedef typename MapTraits<NodeImpl>::ConstReturnValue ConstReturnValue;
 		      typedef typename MapTraits<NodeImpl>::ReturnValue Reference;
 		      typedef typename MapTraits<NodeImpl>::ConstReturnValue ConstReference;
 		      NodeMapBase(const SplitNodesBase<DGR>& adaptor)
 		        : _in_map(*adaptor._digraph), _out_map(*adaptor._digraph) {}
 		      NodeMapBase(const SplitNodesBase<DGR>& adaptor, const V& value)
 		        : _in_map(*adaptor._digraph, value),
 		          _out_map(*adaptor._digraph, value) {}
 		      void set(const Node& key, const V& val) {
 		        if (SplitNodesBase<DGR>::inNode(key)) { _in_map.set(key, val); }
 		        else {_out_map.set(key, val); }
+		      }
 		      ReturnValue operator[](const Node& key) {
 		        if (SplitNodesBase<DGR>::inNode(key)) { return _in_map[key]; }
 		        else { return _out_map[key]; }
+		      }
 		      ConstReturnValue operator[](const Node& key) const {
 		        if (Adaptor::inNode(key)) { return _in_map[key]; }
 		        else { return _out_map[key]; }
+		      }
 		    private:
 		      NodeImpl _in_map, _out_map;
 		    };
 		    template <typename V>
 		    class ArcMapBase
 		      : public MapTraits<typename Parent::template ArcMap<V> > {
 		      typedef typename Parent::template ArcMap<V> ArcImpl;
 		      typedef typename Parent::template NodeMap<V> NodeImpl;
 		    public:
 		      typedef Arc Key;
 		      typedef V Value;
 		      typedef typename MapTraits<ArcImpl>::ReferenceMapTag ReferenceMapTag;
 		      typedef typename MapTraits<ArcImpl>::ReturnValue ReturnValue;
 		      typedef typename MapTraits<ArcImpl>::ConstReturnValue ConstReturnValue;
 		      typedef typename MapTraits<ArcImpl>::ReturnValue Reference;
 		      typedef typename MapTraits<ArcImpl>::ConstReturnValue ConstReference;
 		      ArcMapBase(const SplitNodesBase<DGR>& adaptor)
 		        : _arc_map(*adaptor._digraph), _node_map(*adaptor._digraph) {}
 		      ArcMapBase(const SplitNodesBase<DGR>& adaptor, const V& value)
 		        : _arc_map(*adaptor._digraph, value),
 		          _node_map(*adaptor._digraph, value) {}
 		      void set(const Arc& key, const V& val) {
 		        if (SplitNodesBase<DGR>::origArc(key)) {
 		          _arc_map.set(static_cast<const DigraphArc&>(key), val);
 		        } else {
 		          _node_map.set(static_cast<const DigraphNode&>(key), val);
+		        }
+		      }
 		      ReturnValue operator[](const Arc& key) {
 		        if (SplitNodesBase<DGR>::origArc(key)) {
 		          return _arc_map[static_cast<const DigraphArc&>(key)];
 		        } else {
 		          return _node_map[static_cast<const DigraphNode&>(key)];
+		        }
+		      }
 		      ConstReturnValue operator[](const Arc& key) const {
 		        if (SplitNodesBase<DGR>::origArc(key)) {
 		          return _arc_map[static_cast<const DigraphArc&>(key)];
 		        } else {
 		          return _node_map[static_cast<const DigraphNode&>(key)];
+		        }
+		      }
 		    private:
 		      ArcImpl _arc_map;
 		      NodeImpl _node_map;
 		    };
 		  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) {}
 		    private:
 		      NodeMap& operator=(const NodeMap& cmap) {
 		        return operator=<NodeMap>(cmap);
+		      }
 		      template <typename CMap>
 		      NodeMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        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) {}
 		    private:
 		      ArcMap& operator=(const ArcMap& cmap) {
 		        return operator=<ArcMap>(cmap);
+		      }
 		      template <typename CMap>
 		      ArcMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		  protected:
 		    SplitNodesBase() : _digraph(0) {}
 		    DGR* _digraph;
 		    void initialize(Digraph& digraph) {
 		      _digraph = &digraph;
+		    }
 		  };
 		  /// \ingroup graph_adaptors
 		  ///
 		  /// \brief Adaptor class for splitting the nodes of a digraph.
 		  ///
 		  /// SplitNodes adaptor can be used for splitting each node into an
 		  /// \e in-node and an \e out-node in a digraph. Formaly, the adaptor
 		  /// replaces each node \f$ u \f$ in the digraph with two nodes,
 		  /// namely node \f$ u_{in} \f$ and node \f$ u_{out} \f$.
 		  /// If there is a \f$ (v, u) \f$ arc in the original digraph, then the
 		  /// new target of the arc will be \f$ u_{in} \f$ and similarly the
 		  /// source of each original \f$ (u, v) \f$ arc will be \f$ u_{out} \f$.
 		  /// The adaptor adds an additional \e bind \e arc from \f$ u_{in} \f$
 		  /// to \f$ u_{out} \f$ for each node \f$ u \f$ of the original digraph.
 		  ///
 		  /// The aim of this class is running an algorithm with respect to node
 		  /// costs or capacities if the algorithm considers only arc costs or
 		  /// capacities directly.
 		  /// In this case you can use \c SplitNodes adaptor, and set the node
 		  /// costs/capacities of the original digraph to the \e bind \e arcs
 		  /// in the adaptor.
 		  ///
 		  /// \tparam DGR The type of the adapted digraph.
 		  /// It must conform to the \ref concepts::Digraph "Digraph" concept.
 		  /// It is implicitly \c const.
 		  ///
 		  /// \note The \c Node type of this adaptor is converible to the \c Node
 		  /// type of the adapted digraph.
 		  template <typename DGR>
 		#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;
 		    /// \brief Constructor
 		    ///
 		    /// Constructor of the adaptor.
 		    SplitNodes(const DGR& g) {
 		      Parent::initialize(g);
+		    }
 		    /// \brief Returns \c true if the given node is an in-node.
 		    ///
 		    /// Returns \c true if the given node is an in-node.
 		    static bool inNode(const Node& n) {
 		      return Parent::inNode(n);
+		    }
 		    /// \brief Returns \c true if the given node is an out-node.
 		    ///
 		    /// Returns \c true if the given node is an out-node.
 		    static bool outNode(const Node& n) {
 		      return Parent::outNode(n);
+		    }
 		    /// \brief Returns \c true if the given arc is an original arc.
 		    ///
 		    /// Returns \c true if the given arc is one of the arcs in the
 		    /// original digraph.
 		    static bool origArc(const Arc& a) {
 		      return Parent::origArc(a);
+		    }
 		    /// \brief Returns \c true if the given arc is a bind arc.
 		    ///
 		    /// Returns \c true if the given arc is a bind arc, i.e. it connects
 		    /// an in-node and an out-node.
 		    static bool bindArc(const Arc& a) {
 		      return Parent::bindArc(a);
+		    }
 		    /// \brief Returns the in-node created from the given original node.
 		    ///
 		    /// Returns the in-node created from the given original node.
 		    static Node inNode(const DigraphNode& n) {
 		      return Parent::inNode(n);
+		    }
 		    /// \brief Returns the out-node created from the given original node.
 		    ///
 		    /// Returns the out-node created from the given original node.
 		    static Node outNode(const DigraphNode& n) {
 		      return Parent::outNode(n);
+		    }
 		    /// \brief Returns the bind arc that corresponds to the given
 		    /// original node.
 		    ///
 		    /// Returns the bind arc in the adaptor that corresponds to the given
 		    /// original node, i.e. the arc connecting the in-node and out-node
 		    /// of \c n.
 		    static Arc arc(const DigraphNode& n) {
 		      return Parent::arc(n);
+		    }
 		    /// \brief Returns the arc that corresponds to the given original arc.
 		    ///
 		    /// Returns the arc in the adaptor that corresponds to the given
 		    /// original arc.
 		    static Arc arc(const DigraphArc& a) {
 		      return Parent::arc(a);
+		    }
 		    /// \brief Node map combined from two original node maps
 		    ///
 		    /// This map adaptor class adapts two node maps of the original digraph
 		    /// to get a node map of the split digraph.
 		    /// Its value type is inherited from the first node map type (\c IN).
 		    /// \tparam IN The type of the node map for the in-nodes.
 		    /// \tparam OUT The type of the node map for the out-nodes.
 		    template <typename IN, typename OUT>
 		    class CombinedNodeMap {
 		    public:
 		      /// The key type of the map
 		      typedef Node Key;
 		      /// The value type of the map
 		      typedef typename IN::Value Value;
 		      typedef typename MapTraits<IN>::ReferenceMapTag ReferenceMapTag;
 		      typedef typename MapTraits<IN>::ReturnValue ReturnValue;
 		      typedef typename MapTraits<IN>::ConstReturnValue ConstReturnValue;
 		      typedef typename MapTraits<IN>::ReturnValue Reference;
 		      typedef typename MapTraits<IN>::ConstReturnValue ConstReference;
 		      /// Constructor
 		      CombinedNodeMap(IN& in_map, OUT& out_map)
 		        : _in_map(in_map), _out_map(out_map) {}
 		      /// Returns the value associated with the given key.
 		      Value operator[](const Key& key) const {
 		        if (SplitNodesBase<const DGR>::inNode(key)) {
 		          return _in_map[key];
 		        } else {
 		          return _out_map[key];
+		        }
+		      }
 		      /// Returns a reference to the value associated with the given key.
 		      Value& operator[](const Key& key) {
 		        if (SplitNodesBase<const DGR>::inNode(key)) {
 		          return _in_map[key];
 		        } else {
 		          return _out_map[key];
+		        }
+		      }
 		      /// Sets the value associated with the given key.
 		      void set(const Key& key, const Value& value) {
 		        if (SplitNodesBase<const DGR>::inNode(key)) {
 		          _in_map.set(key, value);
 		        } else {
 		          _out_map.set(key, value);
+		        }
+		      }
 		    private:
 		      IN& _in_map;
 		      OUT& _out_map;
 		    };
 		    /// \brief Returns a combined node map
 		    ///
 		    /// This function just returns a combined node map.
 		    template <typename IN, typename OUT>
 		    static CombinedNodeMap<IN, OUT>
 		    combinedNodeMap(IN& in_map, OUT& out_map) {
 		      return CombinedNodeMap<IN, OUT>(in_map, out_map);
+		    }
 		    template <typename IN, typename OUT>
 		    static CombinedNodeMap<const IN, OUT>
 		    combinedNodeMap(const IN& in_map, OUT& out_map) {
 		      return CombinedNodeMap<const IN, OUT>(in_map, out_map);
+		    }
 		    template <typename IN, typename OUT>
 		    static CombinedNodeMap<IN, const OUT>
 		    combinedNodeMap(IN& in_map, const OUT& out_map) {
 		      return CombinedNodeMap<IN, const OUT>(in_map, out_map);
+		    }
 		    template <typename IN, typename OUT>
 		    static CombinedNodeMap<const IN, const OUT>
 		    combinedNodeMap(const IN& in_map, const OUT& out_map) {
 		      return CombinedNodeMap<const IN, const OUT>(in_map, out_map);
+		    }
 		    /// \brief Arc map combined from an arc map and a node map of the
 		    /// original digraph.
 		    ///
 		    /// This map adaptor class adapts an arc map and a node map of the
 		    /// original digraph to get an arc map of the split digraph.
 		    /// Its value type is inherited from the original arc map type (\c AM).
 		    /// \tparam AM The type of the arc map.
 		    /// \tparam NM the type of the node map.
 		    template <typename AM, typename NM>
 		    class CombinedArcMap {
 		    public:
 		      /// The key type of the map
 		      typedef Arc Key;
 		      /// The value type of the map
 		      typedef typename AM::Value Value;
 		      typedef typename MapTraits<AM>::ReferenceMapTag ReferenceMapTag;
 		      typedef typename MapTraits<AM>::ReturnValue ReturnValue;
 		      typedef typename MapTraits<AM>::ConstReturnValue ConstReturnValue;
 		      typedef typename MapTraits<AM>::ReturnValue Reference;
 		      typedef typename MapTraits<AM>::ConstReturnValue ConstReference;
 		      /// Constructor
 		      CombinedArcMap(AM& arc_map, NM& node_map)
 		        : _arc_map(arc_map), _node_map(node_map) {}
 		      /// Returns the value associated with the given key.
 		      Value operator[](const Key& arc) const {
 		        if (SplitNodesBase<const DGR>::origArc(arc)) {
 		          return _arc_map[arc];
 		        } else {
 		          return _node_map[arc];
+		        }
+		      }
 		      /// Returns a reference to the value associated with the given key.
 		      Value& operator[](const Key& arc) {
 		        if (SplitNodesBase<const DGR>::origArc(arc)) {
 		          return _arc_map[arc];
 		        } else {
 		          return _node_map[arc];
+		        }
+		      }
 		      /// Sets the value associated with the given key.
 		      void set(const Arc& arc, const Value& val) {
 		        if (SplitNodesBase<const DGR>::origArc(arc)) {
 		          _arc_map.set(arc, val);
 		        } else {
 		          _node_map.set(arc, val);
+		        }
+		      }
 		    private:
 		      AM& _arc_map;
 		      NM& _node_map;
 		    };
 		    /// \brief Returns a combined arc map
 		    ///
 		    /// This function just returns a combined arc map.
 		    template <typename ArcMap, typename NodeMap>
 		    static CombinedArcMap<ArcMap, NodeMap>
 		    combinedArcMap(ArcMap& arc_map, NodeMap& node_map) {
 		      return CombinedArcMap<ArcMap, NodeMap>(arc_map, node_map);
+		    }
 		    template <typename ArcMap, typename NodeMap>
 		    static CombinedArcMap<const ArcMap, NodeMap>
 		    combinedArcMap(const ArcMap& arc_map, NodeMap& node_map) {
 		      return CombinedArcMap<const ArcMap, NodeMap>(arc_map, node_map);
+		    }
 		    template <typename ArcMap, typename NodeMap>
 		    static CombinedArcMap<ArcMap, const NodeMap>
 		    combinedArcMap(ArcMap& arc_map, const NodeMap& node_map) {
 		      return CombinedArcMap<ArcMap, const NodeMap>(arc_map, node_map);
+		    }
 		    template <typename ArcMap, typename NodeMap>
 		    static CombinedArcMap<const ArcMap, const NodeMap>
 		    combinedArcMap(const ArcMap& arc_map, const NodeMap& node_map) {
 		      return CombinedArcMap<const ArcMap, const NodeMap>(arc_map, node_map);
+		    }
 		  };
 		  /// \brief Returns a (read-only) SplitNodes adaptor
 		  ///

lemon/bits/array_map.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2009
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_BITS_ARRAY_MAP_H
 		#define LEMON_BITS_ARRAY_MAP_H
 		#include <memory>
 		#include <lemon/bits/traits.h>
 		#include <lemon/bits/alteration_notifier.h>
 		#include <lemon/concept_check.h>
 		#include <lemon/concepts/maps.h>
 		// \ingroup graphbits
 		// \file
 		// \brief Graph map based on the array storage.
 		namespace lemon {
 		  // \ingroup graphbits
 		  //
 		  // \brief Graph map based on the array storage.
 		  //
 		  // The ArrayMap template class is graph map structure that automatically
 		  // updates the map when a key is added to or erased from the graph.
 		  // This map uses the allocators to implement the container functionality.
 		  //
 		  // The template parameters are the Graph, the current Item type and
 		  // 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.
 		    typedef _Item Key;
 		    // The value type of the map.
 		    typedef _Value Value;
 		    // 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);;
 		        allocator.construct(&(values[id]), Value());
+		      }
+		    }
 		    // \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);;
 		        allocator.construct(&(values[id]), value);
+		      }
+		    }
 		  private:
 		    // \brief Constructor to copy a map of the same map type.
 		    //
 		    // Constructor to copy a map of the same map type.
 		    ArrayMap(const ArrayMap& copy) : Parent() {
 		      if (copy.attached()) {
 		        attach(*copy.notifier());
+		      }
 		      capacity = copy.capacity;
 		      if (capacity == 0) return;
 		      values = allocator.allocate(capacity);
 		      Notifier* nf = Parent::notifier();
 		      Item it;
 		      for (nf->first(it); it != INVALID; nf->next(it)) {
 		        int id = nf->id(it);;
 		        allocator.construct(&(values[id]), copy.values[id]);
+		      }
+		    }
 		    // \brief Assign operator.
 		    //
 		    // This operator assigns for each item in the map the
 		    // value mapped to the same item in the copied map.
 		    // The parameter map should be indiced with the same
 		    // itemset because this assign operator does not change
 		    // the container of the map.
 		    ArrayMap& operator=(const ArrayMap& cmap) {
 		      return operator=<ArrayMap>(cmap);
+		    }
 		    // \brief Template assign operator.
 		    //
 		    // The given parameter should conform to the ReadMap
 		    // concecpt and could be indiced by the current item set of
 		    // the NodeMap. In this case the value for each item
 		    // is assigned by the value of the given ReadMap.
 		    template <typename CMap>
 		    ArrayMap& operator=(const CMap& cmap) {
 		      checkConcept<concepts::ReadMap<Key, _Value>, CMap>();
 		      const typename Parent::Notifier* nf = Parent::notifier();
 		      Item it;
 		      for (nf->first(it); it != INVALID; nf->next(it)) {
 		        set(it, cmap[it]);
+		      }
 		      return *this;
+		    }
 		  public:
 		    // \brief The destructor of the map.
 		    //
 		    // The destructor of the map.
 		    virtual ~ArrayMap() {
 		      if (attached()) {
 		        clear();
 		        detach();
+		      }
+		    }
 		  protected:
 		    using Parent::attach;
 		    using Parent::detach;
 		    using Parent::attached;
 		  public:
 		    // \brief The subscript operator.
 		    //
 		    // The subscript operator. The map can be subscripted by the
 		    // actual keys of the graph.
 		    Value& operator[](const Key& key) {
 		      int id = Parent::notifier()->id(key);
 		      return values[id];
+		    }
 		    // \brief The const subscript operator.
 		    //
 		    // The const subscript operator. The map can be subscripted by the
 		    // actual keys of the graph.
 		    const Value& operator[](const Key& key) const {
 		      int id = Parent::notifier()->id(key);
 		      return values[id];
+		    }
 		    // \brief Setter function of the map.
 		    //
 		    // Setter function of the map. Equivalent with map[key] = val.
 		    // This is a compatibility feature with the not dereferable maps.
 		    void set(const Key& key, const Value& val) {
 		      (*this)[key] = val;
+		    }
 		  protected:
 		    // \brief Adds a new key to the map.
 		    //
 		    // It adds a new key to the map. It is called by the observer notifier
 		    // and it overrides the add() member function of the observer base.
 		    virtual void add(const Key& key) {
 		      Notifier* nf = Parent::notifier();
 		      int id = nf->id(key);
 		      if (id >= capacity) {
 		        int new_capacity = (capacity == 0 ? 1 : capacity);
 		        while (new_capacity <= id) {
 		          new_capacity <<= 1;
+		        }
 		        Value* new_values = allocator.allocate(new_capacity);
 		        Item it;
 		        for (nf->first(it); it != INVALID; nf->next(it)) {
 		          int jd = nf->id(it);;
 		          if (id != jd) {
 		            allocator.construct(&(new_values[jd]), values[jd]);
 		            allocator.destroy(&(values[jd]));
+		          }
+		        }
 		        if (capacity != 0) allocator.deallocate(values, capacity);
 		        values = new_values;
 		        capacity = new_capacity;
+		      }
 		      allocator.construct(&(values[id]), Value());
+		    }
 		    // \brief Adds more new keys to the map.
 		    //
 		    // It adds more new keys to the map. It is called by the observer notifier
 		    // and it overrides the add() member function of the observer base.
 		    virtual void add(const std::vector<Key>& keys) {
 		      Notifier* nf = Parent::notifier();
 		      int max_id = -1;
 		      for (int i = 0; i < int(keys.size()); ++i) {
 		        int id = nf->id(keys[i]);
 		        if (id > max_id) {
 		          max_id = id;
+		        }
+		      }
 		      if (max_id >= capacity) {
 		        int new_capacity = (capacity == 0 ? 1 : capacity);
 		        while (new_capacity <= max_id) {
 		          new_capacity <<= 1;
+		        }
 		        Value* new_values = allocator.allocate(new_capacity);
 		        Item it;
 		        for (nf->first(it); it != INVALID; nf->next(it)) {
 		          int id = nf->id(it);
 		          bool found = false;
 		          for (int i = 0; i < int(keys.size()); ++i) {
 		            int jd = nf->id(keys[i]);
 		            if (id == jd) {
 		              found = true;
 		              break;
+		            }
+		          }
 		          if (found) continue;
 		          allocator.construct(&(new_values[id]), values[id]);
 		          allocator.destroy(&(values[id]));
+		        }
 		        if (capacity != 0) allocator.deallocate(values, capacity);
 		        values = new_values;
 		        capacity = new_capacity;
+		      }
 		      for (int i = 0; i < int(keys.size()); ++i) {
 		        int id = nf->id(keys[i]);
 		        allocator.construct(&(values[id]), Value());
+		      }
+		    }
 		    // \brief Erase a key from the map.
 		    //
 		    // Erase a key from the map. It is called by the observer notifier
 		    // and it overrides the erase() member function of the observer base.
 		    virtual void erase(const Key& key) {
 		      int id = Parent::notifier()->id(key);
 		      allocator.destroy(&(values[id]));
+		    }
 		    // \brief Erase more keys from the map.
 		    //
 		    // Erase more keys from the map. It is called by the observer notifier
 		    // and it overrides the erase() member function of the observer base.
 		    virtual void erase(const std::vector<Key>& keys) {
 		      for (int i = 0; i < int(keys.size()); ++i) {
 		        int id = Parent::notifier()->id(keys[i]);
 		        allocator.destroy(&(values[id]));
+		      }
+		    }
 		    // \brief Builds the map.
 		    //
 		    // It builds the map. It is called by the observer notifier
 		    // and it overrides the build() member function of the observer base.
 		    virtual void build() {
 		      Notifier* nf = Parent::notifier();
 		      allocate_memory();
 		      Item it;
 		      for (nf->first(it); it != INVALID; nf->next(it)) {
 		        int id = nf->id(it);;
 		        allocator.construct(&(values[id]), Value());
+		      }
+		    }
 		    // \brief Clear the map.
 		    //
 		    // It erase all items from the map. It is called by the observer notifier
 		    // and it overrides the clear() member function of the observer base.
 		    virtual void clear() {
 		      Notifier* nf = Parent::notifier();
 		      if (capacity != 0) {
 		        Item it;
 		        for (nf->first(it); it != INVALID; nf->next(it)) {
 		          int id = nf->id(it);
 		          allocator.destroy(&(values[id]));
+		        }
 		        allocator.deallocate(values, capacity);
 		        capacity = 0;
+		      }
+		    }
 		  private:
 		    void allocate_memory() {
 		      int max_id = Parent::notifier()->maxId();
 		      if (max_id == -1) {
 		        capacity = 0;
 		        values = 0;
 		        return;
+		      }
 		      capacity = 1;
 		      while (capacity <= max_id) {
 		        capacity <<= 1;
+		      }
 		      values = allocator.allocate(capacity);
+		    }
 		    int capacity;
 		    Value* values;
 		    Allocator allocator;
 		  };
+		}
 		#endif

lemon/bits/base_extender.h

Show inline comments

/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
 * This file is a part of LEMON, a generic C++ optimization library.
 *
 * Copyright (C) 2003-2009
 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 * (Egervary Research Group on Combinatorial Optimization, EGRES).
 *
 * Permission to use, modify and distribute this software is granted
 * provided that this copyright notice appears in all copies. For
 * precise terms see the accompanying LICENSE file.
 *
 * This software is provided "AS IS" with no warranty of any kind,
 * express or implied, and with no claim as to its suitability for any
 * purpose.
 *
 */

#ifndef LEMON_BITS_BASE_EXTENDER_H
#define LEMON_BITS_BASE_EXTENDER_H

#include <lemon/core.h>
#include <lemon/error.h>

#include <lemon/bits/map_extender.h>
#include <lemon/bits/default_map.h>

#include <lemon/concept_check.h>
#include <lemon/concepts/maps.h>

//\ingroup digraphbits
//\file
//\brief Extenders for the graph types
namespace lemon {

  // \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 {
      friend class UndirDigraphExtender;

    protected:
      bool forward;

      Arc(const Edge &ue, bool _forward) :
        Edge(ue), forward(_forward) {}

    public:
      Arc() {}

      // Invalid arc constructor
      Arc(Invalid i) : Edge(i), forward(true) {}

      bool operator==(const Arc &that) const {
        return forward==that.forward && Edge(*this)==Edge(that);
      }
      bool operator!=(const Arc &that) const {
        return forward!=that.forward || Edge(*this)!=Edge(that);
      }
      bool operator<(const Arc &that) const {
        return forward<that.forward ||
          (!(that.forward<forward) && Edge(*this)<Edge(that));
      }
    };

    // First node of the edge
    Node u(const Edge &e) const {
      return Parent::source(e);
    }

    // Source of the given arc
    Node source(const Arc &e) const {
      return e.forward ? Parent::source(e) : Parent::target(e);
    }

    // Second node of the edge
    Node v(const Edge &e) const {
      return Parent::target(e);
    }

    // Target of the given arc
    Node target(const Arc &e) const {
      return e.forward ? Parent::target(e) : Parent::source(e);
    }

    // \brief Directed arc from an edge.
    //
    // Returns a directed arc corresponding to the specified edge.
    // If the given bool is true, the first node of the given edge and
    // the source node of the returned arc are the same.
    static Arc direct(const Edge &e, bool d) {
      return Arc(e, d);
    }

    // Returns whether the given directed arc has the same orientation
    // as the corresponding edge.
    static bool direction(const Arc &a) { return a.forward; }

    using Parent::first;
    using Parent::next;

    void first(Arc &e) const {
      Parent::first(e);
      e.forward=true;
    }

    void next(Arc &e) const {
      if( e.forward ) {
        e.forward = false;
      }
      else {
        Parent::next(e);
        e.forward = true;
      }
    }

    void firstOut(Arc &e, const Node &n) const {
      Parent::firstIn(e,n);
      if( Edge(e) != INVALID ) {
        e.forward = false;
      }
      else {
        Parent::firstOut(e,n);
        e.forward = true;
      }
    }
    void nextOut(Arc &e) const {
      if( ! e.forward ) {
        Node n = Parent::target(e);
        Parent::nextIn(e);
        if( Edge(e) == INVALID ) {
          Parent::firstOut(e, n);
          e.forward = true;
        }
      }
      else {
        Parent::nextOut(e);
      }
    }

    void firstIn(Arc &e, const Node &n) const {
      Parent::firstOut(e,n);
      if( Edge(e) != INVALID ) {
        e.forward = false;
      }
      else {
        Parent::firstIn(e,n);
        e.forward = true;
      }
    }
    void nextIn(Arc &e) const {
      if( ! e.forward ) {
        Node n = Parent::source(e);
        Parent::nextOut(e);
        if( Edge(e) == INVALID ) {
          Parent::firstIn(e, n);
          e.forward = true;
        }
      }
      else {
        Parent::nextIn(e);
      }
    }

    void firstInc(Edge &e, bool &d, const Node &n) const {
      d = true;
      Parent::firstOut(e, n);
      if (e != INVALID) return;
      d = false;
      Parent::firstIn(e, n);
    }

    void nextInc(Edge &e, bool &d) const {
      if (d) {
        Node s = Parent::source(e);
        Parent::nextOut(e);
        if (e != INVALID) return;
        d = false;
        Parent::firstIn(e, s);
      } else {
        Parent::nextIn(e);
      }
    }

    Node nodeFromId(int ix) const {
      return Parent::nodeFromId(ix);
    }

    Arc arcFromId(int ix) const {
      return direct(Parent::arcFromId(ix >> 1), bool(ix & 1));
    }

    Edge edgeFromId(int ix) const {
      return Parent::arcFromId(ix);
    }

    int id(const Node &n) const {
      return Parent::id(n);
    }

    int id(const Edge &e) const {
      return Parent::id(e);
    }

    int id(const Arc &e) const {
      return 2 * Parent::id(e) + int(e.forward);
    }

    int maxNodeId() const {
      return Parent::maxNodeId();
    }

    int maxArcId() const {
      return 2 * Parent::maxArcId() + 1;
    }

    int maxEdgeId() const {
      return Parent::maxArcId();
    }

    int arcNum() const {
      return 2 * Parent::arcNum();
    }

    int edgeNum() const {
      return Parent::arcNum();
    }

    Arc findArc(Node s, Node t, Arc p = INVALID) const {
      if (p == INVALID) {
        Edge arc = Parent::findArc(s, t);
        if (arc != INVALID) return direct(arc, true);
        arc = Parent::findArc(t, s);
        if (arc != INVALID) return direct(arc, false);
      } else if (direction(p)) {
        Edge arc = Parent::findArc(s, t, p);
        if (arc != INVALID) return direct(arc, true);
        arc = Parent::findArc(t, s);
        if (arc != INVALID) return direct(arc, false);
      } else {
        Edge arc = Parent::findArc(t, s, p);
        if (arc != INVALID) return direct(arc, false);
      }
      return INVALID;
    }

    Edge findEdge(Node s, Node t, Edge p = INVALID) const {
      if (s != t) {
        if (p == INVALID) {
          Edge arc = Parent::findArc(s, t);
          if (arc != INVALID) return arc;
          arc = Parent::findArc(t, s);
          if (arc != INVALID) return arc;
        } else if (Parent::s(p) == s) {
          Edge arc = Parent::findArc(s, t, p);
          if (arc != INVALID) return arc;
          arc = Parent::findArc(t, s);
          if (arc != INVALID) return arc;
        } else {
          Edge arc = Parent::findArc(t, s, p);
          if (arc != INVALID) return arc;
        }
      } else {
        return Parent::findArc(s, t, p);
      }
      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;


    using Parent::first;
    using Parent::next;

    using Parent::id;

    class Red : public Node {
      friend class BidirBpGraphExtender;
    public:
      Red() {}
      Red(const Node& node) : Node(node) {
        LEMON_DEBUG(Parent::red(node) || node == INVALID,
                    typename Parent::NodeSetError());
      }
      Red& operator=(const Node& node) {
        LEMON_DEBUG(Parent::red(node) || node == INVALID,
                    typename Parent::NodeSetError());
        Node::operator=(node);
        return *this;
      }
      Red(Invalid) : Node(INVALID) {}
      Red& operator=(Invalid) {
        Node::operator=(INVALID);
        return *this;
      }
    };

    void first(Red& node) const {
      Parent::firstRed(static_cast<Node&>(node));
    }
    void next(Red& node) const {
      Parent::nextRed(static_cast<Node&>(node));
    }

    int id(const Red& node) const {
      return Parent::redId(node);
    }

    class Blue : public Node {
      friend class BidirBpGraphExtender;
    public:
      Blue() {}
      Blue(const Node& node) : Node(node) {
        LEMON_DEBUG(Parent::blue(node) || node == INVALID,
                    typename Parent::NodeSetError());
      }
      Blue& operator=(const Node& node) {
        LEMON_DEBUG(Parent::blue(node) || node == INVALID,
                    typename Parent::NodeSetError());
        Node::operator=(node);
        return *this;
      }
      Blue(Invalid) : Node(INVALID) {}
      Blue& operator=(Invalid) {
        Node::operator=(INVALID);
        return *this;
      }
    };

    void first(Blue& node) const {
      Parent::firstBlue(static_cast<Node&>(node));
    }
    void next(Blue& node) const {
      Parent::nextBlue(static_cast<Node&>(node));
    }

    int id(const Blue& node) const {
      return Parent::redId(node);
    }

    Node source(const Edge& arc) const {
      return red(arc);
    }
    Node target(const Edge& arc) const {
      return blue(arc);
    }

    void firstInc(Edge& arc, bool& dir, const Node& node) const {
      if (Parent::red(node)) {
        Parent::firstFromRed(arc, node);
        dir = true;
      } else {
        Parent::firstFromBlue(arc, node);
        dir = static_cast<Edge&>(arc) == INVALID;
      }
    }
    void nextInc(Edge& arc, bool& dir) const {
      if (dir) {
        Parent::nextFromRed(arc);
      } else {
        Parent::nextFromBlue(arc);
        if (arc == INVALID) dir = true;
      }
    }

    class Arc : public Edge {
      friend class BidirBpGraphExtender;
    protected:
      bool forward;

      Arc(const Edge& arc, bool _forward)
        : Edge(arc), forward(_forward) {}

    public:
      Arc() {}
      Arc (Invalid) : Edge(INVALID), forward(true) {}
      bool operator==(const Arc& i) const {
        return Edge::operator==(i) && forward == i.forward;
      }
      bool operator!=(const Arc& i) const {
        return Edge::operator!=(i) || forward != i.forward;
      }
      bool operator<(const Arc& i) const {
        return Edge::operator<(i) ||
          (!(i.forward<forward) && Edge(*this)<Edge(i));
      }
    };

    void first(Arc& arc) const {
      Parent::first(static_cast<Edge&>(arc));
      arc.forward = true;
    }

    void next(Arc& arc) const {
      if (!arc.forward) {
        Parent::next(static_cast<Edge&>(arc));
      }
      arc.forward = !arc.forward;
    }

    void firstOut(Arc& arc, const Node& node) const {
      if (Parent::red(node)) {
        Parent::firstFromRed(arc, node);
        arc.forward = true;
      } else {
        Parent::firstFromBlue(arc, node);
        arc.forward = static_cast<Edge&>(arc) == INVALID;
      }
    }
    void nextOut(Arc& arc) const {
      if (arc.forward) {
        Parent::nextFromRed(arc);
      } else {
        Parent::nextFromBlue(arc);
        arc.forward = static_cast<Edge&>(arc) == INVALID;
      }
    }

    void firstIn(Arc& arc, const Node& node) const {
      if (Parent::blue(node)) {
        Parent::firstFromBlue(arc, node);
        arc.forward = true;
      } else {
        Parent::firstFromRed(arc, node);
        arc.forward = static_cast<Edge&>(arc) == INVALID;
      }
    }
    void nextIn(Arc& arc) const {
      if (arc.forward) {
        Parent::nextFromBlue(arc);
      } else {
        Parent::nextFromRed(arc);
        arc.forward = static_cast<Edge&>(arc) == INVALID;
      }
    }

    Node source(const Arc& arc) const {
      return arc.forward ? Parent::red(arc) : Parent::blue(arc);
    }
    Node target(const Arc& arc) const {
      return arc.forward ? Parent::blue(arc) : Parent::red(arc);
    }

    int id(const Arc& arc) const {
      return (Parent::id(static_cast<const Edge&>(arc)) << 1) +
        (arc.forward ? 0 : 1);
    }
    Arc arcFromId(int ix) const {
      return Arc(Parent::fromEdgeId(ix >> 1), (ix & 1) == 0);
    }
    int maxArcId() const {
      return (Parent::maxEdgeId() << 1) + 1;
    }

    bool direction(const Arc& arc) const {
      return arc.forward;
    }

    Arc direct(const Edge& arc, bool dir) const {
      return Arc(arc, dir);
    }

    int arcNum() const {
      return 2 * Parent::edgeNum();
    }

    int edgeNum() const {
      return Parent::edgeNum();
    }


  };
}

#endif

lemon/bits/default_map.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2009
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_BITS_DEFAULT_MAP_H
 		#define LEMON_BITS_DEFAULT_MAP_H
 		#include <lemon/config.h>
 		#include <lemon/bits/array_map.h>
 		#include <lemon/bits/vector_map.h>
 		//#include <lemon/bits/debug_map.h>
 		//\ingroup graphbits
 		//\file
 		//\brief Graph maps that construct and destruct their elements dynamically.
 		namespace lemon {
 		  //#ifndef LEMON_USE_DEBUG_MAP
 		  template <typename _Graph, typename _Item, typename _Value>
 		  struct DefaultMapSelector {
 		    typedef ArrayMap<_Graph, _Item, _Value> Map;
 		  };
 		  // bool
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, bool> {
 		    typedef VectorMap<_Graph, _Item, bool> Map;
 		  };
 		  // char
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, char> {
 		    typedef VectorMap<_Graph, _Item, char> Map;
 		  };
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, signed char> {
 		    typedef VectorMap<_Graph, _Item, signed char> Map;
 		  };
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, unsigned char> {
 		    typedef VectorMap<_Graph, _Item, unsigned char> Map;
 		  };
 		  // int
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, signed int> {
 		    typedef VectorMap<_Graph, _Item, signed int> Map;
 		  };
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, unsigned int> {
 		    typedef VectorMap<_Graph, _Item, unsigned int> Map;
 		  };
 		  // short
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, signed short> {
 		    typedef VectorMap<_Graph, _Item, signed short> Map;
 		  };
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, unsigned short> {
 		    typedef VectorMap<_Graph, _Item, unsigned short> Map;
 		  };
 		  // long
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, signed long> {
 		    typedef VectorMap<_Graph, _Item, signed long> Map;
 		  };
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, unsigned long> {
 		    typedef VectorMap<_Graph, _Item, unsigned long> Map;
 		  };
 		#if defined HAVE_LONG_LONG
 		  // long long
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, signed long long> {
 		    typedef VectorMap<_Graph, _Item, signed long long> Map;
 		  };
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, unsigned long long> {
 		    typedef VectorMap<_Graph, _Item, unsigned long long> Map;
 		  };
 		#endif
 		  // float
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, float> {
 		    typedef VectorMap<_Graph, _Item, float> Map;
 		  };
 		  // double
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, double> {
 		    typedef VectorMap<_Graph, _Item,  double> Map;
 		  };
 		  // long double
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, long double> {
 		    typedef VectorMap<_Graph, _Item, long double> Map;
 		  };
 		  // pointer
 		  template <typename _Graph, typename _Item, typename _Ptr>
 		  struct DefaultMapSelector<_Graph, _Item, _Ptr*> {
 		    typedef VectorMap<_Graph, _Item, _Ptr*> Map;
 		  };
 		// #else
 		//   template <typename _Graph, typename _Item, typename _Value>
 		//   struct DefaultMapSelector {
 		//     typedef DebugMap<_Graph, _Item, _Value> Map;
 		//   };
 		// #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);
+		    }
 		    template <typename CMap>
 		    DefaultMap& operator=(const CMap& cmap) {
 		      Parent::operator=(cmap);
 		      return *this;
+		    }
 		  };
+		}
 		#endif

lemon/bits/edge_set_extender.h

Show inline comments

 		/* -*- C++ -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 *
 		 * Copyright (C) 2003-2008
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_BITS_EDGE_SET_EXTENDER_H
 		#define LEMON_BITS_EDGE_SET_EXTENDER_H
 		#include <lemon/core.h>
 		#include <lemon/error.h>
 		#include <lemon/bits/default_map.h>
 		#include <lemon/bits/map_extender.h>
 		//\ingroup digraphbits
 		//\file
 		//\brief Extenders for the arc set types
 		namespace lemon {
 		  // \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;
 		    int maxId(Node) const {
 		      return Parent::maxNodeId();
+		    }
 		    int maxId(Arc) const {
 		      return Parent::maxArcId();
+		    }
 		    Node fromId(int id, Node) const {
 		      return Parent::nodeFromId(id);
+		    }
 		    Arc fromId(int id, Arc) const {
 		      return Parent::arcFromId(id);
+		    }
 		    Node oppositeNode(const Node &n, const Arc &e) const {
 		      if (n == Parent::source(e))
 			return Parent::target(e);
 		      else if(n==Parent::target(e))
 			return Parent::source(e);
 		      else
 			return INVALID;
+		    }
 		    // Alteration notifier extensions
 		    // The arc observer registry.
 		    typedef AlterationNotifier<ArcSetExtender, Arc> ArcNotifier;
 		  protected:
 		    mutable ArcNotifier arc_notifier;
 		  public:
 		    using Parent::notifier;
 		    // Gives back the arc alteration notifier.
 		    ArcNotifier& notifier(Arc) const {
 		      return arc_notifier;
+		    }
 		    // Iterable extensions
 		    class NodeIt : public Node {
 		      const Digraph* digraph;
 		    public:
 		      NodeIt() {}
 		      NodeIt(Invalid i) : Node(i) { }
 		      explicit NodeIt(const Digraph& _graph) : digraph(&_graph) {
 			_graph.first(static_cast<Node&>(*this));
+		      }
 		      NodeIt(const Digraph& _graph, const Node& node)
 			: Node(node), digraph(&_graph) {}
 		      NodeIt& operator++() {
 			digraph->next(*this);
 			return *this;
+		      }
 		    };
 		    class ArcIt : public Arc {
 		      const Digraph* digraph;
 		    public:
 		      ArcIt() { }
 		      ArcIt(Invalid i) : Arc(i) { }
 		      explicit ArcIt(const Digraph& _graph) : digraph(&_graph) {
 			_graph.first(static_cast<Arc&>(*this));
+		      }
 		      ArcIt(const Digraph& _graph, const Arc& e) :
 			Arc(e), digraph(&_graph) { }
 		      ArcIt& operator++() {
 			digraph->next(*this);
 			return *this;
+		      }
 		    };
 		    class OutArcIt : public Arc {
 		      const Digraph* digraph;
 		    public:
 		      OutArcIt() { }
 		      OutArcIt(Invalid i) : Arc(i) { }
 		      OutArcIt(const Digraph& _graph, const Node& node)
 			: digraph(&_graph) {
 			_graph.firstOut(*this, node);
+		      }
 		      OutArcIt(const Digraph& _graph, const Arc& arc)
 			: Arc(arc), digraph(&_graph) {}
 		      OutArcIt& operator++() {
 			digraph->nextOut(*this);
 			return *this;
+		      }
 		    };
 		    class InArcIt : public Arc {
 		      const Digraph* digraph;
 		    public:
 		      InArcIt() { }
 		      InArcIt(Invalid i) : Arc(i) { }
 		      InArcIt(const Digraph& _graph, const Node& node)
 			: digraph(&_graph) {
 			_graph.firstIn(*this, node);
+		      }
 		      InArcIt(const Digraph& _graph, const Arc& arc) :
 			Arc(arc), digraph(&_graph) {}
 		      InArcIt& operator++() {
 			digraph->nextIn(*this);
 			return *this;
+		      }
 		    };
 		    // \brief Base node of the iterator
 		    //
 		    // Returns the base node (ie. the source in this case) of the iterator
 		    Node baseNode(const OutArcIt &e) const {
 		      return Parent::source(static_cast<const Arc&>(e));
+		    }
 		    // \brief Running node of the iterator
 		    //
 		    // Returns the running node (ie. the target in this case) of the
 		    // iterator
 		    Node runningNode(const OutArcIt &e) const {
 		      return Parent::target(static_cast<const Arc&>(e));
+		    }
 		    // \brief Base node of the iterator
 		    //
 		    // Returns the base node (ie. the target in this case) of the iterator
 		    Node baseNode(const InArcIt &e) const {
 		      return Parent::target(static_cast<const Arc&>(e));
+		    }
 		    // \brief Running node of the iterator
 		    //
 		    // Returns the running node (ie. the source in this case) of the
 		    // iterator
 		    Node runningNode(const InArcIt &e) const {
 		      return Parent::source(static_cast<const Arc&>(e));
+		    }
 		    using Parent::first;
 		    // 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) {
 			return operator=<ArcMap>(cmap);
+		      }
 		      template <typename CMap>
 		      ArcMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 			return *this;
+		      }
 		    };
 		    // Alteration extension
 		    Arc addArc(const Node& from, const Node& to) {
 		      Arc arc = Parent::addArc(from, to);
 		      notifier(Arc()).add(arc);
 		      return arc;
+		    }
 		    void clear() {
 		      notifier(Arc()).clear();
 		      Parent::clear();
+		    }
 		    void erase(const Arc& arc) {
 		      notifier(Arc()).erase(arc);
 		      Parent::erase(arc);
+		    }
 		    ArcSetExtender() {
 		      arc_notifier.setContainer(*this);
+		    }
 		    ~ArcSetExtender() {
 		      arc_notifier.clear();
+		    }
 		  };
 		  // \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();
+		    }
 		    int maxId(Edge) const {
 		      return Parent::maxEdgeId();
+		    }
 		    Node fromId(int id, Node) const {
 		      return Parent::nodeFromId(id);
+		    }
 		    Arc fromId(int id, Arc) const {
 		      return Parent::arcFromId(id);
+		    }
 		    Edge fromId(int id, Edge) const {
 		      return Parent::edgeFromId(id);
+		    }
 		    Node oppositeNode(const Node &n, const Edge &e) const {
 		      if( n == Parent::u(e))
 			return Parent::v(e);
 		      else if( n == Parent::v(e))
 			return Parent::u(e);
 		      else
 			return INVALID;
+		    }
 		    Arc oppositeArc(const Arc &e) const {
 		      return Parent::direct(e, !Parent::direction(e));
+		    }
 		    using Parent::direct;
 		    Arc direct(const Edge &e, const Node &s) const {
 		      return Parent::direct(e, Parent::u(e) == s);
+		    }
 		    typedef AlterationNotifier<EdgeSetExtender, Arc> ArcNotifier;
 		    typedef AlterationNotifier<EdgeSetExtender, Edge> EdgeNotifier;
 		  protected:
 		    mutable ArcNotifier arc_notifier;
 		    mutable EdgeNotifier edge_notifier;
 		  public:
 		    using Parent::notifier;
 		    ArcNotifier& notifier(Arc) const {
 		      return arc_notifier;
+		    }
 		    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
 		    //
 		    // Returns the base node (ie. the source in this case) of the iterator
 		    Node baseNode(const OutArcIt &e) const {
 		      return Parent::source(static_cast<const Arc&>(e));
+		    }
 		    // \brief Running node of the iterator
 		    //
 		    // Returns the running node (ie. the target in this case) of the
 		    // iterator
 		    Node runningNode(const OutArcIt &e) const {
 		      return Parent::target(static_cast<const Arc&>(e));
+		    }
 		    // \brief Base node of the iterator
 		    //
 		    // Returns the base node (ie. the target in this case) of the iterator
 		    Node baseNode(const InArcIt &e) const {
 		      return Parent::target(static_cast<const Arc&>(e));
+		    }
 		    // \brief Running node of the iterator
 		    //
 		    // Returns the running node (ie. the source in this case) of the
 		    // iterator
 		    Node runningNode(const InArcIt &e) const {
 		      return Parent::source(static_cast<const Arc&>(e));
+		    }
 		    // Base node of the iterator
 		    //
 		    // Returns the base node of the iterator
 		    Node baseNode(const IncEdgeIt &e) const {
 		      return e.direction ? u(e) : v(e);
+		    }
 		    // Running node of the iterator
 		    //
 		    // Returns the running node of the iterator
 		    Node runningNode(const IncEdgeIt &e) const {
 		      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);
+		      }
 		      template <typename CMap>
 		      ArcMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 			return *this;
+		      }
 		    };
 		    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);
+		      }
 		      template <typename CMap>
 		      EdgeMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 			return *this;
+		      }
 		    };
 		    // Alteration extension
 		    Edge addEdge(const Node& from, const Node& to) {
 		      Edge edge = Parent::addEdge(from, to);
 		      notifier(Edge()).add(edge);
 		      std::vector<Arc> arcs;
 		      arcs.push_back(Parent::direct(edge, true));
 		      arcs.push_back(Parent::direct(edge, false));
 		      notifier(Arc()).add(arcs);
 		      return edge;
+		    }
 		    void clear() {
 		      notifier(Arc()).clear();
 		      notifier(Edge()).clear();
 		      Parent::clear();
+		    }
 		    void erase(const Edge& edge) {
 		      std::vector<Arc> arcs;
 		      arcs.push_back(Parent::direct(edge, true));
 		      arcs.push_back(Parent::direct(edge, false));
 		      notifier(Arc()).erase(arcs);
 		      notifier(Edge()).erase(edge);
 		      Parent::erase(edge);
+		    }
 		    EdgeSetExtender() {
 		      arc_notifier.setContainer(*this);
 		      edge_notifier.setContainer(*this);
+		    }
 		    ~EdgeSetExtender() {
 		      edge_notifier.clear();
 		      arc_notifier.clear();
+		    }
 		  };
+		}
 		#endif

lemon/bits/graph_adaptor_extender.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2009
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_BITS_GRAPH_ADAPTOR_EXTENDER_H
 		#define LEMON_BITS_GRAPH_ADAPTOR_EXTENDER_H
 		#include <lemon/core.h>
 		#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;
 		    typedef typename Parent::Arc Arc;
 		    int maxId(Node) const {
 		      return Parent::maxNodeId();
+		    }
 		    int maxId(Arc) const {
 		      return Parent::maxArcId();
+		    }
 		    Node fromId(int id, Node) const {
 		      return Parent::nodeFromId(id);
+		    }
 		    Arc fromId(int id, Arc) const {
 		      return Parent::arcFromId(id);
+		    }
 		    Node oppositeNode(const Node &n, const Arc &e) const {
 		      if (n == Parent::source(e))
 		        return Parent::target(e);
 		      else if(n==Parent::target(e))
 		        return Parent::source(e);
 		      else
 		        return INVALID;
+		    }
 		    class NodeIt : public Node {
 		      const Adaptor* _adaptor;
 		    public:
 		      NodeIt() {}
 		      NodeIt(Invalid i) : Node(i) { }
 		      explicit NodeIt(const Adaptor& adaptor) : _adaptor(&adaptor) {
 		        _adaptor->first(static_cast<Node&>(*this));
+		      }
 		      NodeIt(const Adaptor& adaptor, const Node& node)
 		        : Node(node), _adaptor(&adaptor) {}
 		      NodeIt& operator++() {
 		        _adaptor->next(*this);
 		        return *this;
+		      }
 		    };
 		    class ArcIt : public Arc {
 		      const Adaptor* _adaptor;
 		    public:
 		      ArcIt() { }
 		      ArcIt(Invalid i) : Arc(i) { }
 		      explicit ArcIt(const Adaptor& adaptor) : _adaptor(&adaptor) {
 		        _adaptor->first(static_cast<Arc&>(*this));
+		      }
 		      ArcIt(const Adaptor& adaptor, const Arc& e) :
 		        Arc(e), _adaptor(&adaptor) { }
 		      ArcIt& operator++() {
 		        _adaptor->next(*this);
 		        return *this;
+		      }
 		    };
 		    class OutArcIt : public Arc {
 		      const Adaptor* _adaptor;
 		    public:
 		      OutArcIt() { }
 		      OutArcIt(Invalid i) : Arc(i) { }
 		      OutArcIt(const Adaptor& adaptor, const Node& node)
 		        : _adaptor(&adaptor) {
 		        _adaptor->firstOut(*this, node);
+		      }
 		      OutArcIt(const Adaptor& adaptor, const Arc& arc)
 		        : Arc(arc), _adaptor(&adaptor) {}
 		      OutArcIt& operator++() {
 		        _adaptor->nextOut(*this);
 		        return *this;
+		      }
 		    };
 		    class InArcIt : public Arc {
 		      const Adaptor* _adaptor;
 		    public:
 		      InArcIt() { }
 		      InArcIt(Invalid i) : Arc(i) { }
 		      InArcIt(const Adaptor& adaptor, const Node& node)
 		        : _adaptor(&adaptor) {
 		        _adaptor->firstIn(*this, node);
+		      }
 		      InArcIt(const Adaptor& adaptor, const Arc& arc) :
 		        Arc(arc), _adaptor(&adaptor) {}
 		      InArcIt& operator++() {
 		        _adaptor->nextIn(*this);
 		        return *this;
+		      }
 		    };
 		    Node baseNode(const OutArcIt &e) const {
 		      return Parent::source(e);
+		    }
 		    Node runningNode(const OutArcIt &e) const {
 		      return Parent::target(e);
+		    }
 		    Node baseNode(const InArcIt &e) const {
 		      return Parent::target(e);
+		    }
 		    Node runningNode(const InArcIt &e) const {
 		      return Parent::source(e);
+		    }
 		  };
 		  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;
 		    // Graph extension
 		    int maxId(Node) const {
 		      return Parent::maxNodeId();
+		    }
 		    int maxId(Arc) const {
 		      return Parent::maxArcId();
+		    }
 		    int maxId(Edge) const {
 		      return Parent::maxEdgeId();
+		    }
 		    Node fromId(int id, Node) const {
 		      return Parent::nodeFromId(id);
+		    }
 		    Arc fromId(int id, Arc) const {
 		      return Parent::arcFromId(id);
+		    }
 		    Edge fromId(int id, Edge) const {
 		      return Parent::edgeFromId(id);
+		    }
 		    Node oppositeNode(const Node &n, const Edge &e) const {
 		      if( n == Parent::u(e))
 		        return Parent::v(e);
 		      else if( n == Parent::v(e))
 		        return Parent::u(e);
 		      else
 		        return INVALID;
+		    }
 		    Arc oppositeArc(const Arc &a) const {
 		      return Parent::direct(a, !Parent::direction(a));
+		    }
 		    using Parent::direct;
 		    Arc direct(const Edge &e, const Node &s) const {
 		      return Parent::direct(e, Parent::u(e) == s);
+		    }
 		    class NodeIt : public Node {
 		      const Adaptor* _adaptor;
 		    public:
 		      NodeIt() {}
 		      NodeIt(Invalid i) : Node(i) { }
 		      explicit NodeIt(const Adaptor& adaptor) : _adaptor(&adaptor) {
 		        _adaptor->first(static_cast<Node&>(*this));
+		      }
 		      NodeIt(const Adaptor& adaptor, const Node& node)
 		        : Node(node), _adaptor(&adaptor) {}
 		      NodeIt& operator++() {
 		        _adaptor->next(*this);
 		        return *this;
+		      }
 		    };
 		    class ArcIt : public Arc {
 		      const Adaptor* _adaptor;
 		    public:
 		      ArcIt() { }
 		      ArcIt(Invalid i) : Arc(i) { }
 		      explicit ArcIt(const Adaptor& adaptor) : _adaptor(&adaptor) {
 		        _adaptor->first(static_cast<Arc&>(*this));
+		      }
 		      ArcIt(const Adaptor& adaptor, const Arc& e) :
 		        Arc(e), _adaptor(&adaptor) { }
 		      ArcIt& operator++() {
 		        _adaptor->next(*this);
 		        return *this;
+		      }
 		    };
 		    class OutArcIt : public Arc {
 		      const Adaptor* _adaptor;
 		    public:
 		      OutArcIt() { }
 		      OutArcIt(Invalid i) : Arc(i) { }
 		      OutArcIt(const Adaptor& adaptor, const Node& node)
 		        : _adaptor(&adaptor) {
 		        _adaptor->firstOut(*this, node);
+		      }
 		      OutArcIt(const Adaptor& adaptor, const Arc& arc)
 		        : Arc(arc), _adaptor(&adaptor) {}
 		      OutArcIt& operator++() {
 		        _adaptor->nextOut(*this);
 		        return *this;
+		      }
 		    };
 		    class InArcIt : public Arc {
 		      const Adaptor* _adaptor;
 		    public:
 		      InArcIt() { }
 		      InArcIt(Invalid i) : Arc(i) { }
 		      InArcIt(const Adaptor& adaptor, const Node& node)
 		        : _adaptor(&adaptor) {
 		        _adaptor->firstIn(*this, node);
+		      }
 		      InArcIt(const Adaptor& adaptor, const Arc& arc) :
 		        Arc(arc), _adaptor(&adaptor) {}
 		      InArcIt& operator++() {
 		        _adaptor->nextIn(*this);
 		        return *this;
+		      }
 		    };
 		    class EdgeIt : public Parent::Edge {
 		      const Adaptor* _adaptor;
 		    public:
 		      EdgeIt() { }
 		      EdgeIt(Invalid i) : Edge(i) { }
 		      explicit EdgeIt(const Adaptor& adaptor) : _adaptor(&adaptor) {
 		        _adaptor->first(static_cast<Edge&>(*this));
+		      }
 		      EdgeIt(const Adaptor& adaptor, const Edge& e) :
 		        Edge(e), _adaptor(&adaptor) { }
 		      EdgeIt& operator++() {
 		        _adaptor->next(*this);
 		        return *this;
+		      }
 		    };
 		    class IncEdgeIt : public Edge {
 		      friend class GraphAdaptorExtender;
 		      const Adaptor* _adaptor;
 		      bool direction;
 		    public:
 		      IncEdgeIt() { }
 		      IncEdgeIt(Invalid i) : Edge(i), direction(false) { }
 		      IncEdgeIt(const Adaptor& adaptor, const Node &n) : _adaptor(&adaptor) {
 		        _adaptor->firstInc(static_cast<Edge&>(*this), direction, n);
+		      }
 		      IncEdgeIt(const Adaptor& adaptor, const Edge &e, const Node &n)
 		        : _adaptor(&adaptor), Edge(e) {
 		        direction = (_adaptor->u(e) == n);
+		      }
 		      IncEdgeIt& operator++() {
 		        _adaptor->nextInc(*this, direction);
 		        return *this;
+		      }
 		    };
 		    Node baseNode(const OutArcIt &a) const {
 		      return Parent::source(a);
+		    }
 		    Node runningNode(const OutArcIt &a) const {
 		      return Parent::target(a);
+		    }
 		    Node baseNode(const InArcIt &a) const {
 		      return Parent::target(a);
+		    }
 		    Node runningNode(const InArcIt &a) const {
 		      return Parent::source(a);
+		    }
 		    Node baseNode(const IncEdgeIt &e) const {
 		      return e.direction ? Parent::u(e) : Parent::v(e);
+		    }
 		    Node runningNode(const IncEdgeIt &e) const {
 		      return e.direction ? Parent::v(e) : Parent::u(e);
+		    }
 		  };
+		}
 		#endif

lemon/bits/graph_extender.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2009
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_BITS_GRAPH_EXTENDER_H
 		#define LEMON_BITS_GRAPH_EXTENDER_H
 		#include <lemon/core.h>
 		#include <lemon/bits/map_extender.h>
 		#include <lemon/bits/default_map.h>
 		#include <lemon/concept_check.h>
 		#include <lemon/concepts/maps.h>
 		//\ingroup graphbits
 		//\file
 		//\brief Extenders for the graph types
 		namespace lemon {
 		  // \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;
 		    int maxId(Node) const {
 		      return Parent::maxNodeId();
+		    }
 		    int maxId(Arc) const {
 		      return Parent::maxArcId();
+		    }
 		    Node fromId(int id, Node) const {
 		      return Parent::nodeFromId(id);
+		    }
 		    Arc fromId(int id, Arc) const {
 		      return Parent::arcFromId(id);
+		    }
 		    Node oppositeNode(const Node &node, const Arc &arc) const {
 		      if (node == Parent::source(arc))
 		        return Parent::target(arc);
 		      else if(node == Parent::target(arc))
 		        return Parent::source(arc);
 		      else
 		        return INVALID;
+		    }
 		    // Alterable extension
 		    typedef AlterationNotifier<DigraphExtender, Node> NodeNotifier;
 		    typedef AlterationNotifier<DigraphExtender, Arc> ArcNotifier;
 		  protected:
 		    mutable NodeNotifier node_notifier;
 		    mutable ArcNotifier arc_notifier;
 		  public:
 		    NodeNotifier& notifier(Node) const {
 		      return node_notifier;
+		    }
 		    ArcNotifier& notifier(Arc) const {
 		      return arc_notifier;
+		    }
 		    class NodeIt : public Node {
 		      const Digraph* _digraph;
 		    public:
 		      NodeIt() {}
 		      NodeIt(Invalid i) : Node(i) { }
 		      explicit NodeIt(const Digraph& digraph) : _digraph(&digraph) {
 		        _digraph->first(static_cast<Node&>(*this));
+		      }
 		      NodeIt(const Digraph& digraph, const Node& node)
 		        : Node(node), _digraph(&digraph) {}
 		      NodeIt& operator++() {
 		        _digraph->next(*this);
 		        return *this;
+		      }
 		    };
 		    class ArcIt : public Arc {
 		      const Digraph* _digraph;
 		    public:
 		      ArcIt() { }
 		      ArcIt(Invalid i) : Arc(i) { }
 		      explicit ArcIt(const Digraph& digraph) : _digraph(&digraph) {
 		        _digraph->first(static_cast<Arc&>(*this));
+		      }
 		      ArcIt(const Digraph& digraph, const Arc& arc) :
 		        Arc(arc), _digraph(&digraph) { }
 		      ArcIt& operator++() {
 		        _digraph->next(*this);
 		        return *this;
+		      }
 		    };
 		    class OutArcIt : public Arc {
 		      const Digraph* _digraph;
 		    public:
 		      OutArcIt() { }
 		      OutArcIt(Invalid i) : Arc(i) { }
 		      OutArcIt(const Digraph& digraph, const Node& node)
 		        : _digraph(&digraph) {
 		        _digraph->firstOut(*this, node);
+		      }
 		      OutArcIt(const Digraph& digraph, const Arc& arc)
 		        : Arc(arc), _digraph(&digraph) {}
 		      OutArcIt& operator++() {
 		        _digraph->nextOut(*this);
 		        return *this;
+		      }
 		    };
 		    class InArcIt : public Arc {
 		      const Digraph* _digraph;
 		    public:
 		      InArcIt() { }
 		      InArcIt(Invalid i) : Arc(i) { }
 		      InArcIt(const Digraph& digraph, const Node& node)
 		        : _digraph(&digraph) {
 		        _digraph->firstIn(*this, node);
+		      }
 		      InArcIt(const Digraph& digraph, const Arc& arc) :
 		        Arc(arc), _digraph(&digraph) {}
 		      InArcIt& operator++() {
 		        _digraph->nextIn(*this);
 		        return *this;
+		      }
 		    };
 		    // \brief Base node of the iterator
 		    //
 		    // Returns the base node (i.e. the source in this case) of the iterator
 		    Node baseNode(const OutArcIt &arc) const {
 		      return Parent::source(arc);
+		    }
 		    // \brief Running node of the iterator
 		    //
 		    // Returns the running node (i.e. the target in this case) of the
 		    // iterator
 		    Node runningNode(const OutArcIt &arc) const {
 		      return Parent::target(arc);
+		    }
 		    // \brief Base node of the iterator
 		    //
 		    // Returns the base node (i.e. the target in this case) of the iterator
 		    Node baseNode(const InArcIt &arc) const {
 		      return Parent::target(arc);
+		    }
 		    // \brief Running node of the iterator
 		    //
 		    // Returns the running node (i.e. the source in this case) of the
 		    // iterator
 		    Node runningNode(const InArcIt &arc) const {
 		      return Parent::source(arc);
+		    }
 		    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:
 		      NodeMap& operator=(const NodeMap& cmap) {
 		        return operator=<NodeMap>(cmap);
+		      }
 		      template <typename CMap>
 		      NodeMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		    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:
 		      ArcMap& operator=(const ArcMap& cmap) {
 		        return operator=<ArcMap>(cmap);
+		      }
 		      template <typename CMap>
 		      ArcMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		    Node addNode() {
 		      Node node = Parent::addNode();
 		      notifier(Node()).add(node);
 		      return node;
+		    }
 		    Arc addArc(const Node& from, const Node& to) {
 		      Arc arc = Parent::addArc(from, to);
 		      notifier(Arc()).add(arc);
 		      return arc;
+		    }
 		    void clear() {
 		      notifier(Arc()).clear();
 		      notifier(Node()).clear();
 		      Parent::clear();
+		    }
 		    template <typename Digraph, typename NodeRefMap, typename ArcRefMap>
 		    void build(const Digraph& digraph, NodeRefMap& nodeRef, ArcRefMap& arcRef) {
 		      Parent::build(digraph, nodeRef, arcRef);
 		      notifier(Node()).build();
 		      notifier(Arc()).build();
+		    }
 		    void erase(const Node& node) {
 		      Arc arc;
 		      Parent::firstOut(arc, node);
 		      while (arc != INVALID ) {
 		        erase(arc);
 		        Parent::firstOut(arc, node);
+		      }
 		      Parent::firstIn(arc, node);
 		      while (arc != INVALID ) {
 		        erase(arc);
 		        Parent::firstIn(arc, node);
+		      }
 		      notifier(Node()).erase(node);
 		      Parent::erase(node);
+		    }
 		    void erase(const Arc& arc) {
 		      notifier(Arc()).erase(arc);
 		      Parent::erase(arc);
+		    }
 		    DigraphExtender() {
 		      node_notifier.setContainer(*this);
 		      arc_notifier.setContainer(*this);
+		    }
 		    ~DigraphExtender() {
 		      arc_notifier.clear();
 		      node_notifier.clear();
+		    }
 		  };
 		  // \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;
 		    typedef typename Parent::Edge Edge;
 		    // Graph extension
 		    int maxId(Node) const {
 		      return Parent::maxNodeId();
+		    }
 		    int maxId(Arc) const {
 		      return Parent::maxArcId();
+		    }
 		    int maxId(Edge) const {
 		      return Parent::maxEdgeId();
+		    }
 		    Node fromId(int id, Node) const {
 		      return Parent::nodeFromId(id);
+		    }
 		    Arc fromId(int id, Arc) const {
 		      return Parent::arcFromId(id);
+		    }
 		    Edge fromId(int id, Edge) const {
 		      return Parent::edgeFromId(id);
+		    }
 		    Node oppositeNode(const Node &n, const Edge &e) const {
 		      if( n == Parent::u(e))
 		        return Parent::v(e);
 		      else if( n == Parent::v(e))
 		        return Parent::u(e);
 		      else
 		        return INVALID;
+		    }
 		    Arc oppositeArc(const Arc &arc) const {
 		      return Parent::direct(arc, !Parent::direction(arc));
+		    }
 		    using Parent::direct;
 		    Arc direct(const Edge &edge, const Node &node) const {
 		      return Parent::direct(edge, Parent::u(edge) == node);
+		    }
 		    // Alterable extension
 		    typedef AlterationNotifier<GraphExtender, Node> NodeNotifier;
 		    typedef AlterationNotifier<GraphExtender, Arc> ArcNotifier;
 		    typedef AlterationNotifier<GraphExtender, Edge> EdgeNotifier;
 		  protected:
 		    mutable NodeNotifier node_notifier;
 		    mutable ArcNotifier arc_notifier;
 		    mutable EdgeNotifier edge_notifier;
 		  public:
 		    NodeNotifier& notifier(Node) const {
 		      return node_notifier;
+		    }
 		    ArcNotifier& notifier(Arc) const {
 		      return arc_notifier;
+		    }
 		    EdgeNotifier& notifier(Edge) const {
 		      return edge_notifier;
+		    }
 		    class NodeIt : public Node {
 		      const Graph* _graph;
 		    public:
 		      NodeIt() {}
 		      NodeIt(Invalid i) : Node(i) { }
 		      explicit NodeIt(const Graph& graph) : _graph(&graph) {
 		        _graph->first(static_cast<Node&>(*this));
+		      }
 		      NodeIt(const Graph& graph, const Node& node)
 		        : Node(node), _graph(&graph) {}
 		      NodeIt& operator++() {
 		        _graph->next(*this);
 		        return *this;
+		      }
 		    };
 		    class ArcIt : public Arc {
 		      const Graph* _graph;
 		    public:
 		      ArcIt() { }
 		      ArcIt(Invalid i) : Arc(i) { }
 		      explicit ArcIt(const Graph& graph) : _graph(&graph) {
 		        _graph->first(static_cast<Arc&>(*this));
+		      }
 		      ArcIt(const Graph& graph, const Arc& arc) :
 		        Arc(arc), _graph(&graph) { }
 		      ArcIt& operator++() {
 		        _graph->next(*this);
 		        return *this;
+		      }
 		    };
 		    class OutArcIt : public Arc {
 		      const Graph* _graph;
 		    public:
 		      OutArcIt() { }
 		      OutArcIt(Invalid i) : Arc(i) { }
 		      OutArcIt(const Graph& graph, const Node& node)
 		        : _graph(&graph) {
 		        _graph->firstOut(*this, node);
+		      }
 		      OutArcIt(const Graph& graph, const Arc& arc)
 		        : Arc(arc), _graph(&graph) {}
 		      OutArcIt& operator++() {
 		        _graph->nextOut(*this);
 		        return *this;
+		      }
 		    };
 		    class InArcIt : public Arc {
 		      const Graph* _graph;
 		    public:
 		      InArcIt() { }
 		      InArcIt(Invalid i) : Arc(i) { }
 		      InArcIt(const Graph& graph, const Node& node)
 		        : _graph(&graph) {
 		        _graph->firstIn(*this, node);
+		      }
 		      InArcIt(const Graph& graph, const Arc& arc) :
 		        Arc(arc), _graph(&graph) {}
 		      InArcIt& operator++() {
 		        _graph->nextIn(*this);
 		        return *this;
+		      }
 		    };
 		    class EdgeIt : public Parent::Edge {
 		      const Graph* _graph;
 		    public:
 		      EdgeIt() { }
 		      EdgeIt(Invalid i) : Edge(i) { }
 		      explicit EdgeIt(const Graph& graph) : _graph(&graph) {
 		        _graph->first(static_cast<Edge&>(*this));
+		      }
 		      EdgeIt(const Graph& graph, const Edge& edge) :
 		        Edge(edge), _graph(&graph) { }
 		      EdgeIt& operator++() {
 		        _graph->next(*this);
 		        return *this;
+		      }
 		    };
 		    class IncEdgeIt : public Parent::Edge {
 		      friend class GraphExtender;
 		      const Graph* _graph;
 		      bool _direction;
 		    public:
 		      IncEdgeIt() { }
 		      IncEdgeIt(Invalid i) : Edge(i), _direction(false) { }
 		      IncEdgeIt(const Graph& graph, const Node &node) : _graph(&graph) {
 		        _graph->firstInc(*this, _direction, node);
+		      }
 		      IncEdgeIt(const Graph& graph, const Edge &edge, const Node &node)
 		        : _graph(&graph), Edge(edge) {
 		        _direction = (_graph->source(edge) == node);
+		      }
 		      IncEdgeIt& operator++() {
 		        _graph->nextInc(*this, _direction);
 		        return *this;
+		      }
 		    };
 		    // \brief Base node of the iterator
 		    //
 		    // Returns the base node (ie. the source in this case) of the iterator
 		    Node baseNode(const OutArcIt &arc) const {
 		      return Parent::source(static_cast<const Arc&>(arc));
+		    }
 		    // \brief Running node of the iterator
 		    //
 		    // Returns the running node (ie. the target in this case) of the
 		    // iterator
 		    Node runningNode(const OutArcIt &arc) const {
 		      return Parent::target(static_cast<const Arc&>(arc));
+		    }
 		    // \brief Base node of the iterator
 		    //
 		    // Returns the base node (ie. the target in this case) of the iterator
 		    Node baseNode(const InArcIt &arc) const {
 		      return Parent::target(static_cast<const Arc&>(arc));
+		    }
 		    // \brief Running node of the iterator
 		    //
 		    // Returns the running node (ie. the source in this case) of the
 		    // iterator
 		    Node runningNode(const InArcIt &arc) const {
 		      return Parent::source(static_cast<const Arc&>(arc));
+		    }
 		    // Base node of the iterator
 		    //
 		    // Returns the base node of the iterator
 		    Node baseNode(const IncEdgeIt &edge) const {
 		      return edge._direction ? u(edge) : v(edge);
+		    }
 		    // Running node of the iterator
 		    //
 		    // Returns the running node of the iterator
 		    Node runningNode(const IncEdgeIt &edge) const {
 		      return edge._direction ? v(edge) : u(edge);
+		    }
 		    // 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:
 		      NodeMap& operator=(const NodeMap& cmap) {
 		        return operator=<NodeMap>(cmap);
+		      }
 		      template <typename CMap>
 		      NodeMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		    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:
 		      ArcMap& operator=(const ArcMap& cmap) {
 		        return operator=<ArcMap>(cmap);
+		      }
 		      template <typename CMap>
 		      ArcMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		    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) {}
 		    private:
 		      EdgeMap& operator=(const EdgeMap& cmap) {
 		        return operator=<EdgeMap>(cmap);
+		      }
 		      template <typename CMap>
 		      EdgeMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		    // Alteration extension
 		    Node addNode() {
 		      Node node = Parent::addNode();
 		      notifier(Node()).add(node);
 		      return node;
+		    }
 		    Edge addEdge(const Node& from, const Node& to) {
 		      Edge edge = Parent::addEdge(from, to);
 		      notifier(Edge()).add(edge);
 		      std::vector<Arc> ev;
 		      ev.push_back(Parent::direct(edge, true));
 		      ev.push_back(Parent::direct(edge, false));
 		      notifier(Arc()).add(ev);
 		      return edge;
+		    }
 		    void clear() {
 		      notifier(Arc()).clear();
 		      notifier(Edge()).clear();
 		      notifier(Node()).clear();
 		      Parent::clear();
+		    }
 		    template <typename Graph, typename NodeRefMap, typename EdgeRefMap>
 		    void build(const Graph& graph, NodeRefMap& nodeRef,
 		               EdgeRefMap& edgeRef) {
 		      Parent::build(graph, nodeRef, edgeRef);
 		      notifier(Node()).build();
 		      notifier(Edge()).build();
 		      notifier(Arc()).build();
+		    }
 		    void erase(const Node& node) {
 		      Arc arc;
 		      Parent::firstOut(arc, node);
 		      while (arc != INVALID ) {
 		        erase(arc);
 		        Parent::firstOut(arc, node);
+		      }
 		      Parent::firstIn(arc, node);
 		      while (arc != INVALID ) {
 		        erase(arc);
 		        Parent::firstIn(arc, node);
+		      }
 		      notifier(Node()).erase(node);
 		      Parent::erase(node);
+		    }
 		    void erase(const Edge& edge) {
 		      std::vector<Arc> av;
 		      av.push_back(Parent::direct(edge, true));
 		      av.push_back(Parent::direct(edge, false));
 		      notifier(Arc()).erase(av);
 		      notifier(Edge()).erase(edge);
 		      Parent::erase(edge);
+		    }
 		    GraphExtender() {
 		      node_notifier.setContainer(*this);
 		      arc_notifier.setContainer(*this);
 		      edge_notifier.setContainer(*this);
+		    }
 		    ~GraphExtender() {
 		      edge_notifier.clear();
 		      arc_notifier.clear();
 		      node_notifier.clear();
+		    }
 		  };
+		}
 		#endif

lemon/bits/map_extender.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2009
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_BITS_MAP_EXTENDER_H
 		#define LEMON_BITS_MAP_EXTENDER_H
 		#include <iterator>
 		#include <lemon/bits/traits.h>
 		#include <lemon/concept_check.h>
 		#include <lemon/concepts/maps.h>
 		//\file
 		//\brief Extenders for iterable maps.
 		namespace lemon {
 		  // \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;
 		    class MapIt;
 		    class ConstMapIt;
 		    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);
+		    }
 		    template <typename CMap>
 		    MapExtender& operator=(const CMap& cmap) {
 		      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) { }
 		      explicit MapIt(Map& _map) : map(_map) {
 		        map.notifier()->first(*this);
+		      }
 		      MapIt(const Map& _map, const Item& item)
 		        : Parent(item), map(_map) {}
 		      MapIt& operator++() {
 		        map.notifier()->next(*this);
 		        return *this;
+		      }
 		      typename MapTraits<Map>::ConstReturnValue operator*() const {
 		        return map[*this];
+		      }
 		      typename MapTraits<Map>::ReturnValue operator*() {
 		        return map[*this];
+		      }
 		      void set(const Value& value) {
 		        map.set(*this, value);
+		      }
 		    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) { }
 		      explicit ConstMapIt(Map& _map) : map(_map) {
 		        map.notifier()->first(*this);
+		      }
 		      ConstMapIt(const Map& _map, const Item& item)
 		        : Parent(item), map(_map) {}
 		      ConstMapIt& operator++() {
 		        map.notifier()->next(*this);
 		        return *this;
+		      }
 		      typename MapTraits<Map>::ConstReturnValue operator*() const {
 		        return map[*this];
+		      }
 		    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);
+		      }
 		      ItemIt(const Map& _map, const Item& item)
 		        : Parent(item), map(_map) {}
 		      ItemIt& operator++() {
 		        map.notifier()->next(*this);
 		        return *this;
+		      }
 		    protected:
 		      const Map& map;
 		    };
 		  };
 		  // \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;
 		    class MapIt;
 		    class ConstMapIt;
 		    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);
+		    }
 		    template <typename CMap>
 		    SubMapExtender& operator=(const CMap& cmap) {
 		      checkConcept<concepts::ReadMap<Key, Value>, CMap>();
 		      Item it;
 		      for (graph.first(it); it != INVALID; graph.next(it)) {
 		        Parent::set(it, cmap[it]);
+		      }
 		      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) { }
 		      explicit MapIt(Map& _map) : map(_map) {
 		        map.graph.first(*this);
+		      }
 		      MapIt(const Map& _map, const Item& item)
 		        : Parent(item), map(_map) {}
 		      MapIt& operator++() {
 		        map.graph.next(*this);
 		        return *this;
+		      }
 		      typename MapTraits<Map>::ConstReturnValue operator*() const {
 		        return map[*this];
+		      }
 		      typename MapTraits<Map>::ReturnValue operator*() {
 		        return map[*this];
+		      }
 		      void set(const Value& value) {
 		        map.set(*this, value);
+		      }
 		    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) { }
 		      explicit ConstMapIt(Map& _map) : map(_map) {
 		        map.graph.first(*this);
+		      }
 		      ConstMapIt(const Map& _map, const Item& item)
 		        : Parent(item), map(_map) {}
 		      ConstMapIt& operator++() {
 		        map.graph.next(*this);
 		        return *this;
+		      }
 		      typename MapTraits<Map>::ConstReturnValue operator*() const {
 		        return map[*this];
+		      }
 		    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);
+		      }
 		      ItemIt(const Map& _map, const Item& item)
 		        : Parent(item), map(_map) {}
 		      ItemIt& operator++() {
 		        map.graph.next(*this);
 		        return *this;
+		      }
 		    protected:
 		      const Map& map;
 		    };
 		  private:
-		    const Graph& graph;
+		    const GraphType& graph;
 		  };
+		}
 		#endif

lemon/bits/vector_map.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2009
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_BITS_VECTOR_MAP_H
 		#define LEMON_BITS_VECTOR_MAP_H
 		#include <vector>
 		#include <algorithm>
 		#include <lemon/core.h>
 		#include <lemon/bits/alteration_notifier.h>
 		#include <lemon/concept_check.h>
 		#include <lemon/concepts/maps.h>
 		//\ingroup graphbits
 		//
 		//\file
 		//\brief Vector based graph maps.
 		namespace lemon {
 		  // \ingroup graphbits
 		  //
 		  // \brief Graph map based on the std::vector storage.
 		  //
 		  // The VectorMap template class is graph map structure that automatically
 		  // updates the map when a key is added to or erased from the graph.
 		  // This map type uses std::vector to store the values.
 		  //
 		  // \tparam _Graph The graph this map is attached to.
 		  // \tparam _Item The item type of the graph items.
 		  // \tparam _Value The value type of the map.
 		  template <typename _Graph, typename _Item, typename _Value>
 		  class VectorMap
 		    : public ItemSetTraits<_Graph, _Item>::ItemNotifier::ObserverBase {
 		  private:
 		    // 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.
 		    typedef _Item Key;
 		    // The value type of the map.
 		    typedef _Value Value;
 		    // 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
 		    //
 		    // Copy constructor.
 		    VectorMap(const VectorMap& _copy) : Parent() {
 		      if (_copy.attached()) {
 		        Parent::attach(*_copy.notifier());
 		        container = _copy.container;
+		      }
+		    }
 		    // \brief Assign operator.
 		    //
 		    // This operator assigns for each item in the map the
 		    // value mapped to the same item in the copied map.
 		    // The parameter map should be indiced with the same
 		    // itemset because this assign operator does not change
 		    // the container of the map.
 		    VectorMap& operator=(const VectorMap& cmap) {
 		      return operator=<VectorMap>(cmap);
+		    }
 		    // \brief Template assign operator.
 		    //
 		    // The given parameter should conform to the ReadMap
 		    // concecpt and could be indiced by the current item set of
 		    // the NodeMap. In this case the value for each item
 		    // is assigned by the value of the given ReadMap.
 		    template <typename CMap>
 		    VectorMap& operator=(const CMap& cmap) {
 		      checkConcept<concepts::ReadMap<Key, _Value>, CMap>();
 		      const typename Parent::Notifier* nf = Parent::notifier();
 		      Item it;
 		      for (nf->first(it); it != INVALID; nf->next(it)) {
 		        set(it, cmap[it]);
+		      }
 		      return *this;
+		    }
 		  public:
 		    // \brief The subcript operator.
 		    //
 		    // The subscript operator. The map can be subscripted by the
 		    // actual items of the graph.
 		    Reference operator[](const Key& key) {
 		      return container[Parent::notifier()->id(key)];
+		    }
 		    // \brief The const subcript operator.
 		    //
 		    // The const subscript operator. The map can be subscripted by the
 		    // actual items of the graph.
 		    ConstReference operator[](const Key& key) const {
 		      return container[Parent::notifier()->id(key)];
+		    }
 		    // \brief The setter function of the map.
 		    //
 		    // It the same as operator[](key) = value expression.
 		    void set(const Key& key, const Value& value) {
 		      (*this)[key] = value;
+		    }
 		  protected:
 		    // \brief Adds a new key to the map.
 		    //
 		    // It adds a new key to the map. It is called by the observer notifier
 		    // and it overrides the add() member function of the observer base.
 		    virtual void add(const Key& key) {
 		      int id = Parent::notifier()->id(key);
 		      if (id >= int(container.size())) {
 		        container.resize(id + 1);
+		      }
+		    }
 		    // \brief Adds more new keys to the map.
 		    //
 		    // It adds more new keys to the map. It is called by the observer notifier
 		    // and it overrides the add() member function of the observer base.
 		    virtual void add(const std::vector<Key>& keys) {
 		      int max = container.size() - 1;
 		      for (int i = 0; i < int(keys.size()); ++i) {
 		        int id = Parent::notifier()->id(keys[i]);
 		        if (id >= max) {
 		          max = id;
+		        }
+		      }
 		      container.resize(max + 1);
+		    }
 		    // \brief Erase a key from the map.
 		    //
 		    // Erase a key from the map. It is called by the observer notifier
 		    // and it overrides the erase() member function of the observer base.
 		    virtual void erase(const Key& key) {
 		      container[Parent::notifier()->id(key)] = Value();
+		    }
 		    // \brief Erase more keys from the map.
 		    //
 		    // It erases more keys from the map. It is called by the observer notifier
 		    // and it overrides the erase() member function of the observer base.
 		    virtual void erase(const std::vector<Key>& keys) {
 		      for (int i = 0; i < int(keys.size()); ++i) {
 		        container[Parent::notifier()->id(keys[i])] = Value();
+		      }
+		    }
 		    // \brief Build the map.
 		    //
 		    // It builds the map. It is called by the observer notifier
 		    // and it overrides the build() member function of the observer base.
 		    virtual void build() {
 		      int size = Parent::notifier()->maxId() + 1;
 		      container.reserve(size);
 		      container.resize(size);
+		    }
 		    // \brief Clear the map.
 		    //
 		    // It erases all items from the map. It is called by the observer notifier
 		    // and it overrides the clear() member function of the observer base.
 		    virtual void clear() {
 		      container.clear();
+		    }
 		  private:
 		    Container container;
 		  };
+		}
 		#endif

lemon/concepts/graph_components.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2009
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		///\ingroup graph_concepts
 		///\file
 		///\brief The concept of graph components.
 		#ifndef LEMON_CONCEPTS_GRAPH_COMPONENTS_H
 		#define LEMON_CONCEPTS_GRAPH_COMPONENTS_H
 		#include <lemon/core.h>
 		#include <lemon/concepts/maps.h>
 		#include <lemon/bits/alteration_notifier.h>
 		namespace lemon {
 		  namespace concepts {
 		    /// \brief Concept class for \c Node, \c Arc and \c Edge types.
 		    ///
 		    /// This class describes the concept of \c Node, \c Arc and \c Edge
 		    /// subtypes of digraph and graph types.
 		    ///
 		    /// \note This class is a template class so that we can use it to
 		    /// create graph skeleton classes. The reason for this is that \c Node
 		    /// and \c Arc (or \c Edge) types should \e not derive from the same
 		    /// base class. For \c Node you should instantiate it with character
 		    /// \c 'n', for \c Arc with \c 'a' and for \c Edge with \c 'e'.
 		#ifndef DOXYGEN
 		    template <char sel = '0'>
 		#endif
 		    class GraphItem {
 		    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.
 		      GraphItem() {}
 		      /// \brief Copy constructor.
 		      ///
 		      /// Copy constructor.
 		      GraphItem(const GraphItem &) {}
 		      /// \brief Constructor for conversion from \c INVALID.
 		      ///
 		      /// Constructor for conversion from \c INVALID.
 		      /// It initializes the item to be invalid.
 		      /// \sa Invalid for more details.
 		      GraphItem(Invalid) {}
 		      /// \brief Assignment operator.
 		      ///
 		      /// Assignment operator for the item.
 		      GraphItem& operator=(const GraphItem&) { return *this; }
 		      /// \brief Equality operator.
 		      ///
 		      /// Equality operator.
 		      bool operator==(const GraphItem&) const { return false; }
 		      /// \brief Inequality operator.
 		      ///
 		      /// Inequality operator.
 		      bool operator!=(const GraphItem&) const { return false; }
 		      /// \brief Ordering operator.
 		      ///
 		      /// This operator defines an ordering of the items.
 		      /// It makes possible to use graph item types as key types in
 		      /// associative containers (e.g. \c std::map).
 		      ///
 		      /// \note This operator only have to define some strict ordering of
 		      /// the items; this order has nothing to do with the iteration
 		      /// ordering of the items.
 		      bool operator<(const GraphItem&) const { return false; }
 		      template<typename _GraphItem>
 		      struct Constraints {
 		        void constraints() {
 		          _GraphItem i1;
 		          _GraphItem i2 = i1;
 		          _GraphItem i3 = INVALID;
 		          i1 = i2 = i3;
 		          bool b;
 		          b = (ia == ib) && (ia != ib);
 		          b = (ia == INVALID) && (ib != INVALID);
 		          b = (ia < ib);
+		        }
 		        const _GraphItem &ia;
 		        const _GraphItem &ib;
 		      };
 		    };
 		    /// \brief Base skeleton class for directed graphs.
 		    ///
 		    /// This class describes the base interface of directed graph types.
 		    /// All digraph %concepts have to conform to this class.
 		    /// It just provides types for nodes and arcs and functions
 		    /// to get the source and the target nodes of arcs.
 		    class BaseDigraphComponent {
 		    public:
 		      typedef BaseDigraphComponent Digraph;
 		      /// \brief Node class of the digraph.
 		      ///
 		      /// This class represents the nodes of the digraph.
 		      typedef GraphItem<'n'> Node;
 		      /// \brief Arc class of the digraph.
 		      ///
 		      /// This class represents the arcs of the digraph.
 		      typedef GraphItem<'a'> Arc;
 		      /// \brief Return the source node of an arc.
 		      ///
 		      /// This function returns the source node of an arc.
 		      Node source(const Arc&) const { return INVALID; }
 		      /// \brief Return the target node of an arc.
 		      ///
 		      /// This function returns the target node of an arc.
 		      Node target(const Arc&) const { return INVALID; }
 		      /// \brief Return the opposite node on the given arc.
 		      ///
 		      /// This function returns the opposite node on the given arc.
 		      Node oppositeNode(const Node&, const Arc&) const {
 		        return INVALID;
+		      }
 		      template <typename _Digraph>
 		      struct Constraints {
 		        typedef typename _Digraph::Node Node;
 		        typedef typename _Digraph::Arc Arc;
 		        void constraints() {
 		          checkConcept<GraphItem<'n'>, Node>();
 		          checkConcept<GraphItem<'a'>, Arc>();
+		          {
 		            Node n;
 		            Arc e(INVALID);
 		            n = digraph.source(e);
 		            n = digraph.target(e);
 		            n = digraph.oppositeNode(n, e);
+		          }
+		        }
 		        const _Digraph& digraph;
 		      };
 		    };
 		    /// \brief Base skeleton class for undirected graphs.
 		    ///
 		    /// This class describes the base interface of undirected graph types.
 		    /// 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.
 		        Edge() {}
 		        /// \brief Copy constructor.
 		        ///
 		        /// Copy constructor.
 		        Edge(const Edge &) : Parent() {}
 		        /// \brief Constructor for conversion from \c INVALID.
 		        ///
 		        /// Constructor for conversion from \c INVALID.
 		        /// It initializes the item to be invalid.
 		        /// \sa Invalid for more details.
 		        Edge(Invalid) {}
 		        /// \brief Constructor for conversion from an arc.
 		        ///
 		        /// Constructor for conversion from an arc.
 		        /// Besides the core graph item functionality each arc should
 		        /// be convertible to the represented edge.
 		        Edge(const Arc&) {}
 		        /// \brief Assign an arc to an edge.
 		        ///
 		        /// This function assigns an arc to an edge.
 		        /// Besides the core graph item functionality each arc should
 		        /// be convertible to the represented edge.
 		        Edge& operator=(const Arc&) { return *this; }
 		      };
 		      /// \brief Return one end node of an edge.
 		      ///
 		      /// This function returns one end node of an edge.
 		      Node u(const Edge&) const { return INVALID; }
 		      /// \brief Return the other end node of an edge.
 		      ///
 		      /// This function returns the other end node of an edge.
 		      Node v(const Edge&) const { return INVALID; }
 		      /// \brief Return a directed arc related to an edge.
 		      ///
 		      /// This function returns a directed arc from its direction and the
 		      /// represented edge.
 		      Arc direct(const Edge&, bool) const { return INVALID; }
 		      /// \brief Return a directed arc related to an edge.
 		      ///
 		      /// This function returns a directed arc from its source node and the
 		      /// represented edge.
 		      Arc direct(const Edge&, const Node&) const { return INVALID; }
 		      /// \brief Return the direction of the arc.
 		      ///
 		      /// Returns the direction of the arc. Each arc represents an
 		      /// edge with a direction. It gives back the
 		      /// direction.
 		      bool direction(const Arc&) const { return true; }
 		      /// \brief Return the opposite arc.
 		      ///
 		      /// This function returns the opposite arc, i.e. the arc representing
 		      /// the same edge and has opposite direction.
 		      Arc oppositeArc(const Arc&) const { return INVALID; }
 		      template <typename _Graph>
 		      struct Constraints {
 		        typedef typename _Graph::Node Node;
 		        typedef typename _Graph::Arc Arc;
 		        typedef typename _Graph::Edge Edge;
 		        void constraints() {
 		          checkConcept<BaseDigraphComponent, _Graph>();
 		          checkConcept<GraphItem<'e'>, Edge>();
+		          {
 		            Node n;
 		            Edge ue(INVALID);
 		            Arc e;
 		            n = graph.u(ue);
 		            n = graph.v(ue);
 		            e = graph.direct(ue, true);
 		            e = graph.direct(ue, false);
 		            e = graph.direct(ue, n);
 		            e = graph.oppositeArc(e);
 		            ue = e;
 		            bool d = graph.direction(e);
 		            ignore_unused_variable_warning(d);
+		          }
+		        }
 		        const _Graph& graph;
 		      };
 		    };
 		    /// \brief Skeleton class for \e idable directed graphs.
 		    ///
 		    /// This class describes the interface of \e idable directed graphs.
 		    /// It extends \ref BaseDigraphComponent with the core ID functions.
 		    /// The ids of the items must be unique and immutable.
 		    /// This concept is part of the Digraph concept.
 		    template <typename BAS = BaseDigraphComponent>
 		    class IDableDigraphComponent : public BAS {
 		    public:
 		      typedef BAS Base;
 		      typedef typename Base::Node Node;
 		      typedef typename Base::Arc Arc;
 		      /// \brief Return a unique integer id for the given node.
 		      ///
 		      /// This function returns a unique integer id for the given node.
 		      int id(const Node&) const { return -1; }
 		      /// \brief Return the node by its unique id.
 		      ///
 		      /// This function returns the node by its unique id.
 		      /// If the digraph does not contain a node with the given id,
 		      /// then the result of the function is undefined.
 		      Node nodeFromId(int) const { return INVALID; }
 		      /// \brief Return a unique integer id for the given arc.
 		      ///
 		      /// This function returns a unique integer id for the given arc.
 		      int id(const Arc&) const { return -1; }
 		      /// \brief Return the arc by its unique id.
 		      ///
 		      /// This function returns the arc by its unique id.
 		      /// If the digraph does not contain an arc with the given id,
 		      /// then the result of the function is undefined.
 		      Arc arcFromId(int) const { return INVALID; }
 		      /// \brief Return an integer greater or equal to the maximum
 		      /// node id.
 		      ///
 		      /// This function returns an integer greater or equal to the
 		      /// maximum node id.
 		      int maxNodeId() const { return -1; }
 		      /// \brief Return an integer greater or equal to the maximum
 		      /// arc id.
 		      ///
 		      /// This function returns an integer greater or equal to the
 		      /// maximum arc id.
 		      int maxArcId() const { return -1; }
 		      template <typename _Digraph>
 		      struct Constraints {
 		        void constraints() {
 		          checkConcept<Base, _Digraph >();
 		          typename _Digraph::Node node;
 		          int nid = digraph.id(node);
 		          nid = digraph.id(node);
 		          node = digraph.nodeFromId(nid);
 		          typename _Digraph::Arc arc;
 		          int eid = digraph.id(arc);
 		          eid = digraph.id(arc);
 		          arc = digraph.arcFromId(eid);
 		          nid = digraph.maxNodeId();
 		          ignore_unused_variable_warning(nid);
 		          eid = digraph.maxArcId();
 		          ignore_unused_variable_warning(eid);
+		        }
 		        const _Digraph& digraph;
 		      };
 		    };
 		    /// \brief Skeleton class for \e idable undirected graphs.
 		    ///
 		    /// This class describes the interface of \e idable undirected
 		    /// graphs. It extends \ref IDableDigraphComponent with the core ID
 		    /// functions of undirected graphs.
 		    /// The ids of the items must be unique and immutable.
 		    /// This concept is part of the Graph concept.
 		    template <typename BAS = BaseGraphComponent>
 		    class IDableGraphComponent : public IDableDigraphComponent<BAS> {
 		    public:
 		      typedef BAS Base;
 		      typedef typename Base::Edge Edge;
 		      using IDableDigraphComponent<Base>::id;
 		      /// \brief Return a unique integer id for the given edge.
 		      ///
 		      /// This function returns a unique integer id for the given edge.
 		      int id(const Edge&) const { return -1; }
 		      /// \brief Return the edge by its unique id.
 		      ///
 		      /// This function returns the edge by its unique id.
 		      /// If the graph does not contain an edge with the given id,
 		      /// then the result of the function is undefined.
 		      Edge edgeFromId(int) const { return INVALID; }
 		      /// \brief Return an integer greater or equal to the maximum
 		      /// edge id.
 		      ///
 		      /// This function returns an integer greater or equal to the
 		      /// maximum edge id.
 		      int maxEdgeId() const { return -1; }
 		      template <typename _Graph>
 		      struct Constraints {
 		        void constraints() {
 		          checkConcept<IDableDigraphComponent<Base>, _Graph >();
 		          typename _Graph::Edge edge;
 		          int ueid = graph.id(edge);
 		          ueid = graph.id(edge);
 		          edge = graph.edgeFromId(ueid);
 		          ueid = graph.maxEdgeId();
 		          ignore_unused_variable_warning(ueid);
+		        }
 		        const _Graph& graph;
 		      };
 		    };
 		    /// \brief Concept class for \c NodeIt, \c ArcIt and \c EdgeIt types.
 		    ///
 		    /// This class describes the concept of \c NodeIt, \c ArcIt and
 		    /// \c EdgeIt subtypes of digraph and graph types.
 		    template <typename GR, typename Item>
 		    class GraphItemIt : public Item {
 		    public:
 		      /// \brief Default constructor.
 		      ///
 		      /// Default constructor.
 		      /// \warning The default constructor is not required to set
 		      /// the iterator to some well-defined value. So you should consider it
 		      /// as uninitialized.
 		      GraphItemIt() {}
 		      /// \brief Copy constructor.
 		      ///
 		      /// Copy constructor.
 		      GraphItemIt(const GraphItemIt& it) : Item(it) {}
 		      /// \brief Constructor that sets the iterator to the first item.
 		      ///
 		      /// Constructor that sets the iterator to the first item.
 		      explicit GraphItemIt(const GR&) {}
 		      /// \brief Constructor for conversion from \c INVALID.
 		      ///
 		      /// Constructor for conversion from \c INVALID.
@@ -738,745 +741,743 @@
+		          {
 		            checkConcept<GraphItemIt<_Digraph, typename _Digraph::Arc>,
 		              typename _Digraph::ArcIt >();
 		            checkConcept<GraphItemIt<_Digraph, typename _Digraph::Node>,
 		              typename _Digraph::NodeIt >();
 		            checkConcept<GraphIncIt<_Digraph, typename _Digraph::Arc,
 		              typename _Digraph::Node, 'i'>, typename _Digraph::InArcIt>();
 		            checkConcept<GraphIncIt<_Digraph, typename _Digraph::Arc,
 		              typename _Digraph::Node, 'o'>, typename _Digraph::OutArcIt>();
 		            typename _Digraph::Node n;
 		            const typename _Digraph::InArcIt iait(INVALID);
 		            const typename _Digraph::OutArcIt oait(INVALID);
 		            n = digraph.baseNode(iait);
 		            n = digraph.runningNode(iait);
 		            n = digraph.baseNode(oait);
 		            n = digraph.runningNode(oait);
 		            ignore_unused_variable_warning(n);
+		          }
+		        }
 		        const _Digraph& digraph;
 		      };
 		    };
 		    /// \brief Skeleton class for iterable undirected graphs.
 		    ///
 		    /// This class describes the interface of iterable undirected
 		    /// graphs. It extends \ref IterableDigraphComponent with the core
 		    /// iterable interface of undirected graphs.
 		    /// This concept is part of the Graph concept.
 		    template <typename BAS = BaseGraphComponent>
 		    class IterableGraphComponent : public IterableDigraphComponent<BAS> {
 		    public:
 		      typedef BAS Base;
 		      typedef typename Base::Node Node;
 		      typedef typename Base::Arc Arc;
 		      typedef typename Base::Edge Edge;
 		      typedef IterableGraphComponent Graph;
 		      /// \name Base Iteration
 		      ///
 		      /// This interface provides functions for iteration on edges.
 		      ///
 		      /// @{
 		      using IterableDigraphComponent<Base>::first;
 		      using IterableDigraphComponent<Base>::next;
 		      /// \brief Return the first edge.
 		      ///
 		      /// This function gives back the first edge in the iteration order.
 		      void first(Edge&) const {}
 		      /// \brief Return the next edge.
 		      ///
 		      /// This function gives back the next edge in the iteration order.
 		      void next(Edge&) const {}
 		      /// \brief Return the first edge incident to the given node.
 		      ///
 		      /// This function gives back the first edge incident to the given
 		      /// node. The bool parameter gives back the direction for which the
 		      /// source node of the directed arc representing the edge is the
 		      /// given node.
 		      void firstInc(Edge&, bool&, const Node&) const {}
 		      /// \brief Gives back the next of the edges from the
 		      /// given node.
 		      ///
 		      /// This function gives back the next edge incident to the given
 		      /// node. The bool parameter should be used as \c firstInc() use it.
 		      void nextInc(Edge&, bool&) const {}
 		      using IterableDigraphComponent<Base>::baseNode;
 		      using IterableDigraphComponent<Base>::runningNode;
 		      /// @}
 		      /// \name Class Based Iteration
 		      ///
 		      /// This interface provides iterator classes for edges.
 		      ///
 		      /// @{
 		      /// \brief This iterator goes through each edge.
 		      ///
 		      /// This iterator goes through each edge.
 		      typedef GraphItemIt<Graph, Edge> EdgeIt;
 		      /// \brief This iterator goes trough the incident edges of a
 		      /// node.
 		      ///
 		      /// This iterator goes trough the incident edges of a certain
 		      /// node of a graph.
 		      typedef GraphIncIt<Graph, Edge, Node, 'e'> IncEdgeIt;
 		      /// \brief The base node of the iterator.
 		      ///
 		      /// This function gives back the base node of the iterator.
 		      Node baseNode(const IncEdgeIt&) const { return INVALID; }
 		      /// \brief The running node of the iterator.
 		      ///
 		      /// This function gives back the running node of the iterator.
 		      Node runningNode(const IncEdgeIt&) const { return INVALID; }
 		      /// @}
 		      template <typename _Graph>
 		      struct Constraints {
 		        void constraints() {
 		          checkConcept<IterableDigraphComponent<Base>, _Graph>();
+		          {
 		            typename _Graph::Node node(INVALID);
 		            typename _Graph::Edge edge(INVALID);
 		            bool dir;
+		            {
 		              graph.first(edge);
 		              graph.next(edge);
+		            }
+		            {
 		              graph.firstInc(edge, dir, node);
 		              graph.nextInc(edge, dir);
+		            }
+		          }
+		          {
 		            checkConcept<GraphItemIt<_Graph, typename _Graph::Edge>,
 		              typename _Graph::EdgeIt >();
 		            checkConcept<GraphIncIt<_Graph, typename _Graph::Edge,
 		              typename _Graph::Node, 'e'>, typename _Graph::IncEdgeIt>();
 		            typename _Graph::Node n;
 		            const typename _Graph::IncEdgeIt ieit(INVALID);
 		            n = graph.baseNode(ieit);
 		            n = graph.runningNode(ieit);
+		          }
+		        }
 		        const _Graph& graph;
 		      };
 		    };
 		    /// \brief Skeleton class for alterable directed graphs.
 		    ///
 		    /// This class describes the interface of alterable directed
 		    /// graphs. It extends \ref BaseDigraphComponent with the alteration
 		    /// notifier interface. It implements
 		    /// an observer-notifier pattern for each digraph item. More
 		    /// obsevers can be registered into the notifier and whenever an
 		    /// alteration occured in the digraph all the observers will be
 		    /// notified about it.
 		    template <typename BAS = BaseDigraphComponent>
 		    class AlterableDigraphComponent : public BAS {
 		    public:
 		      typedef BAS Base;
 		      typedef typename Base::Node Node;
 		      typedef typename Base::Arc Arc;
 		      /// Node alteration notifier class.
 		      typedef AlterationNotifier<AlterableDigraphComponent, Node>
 		      NodeNotifier;
 		      /// Arc alteration notifier class.
 		      typedef AlterationNotifier<AlterableDigraphComponent, Arc>
 		      ArcNotifier;
 		      /// \brief Return the node alteration notifier.
 		      ///
 		      /// This function gives back the node alteration notifier.
 		      NodeNotifier& notifier(Node) const {
 		         return NodeNotifier();
+		      }
 		      /// \brief Return the arc alteration notifier.
 		      ///
 		      /// This function gives back the arc alteration notifier.
 		      ArcNotifier& notifier(Arc) const {
 		        return ArcNotifier();
+		      }
 		      template <typename _Digraph>
 		      struct Constraints {
 		        void constraints() {
 		          checkConcept<Base, _Digraph>();
 		          typename _Digraph::NodeNotifier& nn
 		            = digraph.notifier(typename _Digraph::Node());
 		          typename _Digraph::ArcNotifier& en
 		            = digraph.notifier(typename _Digraph::Arc());
 		          ignore_unused_variable_warning(nn);
 		          ignore_unused_variable_warning(en);
+		        }
 		        const _Digraph& digraph;
 		      };
 		    };
 		    /// \brief Skeleton class for alterable undirected graphs.
 		    ///
 		    /// This class describes the interface of alterable undirected
 		    /// graphs. It extends \ref AlterableDigraphComponent with the alteration
 		    /// notifier interface of undirected graphs. It implements
 		    /// an observer-notifier pattern for the edges. More
 		    /// obsevers can be registered into the notifier and whenever an
 		    /// alteration occured in the graph all the observers will be
 		    /// notified about it.
 		    template <typename BAS = BaseGraphComponent>
 		    class AlterableGraphComponent : public AlterableDigraphComponent<BAS> {
 		    public:
 		      typedef BAS Base;
 		      typedef typename Base::Edge Edge;
 		      /// Edge alteration notifier class.
 		      typedef AlterationNotifier<AlterableGraphComponent, Edge>
 		      EdgeNotifier;
 		      /// \brief Return the edge alteration notifier.
 		      ///
 		      /// This function gives back the edge alteration notifier.
 		      EdgeNotifier& notifier(Edge) const {
 		        return EdgeNotifier();
+		      }
 		      template <typename _Graph>
 		      struct Constraints {
 		        void constraints() {
 		          checkConcept<AlterableDigraphComponent<Base>, _Graph>();
 		          typename _Graph::EdgeNotifier& uen
 		            = graph.notifier(typename _Graph::Edge());
 		          ignore_unused_variable_warning(uen);
+		        }
 		        const _Graph& graph;
 		      };
 		    };
 		    /// \brief Concept class for standard graph maps.
 		    ///
 		    /// 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;
 		      /// The const reference type of the map.
 		      typedef const Value& ConstReference;
 		      // 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() {}
 		      /// \brief Assignment operator.
 		      ///
 		      /// Assignment operator. It does not mofify the underlying graph,
 		      /// it just iterates on the current item set and set the  map
 		      /// with the value returned by the assigned map.
 		      template <typename CMap>
 		      GraphMap& operator=(const CMap&) {
 		        checkConcept<ReadMap<Key, Value>, CMap>();
 		        return *this;
+		      }
 		    public:
 		      template<typename _Map>
 		      struct Constraints {
 		        void constraints() {
 		          checkConcept
 		            <ReferenceMap<Key, Value, Value&, const Value&>, _Map>();
 		          _Map m1(g);
 		          _Map m2(g,t);
 		          // Copy constructor
 		          // _Map m3(m);
 		          // Assignment operator
 		          // ReadMap<Key, Value> cmap;
 		          // m3 = cmap;
 		          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.
 		    ///
 		    /// This class describes the interface of mappable directed graphs.
 		    /// It extends \ref BaseDigraphComponent with the standard digraph
 		    /// map classes, namely \c NodeMap and \c ArcMap.
 		    /// This concept is part of the Digraph concept.
 		    template <typename BAS = BaseDigraphComponent>
 		    class MappableDigraphComponent : public BAS  {
 		    public:
 		      typedef BAS Base;
 		      typedef typename Base::Node Node;
 		      typedef typename Base::Arc Arc;
 		      typedef MappableDigraphComponent Digraph;
 		      /// \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) {}
 		        /// \brief Construct a new map with default value.
 		        ///
 		        /// Construct a new map for the digraph and initalize the values.
 		        NodeMap(const MappableDigraphComponent& digraph, const V& value)
 		          : Parent(digraph, value) {}
 		      private:
 		        /// \brief Copy constructor.
 		        ///
 		        /// Copy Constructor.
 		        NodeMap(const NodeMap& nm) : Parent(nm) {}
 		        /// \brief Assignment operator.
 		        ///
 		        /// Assignment operator.
 		        template <typename CMap>
 		        NodeMap& operator=(const CMap&) {
 		          checkConcept<ReadMap<Node, V>, CMap>();
 		          return *this;
+		        }
 		      };
 		      /// \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) {}
 		        /// \brief Construct a new map with default value.
 		        ///
 		        /// Construct a new map for the digraph and initalize the values.
 		        ArcMap(const MappableDigraphComponent& digraph, const V& value)
 		          : Parent(digraph, value) {}
 		      private:
 		        /// \brief Copy constructor.
 		        ///
 		        /// Copy Constructor.
 		        ArcMap(const ArcMap& nm) : Parent(nm) {}
 		        /// \brief Assignment operator.
 		        ///
 		        /// Assignment operator.
 		        template <typename CMap>
 		        ArcMap& operator=(const CMap&) {
 		          checkConcept<ReadMap<Arc, V>, CMap>();
 		          return *this;
+		        }
 		      };
 		      template <typename _Digraph>
 		      struct Constraints {
 		        struct Dummy {
 		          int value;
 		          Dummy() : value(0) {}
 		          Dummy(int _v) : value(_v) {}
 		        };
 		        void constraints() {
 		          checkConcept<Base, _Digraph>();
 		          { // int map test
 		            typedef typename _Digraph::template NodeMap<int> IntNodeMap;
 		            checkConcept<GraphMap<_Digraph, typename _Digraph::Node, int>,
 		              IntNodeMap >();
 		          } { // bool map test
 		            typedef typename _Digraph::template NodeMap<bool> BoolNodeMap;
 		            checkConcept<GraphMap<_Digraph, typename _Digraph::Node, bool>,
 		              BoolNodeMap >();
 		          } { // Dummy map test
 		            typedef typename _Digraph::template NodeMap<Dummy> DummyNodeMap;
 		            checkConcept<GraphMap<_Digraph, typename _Digraph::Node, Dummy>,
 		              DummyNodeMap >();
+		          }
 		          { // int map test
 		            typedef typename _Digraph::template ArcMap<int> IntArcMap;
 		            checkConcept<GraphMap<_Digraph, typename _Digraph::Arc, int>,
 		              IntArcMap >();
 		          } { // bool map test
 		            typedef typename _Digraph::template ArcMap<bool> BoolArcMap;
 		            checkConcept<GraphMap<_Digraph, typename _Digraph::Arc, bool>,
 		              BoolArcMap >();
 		          } { // Dummy map test
 		            typedef typename _Digraph::template ArcMap<Dummy> DummyArcMap;
 		            checkConcept<GraphMap<_Digraph, typename _Digraph::Arc, Dummy>,
 		              DummyArcMap >();
+		          }
+		        }
 		        const _Digraph& digraph;
 		      };
 		    };
 		    /// \brief Skeleton class for mappable undirected graphs.
 		    ///
 		    /// This class describes the interface of mappable undirected graphs.
 		    /// It extends \ref MappableDigraphComponent with the standard graph
 		    /// map class for edges (\c EdgeMap).
 		    /// This concept is part of the Graph concept.
 		    template <typename BAS = BaseGraphComponent>
 		    class MappableGraphComponent : public MappableDigraphComponent<BAS>  {
 		    public:
 		      typedef BAS Base;
 		      typedef typename Base::Edge Edge;
 		      typedef MappableGraphComponent Graph;
 		      /// \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) {}
 		        /// \brief Construct a new map with default value.
 		        ///
 		        /// Construct a new map for the graph and initalize the values.
 		        EdgeMap(const MappableGraphComponent& graph, const V& value)
 		          : Parent(graph, value) {}
 		      private:
 		        /// \brief Copy constructor.
 		        ///
 		        /// Copy Constructor.
 		        EdgeMap(const EdgeMap& nm) : Parent(nm) {}
 		        /// \brief Assignment operator.
 		        ///
 		        /// Assignment operator.
 		        template <typename CMap>
 		        EdgeMap& operator=(const CMap&) {
 		          checkConcept<ReadMap<Edge, V>, CMap>();
 		          return *this;
+		        }
 		      };
 		      template <typename _Graph>
 		      struct Constraints {
 		        struct Dummy {
 		          int value;
 		          Dummy() : value(0) {}
 		          Dummy(int _v) : value(_v) {}
 		        };
 		        void constraints() {
 		          checkConcept<MappableDigraphComponent<Base>, _Graph>();
 		          { // int map test
 		            typedef typename _Graph::template EdgeMap<int> IntEdgeMap;
 		            checkConcept<GraphMap<_Graph, typename _Graph::Edge, int>,
 		              IntEdgeMap >();
 		          } { // bool map test
 		            typedef typename _Graph::template EdgeMap<bool> BoolEdgeMap;
 		            checkConcept<GraphMap<_Graph, typename _Graph::Edge, bool>,
 		              BoolEdgeMap >();
 		          } { // Dummy map test
 		            typedef typename _Graph::template EdgeMap<Dummy> DummyEdgeMap;
 		            checkConcept<GraphMap<_Graph, typename _Graph::Edge, Dummy>,
 		              DummyEdgeMap >();
+		          }
+		        }
 		        const _Graph& graph;
 		      };
 		    };
 		    /// \brief Skeleton class for extendable directed graphs.
 		    ///
 		    /// This class describes the interface of extendable directed graphs.
 		    /// It extends \ref BaseDigraphComponent with functions for adding
 		    /// nodes and arcs to the digraph.
 		    /// This concept requires \ref AlterableDigraphComponent.
 		    template <typename BAS = BaseDigraphComponent>
 		    class ExtendableDigraphComponent : public BAS {
 		    public:
 		      typedef BAS Base;
 		      typedef typename Base::Node Node;
 		      typedef typename Base::Arc Arc;
 		      /// \brief Add a new node to the digraph.
 		      ///
 		      /// This function adds a new node to the digraph.
 		      Node addNode() {
 		        return INVALID;
+		      }
 		      /// \brief Add a new arc connecting the given two nodes.
 		      ///
 		      /// This function adds a new arc connecting the given two nodes
 		      /// of the digraph.
 		      Arc addArc(const Node&, const Node&) {
 		        return INVALID;
+		      }
 		      template <typename _Digraph>
 		      struct Constraints {
 		        void constraints() {
 		          checkConcept<Base, _Digraph>();
 		          typename _Digraph::Node node_a, node_b;
 		          node_a = digraph.addNode();
 		          node_b = digraph.addNode();
 		          typename _Digraph::Arc arc;
 		          arc = digraph.addArc(node_a, node_b);
+		        }
 		        _Digraph& digraph;
 		      };
 		    };
 		    /// \brief Skeleton class for extendable undirected graphs.
 		    ///
 		    /// This class describes the interface of extendable undirected graphs.
 		    /// It extends \ref BaseGraphComponent with functions for adding
 		    /// nodes and edges to the graph.
 		    /// This concept requires \ref AlterableGraphComponent.
 		    template <typename BAS = BaseGraphComponent>
 		    class ExtendableGraphComponent : public BAS {
 		    public:
 		      typedef BAS Base;
 		      typedef typename Base::Node Node;
 		      typedef typename Base::Edge Edge;
 		      /// \brief Add a new node to the digraph.
 		      ///
 		      /// This function adds a new node to the digraph.
 		      Node addNode() {
 		        return INVALID;
+		      }
 		      /// \brief Add a new edge connecting the given two nodes.
 		      ///
 		      /// This function adds a new edge connecting the given two nodes
 		      /// of the graph.
 		      Edge addEdge(const Node&, const Node&) {
 		        return INVALID;
+		      }
 		      template <typename _Graph>
 		      struct Constraints {
 		        void constraints() {
 		          checkConcept<Base, _Graph>();
 		          typename _Graph::Node node_a, node_b;
 		          node_a = graph.addNode();
 		          node_b = graph.addNode();
 		          typename _Graph::Edge edge;
 		          edge = graph.addEdge(node_a, node_b);
+		        }
 		        _Graph& graph;
 		      };
 		    };
 		    /// \brief Skeleton class for erasable directed graphs.
 		    ///
 		    /// This class describes the interface of erasable directed graphs.
 		    /// It extends \ref BaseDigraphComponent with functions for removing
 		    /// nodes and arcs from the digraph.
 		    /// This concept requires \ref AlterableDigraphComponent.
 		    template <typename BAS = BaseDigraphComponent>
 		    class ErasableDigraphComponent : public BAS {
 		    public:
 		      typedef BAS Base;
 		      typedef typename Base::Node Node;
 		      typedef typename Base::Arc Arc;
 		      /// \brief Erase a node from the digraph.
 		      ///
 		      /// This function erases the given node from the digraph and all arcs
 		      /// connected to the node.
 		      void erase(const Node&) {}
 		      /// \brief Erase an arc from the digraph.
 		      ///
 		      /// This function erases the given arc from the digraph.
 		      void erase(const Arc&) {}
 		      template <typename _Digraph>
 		      struct Constraints {
 		        void constraints() {
 		          checkConcept<Base, _Digraph>();
 		          const typename _Digraph::Node node(INVALID);
 		          digraph.erase(node);
 		          const typename _Digraph::Arc arc(INVALID);
 		          digraph.erase(arc);
+		        }
 		        _Digraph& digraph;
 		      };
 		    };
 		    /// \brief Skeleton class for erasable undirected graphs.
 		    ///
 		    /// This class describes the interface of erasable undirected graphs.
 		    /// It extends \ref BaseGraphComponent with functions for removing
 		    /// nodes and edges from the graph.
 		    /// This concept requires \ref AlterableGraphComponent.
 		    template <typename BAS = BaseGraphComponent>
 		    class ErasableGraphComponent : public BAS {
 		    public:
 		      typedef BAS Base;
 		      typedef typename Base::Node Node;
 		      typedef typename Base::Edge Edge;
 		      /// \brief Erase a node from the graph.
 		      ///
 		      /// This function erases the given node from the graph and all edges
 		      /// connected to the node.
 		      void erase(const Node&) {}
 		      /// \brief Erase an edge from the digraph.
 		      ///
 		      /// This function erases the given edge from the digraph.
 		      void erase(const Edge&) {}
 		      template <typename _Graph>
 		      struct Constraints {
 		        void constraints() {
 		          checkConcept<Base, _Graph>();
 		          const typename _Graph::Node node(INVALID);
 		          graph.erase(node);
 		          const typename _Graph::Edge edge(INVALID);
 		          graph.erase(edge);
+		        }
 		        _Graph& graph;
 		      };
 		    };
 		    /// \brief Skeleton class for clearable directed graphs.
 		    ///
 		    /// This class describes the interface of clearable directed graphs.
 		    /// It extends \ref BaseDigraphComponent with a function for clearing
 		    /// the digraph.
 		    /// This concept requires \ref AlterableDigraphComponent.
 		    template <typename BAS = BaseDigraphComponent>
 		    class ClearableDigraphComponent : public BAS {
 		    public:
 		      typedef BAS Base;
 		      /// \brief Erase all nodes and arcs from the digraph.
 		      ///
 		      /// This function erases all nodes and arcs from the digraph.
 		      void clear() {}
 		      template <typename _Digraph>
 		      struct Constraints {
 		        void constraints() {
 		          checkConcept<Base, _Digraph>();
 		          digraph.clear();
+		        }
 		        _Digraph& digraph;
 		      };
 		    };
 		    /// \brief Skeleton class for clearable undirected graphs.

lemon/core.h

Show inline comments

@@ -783,1064 +783,1073 @@
 		    /// \brief Make a copy of the given node map.
 		    ///
 		    /// This function makes a copy of the given node map for the newly
 		    /// created graph.
 		    /// The key type of the new map \c tmap should be the Node type of the
 		    /// destination graph, and the key type of the original map \c map
 		    /// should be the Node type of the source graph.
 		    template <typename FromMap, typename ToMap>
 		    GraphCopy& nodeMap(const FromMap& map, ToMap& tmap) {
 		      _node_maps.push_back(new _core_bits::MapCopy<From, Node,
 		                           NodeRefMap, FromMap, ToMap>(map, tmap));
 		      return *this;
+		    }
 		    /// \brief Make a copy of the given node.
 		    ///
 		    /// This function makes a copy of the given node.
 		    GraphCopy& node(const Node& node, TNode& tnode) {
 		      _node_maps.push_back(new _core_bits::ItemCopy<From, Node,
 		                           NodeRefMap, TNode>(node, tnode));
 		      return *this;
+		    }
 		    /// \brief Copy the arc references into the given map.
 		    ///
 		    /// This function copies the arc references into the given map.
 		    /// The parameter should be a map, whose key type is the Arc type of
 		    /// the source graph, while the value type is the Arc type of the
 		    /// destination graph.
 		    template <typename ArcRef>
 		    GraphCopy& arcRef(ArcRef& map) {
 		      _arc_maps.push_back(new _core_bits::RefCopy<From, Arc,
 		                          ArcRefMap, ArcRef>(map));
 		      return *this;
+		    }
 		    /// \brief Copy the arc cross references into the given map.
 		    ///
 		    /// This function copies the arc cross references (reverse references)
 		    /// into the given map. The parameter should be a map, whose key type
 		    /// is the Arc type of the destination graph, while the value type is
 		    /// the Arc type of the source graph.
 		    template <typename ArcCrossRef>
 		    GraphCopy& arcCrossRef(ArcCrossRef& map) {
 		      _arc_maps.push_back(new _core_bits::CrossRefCopy<From, Arc,
 		                          ArcRefMap, ArcCrossRef>(map));
 		      return *this;
+		    }
 		    /// \brief Make a copy of the given arc map.
 		    ///
 		    /// This function makes a copy of the given arc map for the newly
 		    /// created graph.
 		    /// The key type of the new map \c tmap should be the Arc type of the
 		    /// destination graph, and the key type of the original map \c map
 		    /// should be the Arc type of the source graph.
 		    template <typename FromMap, typename ToMap>
 		    GraphCopy& arcMap(const FromMap& map, ToMap& tmap) {
 		      _arc_maps.push_back(new _core_bits::MapCopy<From, Arc,
 		                          ArcRefMap, FromMap, ToMap>(map, tmap));
 		      return *this;
+		    }
 		    /// \brief Make a copy of the given arc.
 		    ///
 		    /// This function makes a copy of the given arc.
 		    GraphCopy& arc(const Arc& arc, TArc& tarc) {
 		      _arc_maps.push_back(new _core_bits::ItemCopy<From, Arc,
 		                          ArcRefMap, TArc>(arc, tarc));
 		      return *this;
+		    }
 		    /// \brief Copy the edge references into the given map.
 		    ///
 		    /// This function copies the edge references into the given map.
 		    /// The parameter should be a map, whose key type is the Edge type of
 		    /// the source graph, while the value type is the Edge type of the
 		    /// destination graph.
 		    template <typename EdgeRef>
 		    GraphCopy& edgeRef(EdgeRef& map) {
 		      _edge_maps.push_back(new _core_bits::RefCopy<From, Edge,
 		                           EdgeRefMap, EdgeRef>(map));
 		      return *this;
+		    }
 		    /// \brief Copy the edge cross references into the given map.
 		    ///
 		    /// This function copies the edge cross references (reverse references)
 		    /// into the given map. The parameter should be a map, whose key type
 		    /// is the Edge type of the destination graph, while the value type is
 		    /// the Edge type of the source graph.
 		    template <typename EdgeCrossRef>
 		    GraphCopy& edgeCrossRef(EdgeCrossRef& map) {
 		      _edge_maps.push_back(new _core_bits::CrossRefCopy<From,
 		                           Edge, EdgeRefMap, EdgeCrossRef>(map));
 		      return *this;
+		    }
 		    /// \brief Make a copy of the given edge map.
 		    ///
 		    /// This function makes a copy of the given edge map for the newly
 		    /// created graph.
 		    /// The key type of the new map \c tmap should be the Edge type of the
 		    /// destination graph, and the key type of the original map \c map
 		    /// should be the Edge type of the source graph.
 		    template <typename FromMap, typename ToMap>
 		    GraphCopy& edgeMap(const FromMap& map, ToMap& tmap) {
 		      _edge_maps.push_back(new _core_bits::MapCopy<From, Edge,
 		                           EdgeRefMap, FromMap, ToMap>(map, tmap));
 		      return *this;
+		    }
 		    /// \brief Make a copy of the given edge.
 		    ///
 		    /// This function makes a copy of the given edge.
 		    GraphCopy& edge(const Edge& edge, TEdge& tedge) {
 		      _edge_maps.push_back(new _core_bits::ItemCopy<From, Edge,
 		                           EdgeRefMap, TEdge>(edge, tedge));
 		      return *this;
+		    }
 		    /// \brief Execute copying.
 		    ///
 		    /// This function executes the copying of the graph along with the
 		    /// copying of the assigned data.
 		    void run() {
 		      NodeRefMap nodeRefMap(_from);
 		      EdgeRefMap edgeRefMap(_from);
 		      ArcRefMap arcRefMap(_from, _to, edgeRefMap, nodeRefMap);
 		      _core_bits::GraphCopySelector<To>::
 		        copy(_from, _to, nodeRefMap, edgeRefMap);
 		      for (int i = 0; i < int(_node_maps.size()); ++i) {
 		        _node_maps[i]->copy(_from, nodeRefMap);
+		      }
 		      for (int i = 0; i < int(_edge_maps.size()); ++i) {
 		        _edge_maps[i]->copy(_from, edgeRefMap);
+		      }
 		      for (int i = 0; i < int(_arc_maps.size()); ++i) {
 		        _arc_maps[i]->copy(_from, arcRefMap);
+		      }
+		    }
 		  private:
 		    const From& _from;
 		    To& _to;
 		    std::vector<_core_bits::MapCopyBase<From, Node, NodeRefMap>* >
 		      _node_maps;
 		    std::vector<_core_bits::MapCopyBase<From, Arc, ArcRefMap>* >
 		      _arc_maps;
 		    std::vector<_core_bits::MapCopyBase<From, Edge, EdgeRefMap>* >
 		      _edge_maps;
 		  };
 		  /// \brief Copy a graph to another graph.
 		  ///
 		  /// This function copies a graph to another graph.
 		  /// The complete usage of it is detailed in the GraphCopy class,
 		  /// but a short example shows a basic work:
 		  ///\code
 		  /// graphCopy(src, trg).nodeRef(nr).edgeCrossRef(ecr).run();
 		  ///\endcode
 		  ///
 		  /// After the copy the \c nr map will contain the mapping from the
 		  /// nodes of the \c from graph to the nodes of the \c to graph and
 		  /// \c ecr will contain the mapping from the edges of the \c to graph
 		  /// to the edges of the \c from graph.
 		  ///
 		  /// \see GraphCopy
 		  template <typename From, typename To>
 		  GraphCopy<From, To>
 		  graphCopy(const From& from, To& to) {
 		    return GraphCopy<From, To>(from, to);
+		  }
 		  namespace _core_bits {
 		    template <typename Graph, typename Enable = void>
 		    struct FindArcSelector {
 		      typedef typename Graph::Node Node;
 		      typedef typename Graph::Arc Arc;
 		      static Arc find(const Graph &g, Node u, Node v, Arc e) {
 		        if (e == INVALID) {
 		          g.firstOut(e, u);
 		        } else {
 		          g.nextOut(e);
+		        }
 		        while (e != INVALID && g.target(e) != v) {
 		          g.nextOut(e);
+		        }
 		        return e;
+		      }
 		    };
 		    template <typename Graph>
 		    struct FindArcSelector<
 		      Graph,
 		      typename enable_if<typename Graph::FindArcTag, void>::type>
+		    {
 		      typedef typename Graph::Node Node;
 		      typedef typename Graph::Arc Arc;
 		      static Arc find(const Graph &g, Node u, Node v, Arc prev) {
 		        return g.findArc(u, v, prev);
+		      }
 		    };
+		  }
 		  /// \brief Find an arc between two nodes of a digraph.
 		  ///
 		  /// This function finds an arc from node \c u to node \c v in the
 		  /// digraph \c g.
 		  ///
 		  /// If \c prev is \ref INVALID (this is the default value), then
 		  /// it finds the first arc from \c u to \c v. Otherwise it looks for
 		  /// the next arc from \c u to \c v after \c prev.
 		  /// \return The found arc or \ref INVALID if there is no such an arc.
 		  ///
 		  /// Thus you can iterate through each arc from \c u to \c v as it follows.
 		  ///\code
 		  /// for(Arc e = findArc(g,u,v); e != INVALID; e = findArc(g,u,v,e)) {
 		  ///   ...
 		  /// }
 		  ///\endcode
 		  ///
 		  /// \note \ref ConArcIt provides iterator interface for the same
 		  /// functionality.
 		  ///
 		  ///\sa ConArcIt
 		  ///\sa ArcLookUp, AllArcLookUp, DynArcLookUp
 		  template <typename Graph>
 		  inline typename Graph::Arc
 		  findArc(const Graph &g, typename Graph::Node u, typename Graph::Node v,
 		          typename Graph::Arc prev = INVALID) {
 		    return _core_bits::FindArcSelector<Graph>::find(g, u, v, prev);
+		  }
 		  /// \brief Iterator for iterating on parallel arcs connecting the same nodes.
 		  ///
 		  /// Iterator for iterating on parallel arcs connecting the same nodes. It is
 		  /// a higher level interface for the \ref findArc() function. You can
 		  /// use it the following way:
 		  ///\code
 		  /// for (ConArcIt<Graph> it(g, src, trg); it != INVALID; ++it) {
 		  ///   ...
 		  /// }
 		  ///\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 {
 		      typedef typename Graph::Node Node;
 		      typedef typename Graph::Edge Edge;
 		      static Edge find(const Graph &g, Node u, Node v, Edge e) {
 		        bool b;
 		        if (u != v) {
 		          if (e == INVALID) {
 		            g.firstInc(e, b, u);
 		          } else {
 		            b = g.u(e) == u;
 		            g.nextInc(e, b);
+		          }
 		          while (e != INVALID && (b ? g.v(e) : g.u(e)) != v) {
 		            g.nextInc(e, b);
+		          }
 		        } else {
 		          if (e == INVALID) {
 		            g.firstInc(e, b, u);
 		          } else {
 		            b = true;
 		            g.nextInc(e, b);
+		          }
 		          while (e != INVALID && (!b || g.v(e) != v)) {
 		            g.nextInc(e, b);
+		          }
+		        }
 		        return e;
+		      }
 		    };
 		    template <typename Graph>
 		    struct FindEdgeSelector<
 		      Graph,
 		      typename enable_if<typename Graph::FindEdgeTag, void>::type>
+		    {
 		      typedef typename Graph::Node Node;
 		      typedef typename Graph::Edge Edge;
 		      static Edge find(const Graph &g, Node u, Node v, Edge prev) {
 		        return g.findEdge(u, v, prev);
+		      }
 		    };
+		  }
 		  /// \brief Find an edge between two nodes of a graph.
 		  ///
 		  /// This function finds an edge from node \c u to node \c v in graph \c g.
 		  /// If node \c u and node \c v is equal then each loop edge
 		  /// will be enumerated once.
 		  ///
 		  /// If \c prev is \ref INVALID (this is the default value), then
 		  /// it finds the first edge from \c u to \c v. Otherwise it looks for
 		  /// the next edge from \c u to \c v after \c prev.
 		  /// \return The found edge or \ref INVALID if there is no such an edge.
 		  ///
 		  /// Thus you can iterate through each edge between \c u and \c v
 		  /// as it follows.
 		  ///\code
 		  /// for(Edge e = findEdge(g,u,v); e != INVALID; e = findEdge(g,u,v,e)) {
 		  ///   ...
 		  /// }
 		  ///\endcode
 		  ///
 		  /// \note \ref ConEdgeIt provides iterator interface for the same
 		  /// functionality.
 		  ///
 		  ///\sa ConEdgeIt
 		  template <typename Graph>
 		  inline typename Graph::Edge
 		  findEdge(const Graph &g, typename Graph::Node u, typename Graph::Node v,
 		            typename Graph::Edge p = INVALID) {
 		    return _core_bits::FindEdgeSelector<Graph>::find(g, u, v, p);
+		  }
 		  /// \brief Iterator for iterating on parallel edges connecting the same nodes.
 		  ///
 		  /// Iterator for iterating on parallel edges connecting the same nodes.
 		  /// It is a higher level interface for the findEdge() function. You can
 		  /// use it the following way:
 		  ///\code
 		  /// for (ConEdgeIt<Graph> it(g, u, v); it != INVALID; ++it) {
 		  ///   ...
 		  /// }
 		  ///\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.
 		  ///Using this class, you can find an arc in a digraph from a given
 		  ///source to a given target in amortized time <em>O</em>(log<em>d</em>),
 		  ///where <em>d</em> is the out-degree of the source node.
 		  ///
 		  ///It is possible to find \e all parallel arcs between two nodes with
 		  ///the \c operator() member.
 		  ///
 		  ///This is a dynamic data structure. Consider to use \ref ArcLookUp or
 		  ///\ref AllArcLookUp if your digraph is not changed so frequently.
 		  ///
 		  ///This class uses a self-adjusting binary search tree, the Splay tree
 		  ///of Sleator and Tarjan to guarantee the logarithmic amortized
 		  ///time bound for arc look-ups. This class also guarantees the
 		  ///optimal time bound in a constant factor for any distribution of
 		  ///queries.
 		  ///
 		  ///\tparam GR The type of the underlying digraph.
 		  ///
 		  ///\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);
+		      }
 		      virtual void add(const std::vector<Node>& nodes) {
 		        Parent::add(nodes);
 		        for (int i = 0; i < int(nodes.size()); ++i) {
 		          Parent::set(nodes[i], INVALID);
+		        }
+		      }
 		      virtual void build() {
 		        Parent::build();
 		        Node it;
 		        typename Parent::Notifier* nf = Parent::notifier();
 		        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.
 		    ///
 		    ///It builds up the search database.
 		    DynArcLookUp(const Digraph &g)
 		      : _g(g),_head(g),_parent(g),_left(g),_right(g)
+		    {
 		      Parent::attach(_g.notifier(typename Digraph::Arc()));
 		      refresh();
+		    }
 		  protected:
 		    virtual void add(const Arc& arc) {
 		      insert(arc);
+		    }
 		    virtual void add(const std::vector<Arc>& arcs) {
 		      for (int i = 0; i < int(arcs.size()); ++i) {
 		        insert(arcs[i]);
+		      }
+		    }
 		    virtual void erase(const Arc& arc) {
 		      remove(arc);
+		    }
 		    virtual void erase(const std::vector<Arc>& arcs) {
 		      for (int i = 0; i < int(arcs.size()); ++i) {
 		        remove(arcs[i]);
+		      }
+		    }
 		    virtual void build() {
 		      refresh();
+		    }
 		    virtual void clear() {
 		      for(NodeIt n(_g);n!=INVALID;++n) {
 		        _head[n] = INVALID;
+		      }
+		    }
 		    void insert(Arc arc) {
 		      Node s = _g.source(arc);
 		      Node t = _g.target(arc);
 		      _left[arc] = INVALID;
 		      _right[arc] = INVALID;
 		      Arc e = _head[s];
 		      if (e == INVALID) {
 		        _head[s] = arc;
 		        _parent[arc] = INVALID;
 		        return;
+		      }
 		      while (true) {
 		        if (t < _g.target(e)) {
 		          if (_left[e] == INVALID) {
 		            _left[e] = arc;
 		            _parent[arc] = e;
 		            splay(arc);
 		            return;
 		          } else {
 		            e = _left[e];
+		          }
 		        } else {
 		          if (_right[e] == INVALID) {
 		            _right[e] = arc;
 		            _parent[arc] = e;
 		            splay(arc);
 		            return;
 		          } else {
 		            e = _right[e];
+		          }
+		        }
+		      }
+		    }
 		    void remove(Arc arc) {
 		      if (_left[arc] == INVALID) {
 		        if (_right[arc] != INVALID) {
 		          _parent[_right[arc]] = _parent[arc];
+		        }
 		        if (_parent[arc] != INVALID) {
 		          if (_left[_parent[arc]] == arc) {
 		            _left[_parent[arc]] = _right[arc];
 		          } else {
 		            _right[_parent[arc]] = _right[arc];
+		          }
 		        } else {
 		          _head[_g.source(arc)] = _right[arc];
+		        }
 		      } else if (_right[arc] == INVALID) {
 		        _parent[_left[arc]] = _parent[arc];
 		        if (_parent[arc] != INVALID) {
 		          if (_left[_parent[arc]] == arc) {
 		            _left[_parent[arc]] = _left[arc];
 		          } else {
 		            _right[_parent[arc]] = _left[arc];
+		          }
 		        } else {
 		          _head[_g.source(arc)] = _left[arc];
+		        }
 		      } else {
 		        Arc e = _left[arc];
 		        if (_right[e] != INVALID) {
 		          e = _right[e];
 		          while (_right[e] != INVALID) {
 		            e = _right[e];
+		          }
 		          Arc s = _parent[e];
 		          _right[_parent[e]] = _left[e];
 		          if (_left[e] != INVALID) {
 		            _parent[_left[e]] = _parent[e];
+		          }
 		          _left[e] = _left[arc];
 		          _parent[_left[arc]] = e;
 		          _right[e] = _right[arc];
 		          _parent[_right[arc]] = e;
 		          _parent[e] = _parent[arc];
 		          if (_parent[arc] != INVALID) {
 		            if (_left[_parent[arc]] == arc) {
 		              _left[_parent[arc]] = e;
 		            } else {
 		              _right[_parent[arc]] = e;
+		            }
+		          }
 		          splay(s);
 		        } else {
 		          _right[e] = _right[arc];
 		          _parent[_right[arc]] = e;
 		          _parent[e] = _parent[arc];
 		          if (_parent[arc] != INVALID) {
 		            if (_left[_parent[arc]] == arc) {
 		              _left[_parent[arc]] = e;
 		            } else {
 		              _right[_parent[arc]] = e;
+		            }
 		          } else {
 		            _head[_g.source(arc)] = e;
+		          }
+		        }
+		      }
+		    }
 		    Arc refreshRec(std::vector<Arc> &v,int a,int b)
+		    {
 		      int m=(a+b)/2;
 		      Arc me=v[m];
 		      if (a < m) {
 		        Arc left = refreshRec(v,a,m-1);
 		        _left[me] = left;
 		        _parent[left] = me;
 		      } else {
 		        _left[me] = INVALID;
+		      }
 		      if (m < b) {
 		        Arc right = refreshRec(v,m+1,b);
 		        _right[me] = right;
 		        _parent[right] = me;
 		      } else {
 		        _right[me] = INVALID;
+		      }
 		      return me;
+		    }
 		    void refresh() {
 		      for(NodeIt n(_g);n!=INVALID;++n) {
 		        std::vector<Arc> v;
 		        for(OutArcIt a(_g,n);a!=INVALID;++a) v.push_back(a);
 		        if (!v.empty()) {
 		          std::sort(v.begin(),v.end(),ArcLess(_g));
 		          Arc head = refreshRec(v,0,v.size()-1);
 		          _head[n] = head;
 		          _parent[head] = INVALID;
+		        }
 		        else _head[n] = INVALID;
+		      }
+		    }
 		    void zig(Arc v) {
 		      Arc w = _parent[v];
 		      _parent[v] = _parent[w];
 		      _parent[w] = v;
 		      _left[w] = _right[v];
 		      _right[v] = w;
 		      if (_parent[v] != INVALID) {
 		        if (_right[_parent[v]] == w) {
 		          _right[_parent[v]] = v;
 		        } else {
 		          _left[_parent[v]] = v;
+		        }
+		      }
 		      if (_left[w] != INVALID){
 		        _parent[_left[w]] = w;
+		      }
+		    }
 		    void zag(Arc v) {
 		      Arc w = _parent[v];
 		      _parent[v] = _parent[w];
 		      _parent[w] = v;
 		      _right[w] = _left[v];
 		      _left[v] = w;
 		      if (_parent[v] != INVALID){
 		        if (_left[_parent[v]] == w) {
 		          _left[_parent[v]] = v;
 		        } else {
 		          _right[_parent[v]] = v;
+		        }
+		      }
 		      if (_right[w] != INVALID){
 		        _parent[_right[w]] = w;
+		      }
+		    }
 		    void splay(Arc v) {
 		      while (_parent[v] != INVALID) {
 		        if (v == _left[_parent[v]]) {
 		          if (_parent[_parent[v]] == INVALID) {
 		            zig(v);
 		          } else {
 		            if (_parent[v] == _left[_parent[_parent[v]]]) {
 		              zig(_parent[v]);
 		              zig(v);
 		            } else {
 		              zig(v);
 		              zag(v);
+		            }
+		          }
 		        } else {
 		          if (_parent[_parent[v]] == INVALID) {
 		            zag(v);
 		          } else {
 		            if (_parent[v] == _left[_parent[_parent[v]]]) {
 		              zag(v);
 		              zig(v);
 		            } else {
 		              zag(_parent[v]);
 		              zag(v);
+		            }
+		          }
+		        }
+		      }
 		      _head[_g.source(v)] = v;
+		    }
 		  public:
 		    ///Find an arc between two nodes.
 		    ///Find an arc between two nodes.
 		    ///\param s The source node.
 		    ///\param t The target node.
 		    ///\param p The previous arc between \c s and \c t. It it is INVALID or
 		    ///not given, the operator finds the first appropriate arc.
 		    ///\return An arc from \c s to \c t after \c p or
 		    ///\ref INVALID if there is no more.
 		    ///
 		    ///For example, you can count the number of arcs from \c u to \c v in the
 		    ///following way.
 		    ///\code
 		    ///DynArcLookUp<ListDigraph> ae(g);
 		    ///...
 		    ///int n = 0;
 		    ///for(Arc a = ae(u,v); a != INVALID; a = ae(u,v,a)) n++;
 		    ///\endcode
 		    ///
 		    ///Finding the arcs take at most <em>O</em>(log<em>d</em>)
 		    ///amortized time, specifically, the time complexity of the lookups
 		    ///is equal to the optimal search tree implementation for the
 		    ///current query distribution in a constant factor.
 		    ///
 		    ///\note This is a dynamic data structure, therefore the data
 		    ///structure is updated after each graph alteration. Thus although
 		    ///this data structure is theoretically faster than \ref ArcLookUp
 		    ///and \ref AllArcLookUp, it often provides worse performance than
 		    ///them.
 		    Arc operator()(Node s, Node t, Arc p = INVALID) const  {
 		      if (p == INVALID) {
 		        Arc a = _head[s];
 		        if (a == INVALID) return INVALID;
 		        Arc r = INVALID;
 		        while (true) {
 		          if (_g.target(a) < t) {
 		            if (_right[a] == INVALID) {
 		              const_cast<DynArcLookUp&>(*this).splay(a);
 		              return r;
 		            } else {
 		              a = _right[a];
+		            }
 		          } else {
 		            if (_g.target(a) == t) {
 		              r = a;
+		            }
 		            if (_left[a] == INVALID) {
 		              const_cast<DynArcLookUp&>(*this).splay(a);
 		              return r;
 		            } else {
 		              a = _left[a];
+		            }
+		          }
+		        }
 		      } else {
 		        Arc a = p;
 		        if (_right[a] != INVALID) {
 		          a = _right[a];
 		          while (_left[a] != INVALID) {
 		            a = _left[a];
+		          }
 		          const_cast<DynArcLookUp&>(*this).splay(a);
 		        } else {
 		          while (_parent[a] != INVALID && _right[_parent[a]] ==  a) {
 		            a = _parent[a];
+		          }
 		          if (_parent[a] == INVALID) {
 		            return INVALID;
 		          } else {
 		            a = _parent[a];
 		            const_cast<DynArcLookUp&>(*this).splay(a);
+		          }
+		        }
 		        if (_g.target(a) == t) return a;
 		        else return INVALID;
+		      }
+		    }
 		  };
 		  ///Fast arc look-up between given endpoints.
 		  ///Using this class, you can find an arc in a digraph from a given
 		  ///source to a given target in time <em>O</em>(log<em>d</em>),
 		  ///where <em>d</em> is the out-degree of the source node.
 		  ///
 		  ///It is not possible to find \e all parallel arcs between two nodes.
 		  ///Use \ref AllArcLookUp for this purpose.
 		  ///
 		  ///\warning This class is static, so you should call refresh() (or at
 		  ///least refresh(Node)) to refresh this data structure whenever the
 		  ///digraph changes. This is a time consuming (superlinearly proportional
 		  ///(<em>O</em>(<em>m</em> log<em>m</em>)) to the number of arcs).
 		  ///
 		  ///\tparam GR The type of the underlying digraph.
 		  ///
 		  ///\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;
 		    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);
+		      }
 		    };
 		  public:
 		    ///Constructor
 		    ///Constructor.
 		    ///
 		    ///It builds up the search database, which remains valid until the digraph
 		    ///changes.
 		    ArcLookUp(const Digraph &g) :_g(g),_head(g),_left(g),_right(g) {refresh();}
 		  private:
 		    Arc refreshRec(std::vector<Arc> &v,int a,int b)
+		    {
 		      int m=(a+b)/2;
 		      Arc me=v[m];
 		      _left[me] = a<m?refreshRec(v,a,m-1):INVALID;
 		      _right[me] = m<b?refreshRec(v,m+1,b):INVALID;
 		      return me;
+		    }
 		  public:
 		    ///Refresh the search data structure at a node.
 		    ///Build up the search database of node \c n.
 		    ///
 		    ///It runs in time <em>O</em>(<em>d</em> log<em>d</em>), where <em>d</em>
 		    ///is the number of the outgoing arcs of \c n.
 		    void refresh(Node n)
+		    {
 		      std::vector<Arc> v;
 		      for(OutArcIt e(_g,n);e!=INVALID;++e) v.push_back(e);
 		      if(v.size()) {
 		        std::sort(v.begin(),v.end(),ArcLess(_g));
 		        _head[n]=refreshRec(v,0,v.size()-1);
+		      }
 		      else _head[n]=INVALID;
+		    }
 		    ///Refresh the full data structure.
 		    ///Build up the full search database. In fact, it simply calls
 		    ///\ref refresh(Node) "refresh(n)" for each node \c n.
 		    ///
 		    ///It runs in time <em>O</em>(<em>m</em> log<em>D</em>), where <em>m</em> is
 		    ///the number of the arcs in the digraph and <em>D</em> is the maximum
 		    ///out-degree of the digraph.
 		    void refresh()
+		    {
 		      for(NodeIt n(_g);n!=INVALID;++n) refresh(n);
+		    }
 		    ///Find an arc between two nodes.
 		    ///Find an arc between two nodes in time <em>O</em>(log<em>d</em>),
 		    ///where <em>d</em> is the number of outgoing arcs of \c s.
 		    ///\param s The source node.
 		    ///\param t The target node.
 		    ///\return An arc from \c s to \c t if there exists,
 		    ///\ref INVALID otherwise.
 		    ///
 		    ///\warning If you change the digraph, refresh() must be called before using
 		    ///this operator. If you change the outgoing arcs of
 		    ///a single node \c n, then \ref refresh(Node) "refresh(n)" is enough.
 		    Arc operator()(Node s, Node t) const
+		    {
 		      Arc e;
 		      for(e=_head[s];
 		          e!=INVALID&&_g.target(e)!=t;
 		          e = t < _g.target(e)?_left[e]:_right[e]) ;
 		      return e;
+		    }
 		  };
 		  ///Fast look-up of all arcs between given endpoints.
 		  ///This class is the same as \ref ArcLookUp, with the addition
 		  ///that it makes it possible to find all parallel arcs between given
 		  ///endpoints.
 		  ///
 		  ///\warning This class is static, so you should call refresh() (or at
 		  ///least refresh(Node)) to refresh this data structure whenever the
 		  ///digraph changes. This is a time consuming (superlinearly proportional
 		  ///(<em>O</em>(<em>m</em> log<em>m</em>)) to the number of arcs).
 		  ///
 		  ///\tparam GR The type of the underlying digraph.
 		  ///
 		  ///\sa DynArcLookUp
 		  ///\sa ArcLookUp
 		  template<class GR>
 		  class AllArcLookUp : public ArcLookUp<GR>
+		  {
 		    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);
 		        _next[head]=( next!=INVALID && _g.target(next)==_g.target(head))
 		          ? next : INVALID;
 		        return refreshNext(_left[head],head);
+		      }
+		    }
 		    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.
 		    AllArcLookUp(const Digraph &g) : ArcLookUp<GR>(g), _next(g) {refreshNext();}
 		    ///Refresh the data structure at a node.
 		    ///Build up the search database of node \c n.
 		    ///
 		    ///It runs in time <em>O</em>(<em>d</em> log<em>d</em>), where <em>d</em> is
 		    ///the number of the outgoing arcs of \c n.
 		    void refresh(Node n)
+		    {
 		      ArcLookUp<GR>::refresh(n);
 		      refreshNext(_head[n]);
+		    }
 		    ///Refresh the full data structure.
 		    ///Build up the full search database. In fact, it simply calls
 		    ///\ref refresh(Node) "refresh(n)" for each node \c n.
 		    ///
 		    ///It runs in time <em>O</em>(<em>m</em> log<em>D</em>), where <em>m</em> is
 		    ///the number of the arcs in the digraph and <em>D</em> is the maximum
 		    ///out-degree of the digraph.
 		    void refresh()
+		    {
 		      for(NodeIt n(_g);n!=INVALID;++n) refresh(_head[n]);
+		    }
 		    ///Find an arc between two nodes.
 		    ///Find an arc between two nodes.
 		    ///\param s The source node.
 		    ///\param t The target node.
 		    ///\param prev The previous arc between \c s and \c t. It it is INVALID or
 		    ///not given, the operator finds the first appropriate arc.
 		    ///\return An arc from \c s to \c t after \c prev or
 		    ///\ref INVALID if there is no more.
 		    ///
 		    ///For example, you can count the number of arcs from \c u to \c v in the
 		    ///following way.
 		    ///\code
 		    ///AllArcLookUp<ListDigraph> ae(g);
 		    ///...
 		    ///int n = 0;
 		    ///for(Arc a = ae(u,v); a != INVALID; a=ae(u,v,a)) n++;
 		    ///\endcode
 		    ///
 		    ///Finding the first arc take <em>O</em>(log<em>d</em>) time,
 		    ///where <em>d</em> is the number of outgoing arcs of \c s. Then the
 		    ///consecutive arcs are found in constant time.
 		    ///
 		    ///\warning If you change the digraph, refresh() must be called before using
 		    ///this operator. If you change the outgoing arcs of
 		    ///a single node \c n, then \ref refresh(Node) "refresh(n)" is enough.
 		    ///
 		#ifdef DOXYGEN
 		    Arc operator()(Node s, Node t, Arc prev=INVALID) const {}
 		#else
 		    using ArcLookUp<GR>::operator() ;
 		    Arc operator()(Node s, Node t, Arc prev) const
+		    {
 		      return prev==INVALID?(*this)(s,t):_next[prev];
+		    }
 		#endif
 		  };
 		  /// @}
 		} //namespace lemon
 		#endif

lemon/edge_set.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_EDGE_SET_H
 		#define LEMON_EDGE_SET_H
 		#include <lemon/core.h>
 		#include <lemon/bits/edge_set_extender.h>
 		/// \ingroup semi_adaptors
 		/// \file
 		/// \brief ArcSet and EdgeSet classes.
 		///
 		/// Graphs which use another graph's node-set as own.
 		namespace lemon {
 		  template <typename GR>
 		  class ListArcSetBase {
 		  public:
 		    typedef GR Graph;
 		    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) {}
 		    };
 		    typedef typename ItemSetTraits<GR, Node>::
 		    template Map<NodeT>::Type NodesImplBase;
 		    NodesImplBase* _nodes;
 		    struct ArcT {
 		      Node source, target;
 		      int next_out, next_in;
 		      int prev_out, prev_in;
 		      ArcT() : prev_out(-1), prev_in(-1) {}
 		    };
 		    std::vector<ArcT> arcs;
 		    int first_arc;
 		    int first_free_arc;
 		    const GR* _graph;
 		    void initalize(const GR& graph, NodesImplBase& nodes) {
 		      _graph = &graph;
 		      _nodes = &nodes;
+		    }
 		  public:
 		    class Arc {
 		      friend class ListArcSetBase<GR>;
 		    protected:
 		      Arc(int _id) : id(_id) {}
 		      int id;
 		    public:
 		      Arc() {}
 		      Arc(Invalid) : id(-1) {}
 		      bool operator==(const Arc& arc) const { return id == arc.id; }
 		      bool operator!=(const Arc& arc) const { return id != arc.id; }
 		      bool operator<(const Arc& arc) const { return id < arc.id; }
 		    };
 		    ListArcSetBase() : first_arc(-1), first_free_arc(-1) {}
 		    Arc addArc(const Node& u, const Node& v) {
 		      int n;
 		      if (first_free_arc == -1) {
 		        n = arcs.size();
 		        arcs.push_back(ArcT());
 		      } else {
 		        n = first_free_arc;
 		        first_free_arc = arcs[first_free_arc].next_in;
+		      }
 		      arcs[n].next_in = (*_nodes)[v].first_in;
 		      if ((*_nodes)[v].first_in != -1) {
 		        arcs[(*_nodes)[v].first_in].prev_in = n;
+		      }
 		      (*_nodes)[v].first_in = n;
 		      arcs[n].next_out = (*_nodes)[u].first_out;
 		      if ((*_nodes)[u].first_out != -1) {
 		        arcs[(*_nodes)[u].first_out].prev_out = n;
+		      }
 		      (*_nodes)[u].first_out = n;
 		      arcs[n].source = u;
 		      arcs[n].target = v;
 		      return Arc(n);
+		    }
 		    void erase(const Arc& arc) {
 		      int n = arc.id;
 		      if (arcs[n].prev_in != -1) {
 		        arcs[arcs[n].prev_in].next_in = arcs[n].next_in;
 		      } else {
 		        (*_nodes)[arcs[n].target].first_in = arcs[n].next_in;
+		      }
 		      if (arcs[n].next_in != -1) {
 		        arcs[arcs[n].next_in].prev_in = arcs[n].prev_in;
+		      }
 		      if (arcs[n].prev_out != -1) {
 		        arcs[arcs[n].prev_out].next_out = arcs[n].next_out;
 		      } else {
 		        (*_nodes)[arcs[n].source].first_out = arcs[n].next_out;
+		      }
 		      if (arcs[n].next_out != -1) {
 		        arcs[arcs[n].next_out].prev_out = arcs[n].prev_out;
+		      }
+		    }
 		    void clear() {
 		      Node node;
 		      for (first(node); node != INVALID; next(node)) {
 		        (*_nodes)[node].first_in = -1;
 		        (*_nodes)[node].first_out = -1;
+		      }
 		      arcs.clear();
 		      first_arc = -1;
 		      first_free_arc = -1;
+		    }
 		    void first(Node& node) const {
 		      _graph->first(node);
+		    }
 		    void next(Node& node) const {
 		      _graph->next(node);
+		    }
 		    void first(Arc& arc) const {
 		      Node node;
 		      first(node);
 		      while (node != INVALID && (*_nodes)[node].first_in == -1) {
 		        next(node);
+		      }
 		      arc.id = (node == INVALID) ? -1 : (*_nodes)[node].first_in;
+		    }
 		    void next(Arc& arc) const {
 		      if (arcs[arc.id].next_in != -1) {
 		        arc.id = arcs[arc.id].next_in;
 		      } else {
 		        Node node = arcs[arc.id].target;
 		        next(node);
 		        while (node != INVALID && (*_nodes)[node].first_in == -1) {
 		          next(node);
+		        }
 		        arc.id = (node == INVALID) ? -1 : (*_nodes)[node].first_in;
+		      }
+		    }
 		    void firstOut(Arc& arc, const Node& node) const {
 		      arc.id = (*_nodes)[node].first_out;
+		    }
 		    void nextOut(Arc& arc) const {
 		      arc.id = arcs[arc.id].next_out;
+		    }
 		    void firstIn(Arc& arc, const Node& node) const {
 		      arc.id = (*_nodes)[node].first_in;
+		    }
 		    void nextIn(Arc& arc) const {
 		      arc.id = arcs[arc.id].next_in;
+		    }
 		    int id(const Node& node) const { return _graph->id(node); }
 		    int id(const Arc& arc) const { return arc.id; }
 		    Node nodeFromId(int ix) const { return _graph->nodeFromId(ix); }
 		    Arc arcFromId(int ix) const { return Arc(ix); }
 		    int maxNodeId() const { return _graph->maxNodeId(); };
 		    int maxArcId() const { return arcs.size() - 1; }
 		    Node source(const Arc& arc) const { return arcs[arc.id].source;}
 		    Node target(const Arc& arc) const { return arcs[arc.id].target;}
 		    typedef typename ItemSetTraits<GR, Node>::ItemNotifier NodeNotifier;
 		    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) {}
 		      NodeMap& operator=(const NodeMap& cmap) {
 		        return operator=<NodeMap>(cmap);
+		      }
 		      template <typename CMap>
 		      NodeMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		  };
 		  /// \ingroup semi_adaptors
 		  ///
 		  /// \brief Digraph using a node set of another digraph or graph and
 		  /// an own arc set.
 		  ///
 		  /// This structure can be used to establish another directed graph
 		  /// over a node set of an existing one. This class uses the same
 		  /// Node type as the underlying graph, and each valid node of the
 		  /// original graph is valid in this arc set, therefore the node
 		  /// objects of the original graph can be used directly with this
 		  /// class. The node handling functions (id handling, observing, and
 		  /// iterators) works equivalently as in the original graph.
 		  ///
 		  /// This implementation is based on doubly-linked lists, from each
 		  /// node the outgoing and the incoming arcs make up lists, therefore
 		  /// one arc can be erased in constant time. It also makes possible,
 		  /// that node can be removed from the underlying graph, in this case
 		  /// all arcs incident to the given node is erased from the arc set.
 		  ///
 		  /// \param GR The type of the graph which shares its node set with
 		  /// this class. Its interface must conform to the
 		  /// \ref concepts::Digraph "Digraph" or \ref concepts::Graph "Graph"
 		  /// 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 ) {
 		        erase(arc);
 		        Parent::firstOut(arc, node);
+		      }
 		      Parent::firstIn(arc, node);
 		      while (arc != INVALID ) {
 		        erase(arc);
 		        Parent::firstIn(arc, node);
+		      }
+		    }
 		    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:
 		      virtual void erase(const Node& node) {
 		        _arcset.eraseNode(node);
 		        Parent::erase(node);
+		      }
 		      virtual void erase(const std::vector<Node>& nodes) {
 		        for (int i = 0; i < int(nodes.size()); ++i) {
 		          _arcset.eraseNode(nodes[i]);
+		        }
 		        Parent::erase(nodes);
+		      }
 		      virtual void clear() {
 		        _arcset.clearNodes();
 		        Parent::clear();
+		      }
 		    private:
 		      ListArcSet& _arcset;
 		    };
 		    NodesImpl _nodes;
 		  public:
 		    /// \brief Constructor of the ArcSet.
 		    ///
 		    /// Constructor of the ArcSet.
 		    ListArcSet(const GR& graph) : _nodes(graph, *this) {
 		      Parent::initalize(graph, _nodes);
+		    }
 		    /// \brief Add a new arc to the digraph.
 		    ///
 		    /// Add a new arc to the digraph with source node \c s
 		    /// and target node \c t.
 		    /// \return The new arc.
 		    Arc addArc(const Node& s, const Node& t) {
 		      return Parent::addArc(s, t);
+		    }
 		    /// \brief Erase an arc from the digraph.
 		    ///
 		    /// Erase an arc \c a from the digraph.
 		    void erase(const Arc& a) {
 		      return Parent::erase(a);
+		    }
 		  };
 		  template <typename GR>
 		  class ListEdgeSetBase {
 		  public:
 		    typedef GR Graph;
 		    typedef typename GR::Node Node;
 		    typedef typename GR::NodeIt NodeIt;
 		  protected:
 		    struct NodeT {
 		      int first_out;
 		      NodeT() : first_out(-1) {}
 		    };
 		    typedef typename ItemSetTraits<GR, Node>::
 		    template Map<NodeT>::Type NodesImplBase;
 		    NodesImplBase* _nodes;
 		    struct ArcT {
 		      Node target;
 		      int prev_out, next_out;
 		      ArcT() : prev_out(-1), next_out(-1) {}
 		    };
 		    std::vector<ArcT> arcs;
 		    int first_arc;
 		    int first_free_arc;
 		    const GR* _graph;
 		    void initalize(const GR& graph, NodesImplBase& nodes) {
 		      _graph = &graph;
 		      _nodes = &nodes;
+		    }
 		  public:
 		    class Edge {
 		      friend class ListEdgeSetBase;
 		    protected:
 		      int id;
 		      explicit Edge(int _id) { id = _id;}
 		    public:
 		      Edge() {}
 		      Edge (Invalid) { id = -1; }
 		      bool operator==(const Edge& arc) const {return id == arc.id;}
 		      bool operator!=(const Edge& arc) const {return id != arc.id;}
 		      bool operator<(const Edge& arc) const {return id < arc.id;}
 		    };
 		    class Arc {
 		      friend class ListEdgeSetBase;
 		    protected:
 		      Arc(int _id) : id(_id) {}
 		      int id;
 		    public:
 		      operator Edge() const { return edgeFromId(id / 2); }
 		      Arc() {}
 		      Arc(Invalid) : id(-1) {}
 		      bool operator==(const Arc& arc) const { return id == arc.id; }
 		      bool operator!=(const Arc& arc) const { return id != arc.id; }
 		      bool operator<(const Arc& arc) const { return id < arc.id; }
 		    };
 		    ListEdgeSetBase() : first_arc(-1), first_free_arc(-1) {}
 		    Edge addEdge(const Node& u, const Node& v) {
 		      int n;
 		      if (first_free_arc == -1) {
 		        n = arcs.size();
 		        arcs.push_back(ArcT());
 		        arcs.push_back(ArcT());
 		      } else {
 		        n = first_free_arc;
 		        first_free_arc = arcs[n].next_out;
+		      }
 		      arcs[n].target = u;
 		      arcs[n | 1].target = v;
 		      arcs[n].next_out = (*_nodes)[v].first_out;
 		      if ((*_nodes)[v].first_out != -1) {
 		        arcs[(*_nodes)[v].first_out].prev_out = n;
+		      }
 		      (*_nodes)[v].first_out = n;
 		      arcs[n].prev_out = -1;
 		      if ((*_nodes)[u].first_out != -1) {
 		        arcs[(*_nodes)[u].first_out].prev_out = (n | 1);
+		      }
 		      arcs[n | 1].next_out = (*_nodes)[u].first_out;
 		      (*_nodes)[u].first_out = (n | 1);
 		      arcs[n | 1].prev_out = -1;
 		      return Edge(n / 2);
+		    }
 		    void erase(const Edge& arc) {
 		      int n = arc.id * 2;
 		      if (arcs[n].next_out != -1) {
 		        arcs[arcs[n].next_out].prev_out = arcs[n].prev_out;
+		      }
 		      if (arcs[n].prev_out != -1) {
 		        arcs[arcs[n].prev_out].next_out = arcs[n].next_out;
 		      } else {
 		        (*_nodes)[arcs[n | 1].target].first_out = arcs[n].next_out;
+		      }
 		      if (arcs[n | 1].next_out != -1) {
 		        arcs[arcs[n | 1].next_out].prev_out = arcs[n | 1].prev_out;
+		      }
 		      if (arcs[n | 1].prev_out != -1) {
 		        arcs[arcs[n | 1].prev_out].next_out = arcs[n | 1].next_out;
 		      } else {
 		        (*_nodes)[arcs[n].target].first_out = arcs[n | 1].next_out;
+		      }
 		      arcs[n].next_out = first_free_arc;
 		      first_free_arc = n;
+		    }
 		    void clear() {
 		      Node node;
 		      for (first(node); node != INVALID; next(node)) {
 		        (*_nodes)[node].first_out = -1;
+		      }
 		      arcs.clear();
 		      first_arc = -1;
 		      first_free_arc = -1;
+		    }
 		    void first(Node& node) const {
 		      _graph->first(node);
+		    }
 		    void next(Node& node) const {
 		      _graph->next(node);
+		    }
 		    void first(Arc& arc) const {
 		      Node node;
 		      first(node);
 		      while (node != INVALID && (*_nodes)[node].first_out == -1) {
 		        next(node);
+		      }
 		      arc.id = (node == INVALID) ? -1 : (*_nodes)[node].first_out;
+		    }
 		    void next(Arc& arc) const {
 		      if (arcs[arc.id].next_out != -1) {
 		        arc.id = arcs[arc.id].next_out;
 		      } else {
 		        Node node = arcs[arc.id ^ 1].target;
 		        next(node);
 		        while(node != INVALID && (*_nodes)[node].first_out == -1) {
 		          next(node);
+		        }
 		        arc.id = (node == INVALID) ? -1 : (*_nodes)[node].first_out;
+		      }
+		    }
 		    void first(Edge& edge) const {
 		      Node node;
 		      first(node);
 		      while (node != INVALID) {
 		        edge.id = (*_nodes)[node].first_out;
 		        while ((edge.id & 1) != 1) {
 		          edge.id = arcs[edge.id].next_out;
+		        }
 		        if (edge.id != -1) {
 		          edge.id /= 2;
 		          return;
+		        }
 		        next(node);
+		      }
 		      edge.id = -1;
+		    }
 		    void next(Edge& edge) const {
 		      Node node = arcs[edge.id * 2].target;
 		      edge.id = arcs[(edge.id * 2) | 1].next_out;
 		      while ((edge.id & 1) != 1) {
 		        edge.id = arcs[edge.id].next_out;
+		      }
 		      if (edge.id != -1) {
 		        edge.id /= 2;
 		        return;
+		      }
 		      next(node);
 		      while (node != INVALID) {
 		        edge.id = (*_nodes)[node].first_out;
 		        while ((edge.id & 1) != 1) {
 		          edge.id = arcs[edge.id].next_out;
+		        }
 		        if (edge.id != -1) {
 		          edge.id /= 2;
 		          return;
+		        }
 		        next(node);
+		      }
 		      edge.id = -1;
+		    }
 		    void firstOut(Arc& arc, const Node& node) const {
 		      arc.id = (*_nodes)[node].first_out;
+		    }
 		    void nextOut(Arc& arc) const {
 		      arc.id = arcs[arc.id].next_out;
+		    }
 		    void firstIn(Arc& arc, const Node& node) const {
 		      arc.id = (((*_nodes)[node].first_out) ^ 1);
 		      if (arc.id == -2) arc.id = -1;
+		    }
 		    void nextIn(Arc& arc) const {
 		      arc.id = ((arcs[arc.id ^ 1].next_out) ^ 1);
 		      if (arc.id == -2) arc.id = -1;
+		    }
 		    void firstInc(Edge &arc, bool& dir, const Node& node) const {
 		      int de = (*_nodes)[node].first_out;
 		      if (de != -1 ) {
 		        arc.id = de / 2;
 		        dir = ((de & 1) == 1);
 		      } else {
 		        arc.id = -1;
 		        dir = true;
+		      }
+		    }
 		    void nextInc(Edge &arc, bool& dir) const {
 		      int de = (arcs[(arc.id * 2) | (dir ? 1 : 0)].next_out);
 		      if (de != -1 ) {
 		        arc.id = de / 2;
 		        dir = ((de & 1) == 1);
 		      } else {
 		        arc.id = -1;
 		        dir = true;
+		      }
+		    }
 		    static bool direction(Arc arc) {
 		      return (arc.id & 1) == 1;
+		    }
 		    static Arc direct(Edge edge, bool dir) {
 		      return Arc(edge.id * 2 + (dir ? 1 : 0));
+		    }
 		    int id(const Node& node) const { return _graph->id(node); }
 		    static int id(Arc e) { return e.id; }
 		    static int id(Edge e) { return e.id; }
 		    Node nodeFromId(int id) const { return _graph->nodeFromId(id); }
 		    static Arc arcFromId(int id) { return Arc(id);}
 		    static Edge edgeFromId(int id) { return Edge(id);}
 		    int maxNodeId() const { return _graph->maxNodeId(); };
 		    int maxEdgeId() const { return arcs.size() / 2 - 1; }
 		    int maxArcId() const { return arcs.size()-1; }
 		    Node source(Arc e) const { return arcs[e.id ^ 1].target; }
 		    Node target(Arc e) const { return arcs[e.id].target; }
 		    Node u(Edge e) const { return arcs[2 * e.id].target; }
 		    Node v(Edge e) const { return arcs[2 * e.id + 1].target; }
 		    typedef typename ItemSetTraits<GR, Node>::ItemNotifier NodeNotifier;
 		    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) {}
 		      NodeMap& operator=(const NodeMap& cmap) {
 		        return operator=<NodeMap>(cmap);
+		      }
 		      template <typename CMap>
 		      NodeMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		  };
 		  /// \ingroup semi_adaptors
 		  ///
 		  /// \brief Graph using a node set of another digraph or graph and an
 		  /// own edge set.
 		  ///
 		  /// This structure can be used to establish another graph over a
 		  /// node set of an existing one. This class uses the same Node type
 		  /// as the underlying graph, and each valid node of the original
 		  /// graph is valid in this arc set, therefore the node objects of
 		  /// the original graph can be used directly with this class. The
 		  /// node handling functions (id handling, observing, and iterators)
 		  /// works equivalently as in the original graph.
 		  ///
 		  /// This implementation is based on doubly-linked lists, from each
 		  /// node the incident edges make up lists, therefore one edge can be
 		  /// erased in constant time. It also makes possible, that node can
 		  /// be removed from the underlying graph, in this case all edges
 		  /// incident to the given node is erased from the arc set.
 		  ///
 		  /// \param GR The type of the graph which shares its node set
 		  /// with this class. Its interface must conform to the
 		  /// \ref concepts::Digraph "Digraph" or \ref concepts::Graph "Graph"
 		  /// 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 ) {
 		        erase(arc);
 		        Parent::firstOut(arc, node);
+		      }
+		    }
 		    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:
 		      virtual void erase(const Node& node) {
 		        _arcset.eraseNode(node);
 		        Parent::erase(node);
+		      }
 		      virtual void erase(const std::vector<Node>& nodes) {
 		        for (int i = 0; i < int(nodes.size()); ++i) {
 		          _arcset.eraseNode(nodes[i]);
+		        }
 		        Parent::erase(nodes);
+		      }
 		      virtual void clear() {
 		        _arcset.clearNodes();
 		        Parent::clear();
+		      }
 		    private:
 		      ListEdgeSet& _arcset;
 		    };
 		    NodesImpl _nodes;
 		  public:
 		    /// \brief Constructor of the EdgeSet.
 		    ///
 		    /// Constructor of the EdgeSet.
 		    ListEdgeSet(const GR& graph) : _nodes(graph, *this) {
 		      Parent::initalize(graph, _nodes);
+		    }
 		    /// \brief Add a new edge to the graph.
 		    ///
 		    /// Add a new edge to the graph with node \c u
 		    /// and node \c v endpoints.
 		    /// \return The new edge.
 		    Edge addEdge(const Node& u, const Node& v) {
 		      return Parent::addEdge(u, v);
+		    }
 		    /// \brief Erase an edge from the graph.
 		    ///
 		    /// Erase the edge \c e from the graph.
 		    void erase(const Edge& e) {
 		      return Parent::erase(e);
+		    }
 		  };
 		  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) {}
 		    };
 		    typedef typename ItemSetTraits<GR, Node>::
 		    template Map<NodeT>::Type NodesImplBase;
 		    NodesImplBase* _nodes;
 		    struct ArcT {
 		      Node source, target;
 		      int next_out, next_in;
 		      ArcT() {}
 		    };
 		    std::vector<ArcT> arcs;
 		    const GR* _graph;
 		    void initalize(const GR& graph, NodesImplBase& nodes) {
 		      _graph = &graph;
 		      _nodes = &nodes;
+		    }
 		  public:
 		    class Arc {
 		      friend class SmartArcSetBase<GR>;
 		    protected:
 		      Arc(int _id) : id(_id) {}
 		      int id;
 		    public:
 		      Arc() {}
 		      Arc(Invalid) : id(-1) {}
 		      bool operator==(const Arc& arc) const { return id == arc.id; }
 		      bool operator!=(const Arc& arc) const { return id != arc.id; }
 		      bool operator<(const Arc& arc) const { return id < arc.id; }
 		    };
 		    SmartArcSetBase() {}
 		    Arc addArc(const Node& u, const Node& v) {
 		      int n = arcs.size();
 		      arcs.push_back(ArcT());
 		      arcs[n].next_in = (*_nodes)[v].first_in;
 		      (*_nodes)[v].first_in = n;
 		      arcs[n].next_out = (*_nodes)[u].first_out;
 		      (*_nodes)[u].first_out = n;
 		      arcs[n].source = u;
 		      arcs[n].target = v;
 		      return Arc(n);
+		    }
 		    void clear() {
 		      Node node;
 		      for (first(node); node != INVALID; next(node)) {
 		        (*_nodes)[node].first_in = -1;
 		        (*_nodes)[node].first_out = -1;
+		      }
 		      arcs.clear();
+		    }
 		    void first(Node& node) const {
 		      _graph->first(node);
+		    }
 		    void next(Node& node) const {
 		      _graph->next(node);
+		    }
 		    void first(Arc& arc) const {
 		      arc.id = arcs.size() - 1;
+		    }
 		    void next(Arc& arc) const {
 		      --arc.id;
+		    }
 		    void firstOut(Arc& arc, const Node& node) const {
 		      arc.id = (*_nodes)[node].first_out;
+		    }
 		    void nextOut(Arc& arc) const {
 		      arc.id = arcs[arc.id].next_out;
+		    }
 		    void firstIn(Arc& arc, const Node& node) const {
 		      arc.id = (*_nodes)[node].first_in;
+		    }
 		    void nextIn(Arc& arc) const {
 		      arc.id = arcs[arc.id].next_in;
+		    }
 		    int id(const Node& node) const { return _graph->id(node); }
 		    int id(const Arc& arc) const { return arc.id; }
 		    Node nodeFromId(int ix) const { return _graph->nodeFromId(ix); }
 		    Arc arcFromId(int ix) const { return Arc(ix); }
 		    int maxNodeId() const { return _graph->maxNodeId(); };
 		    int maxArcId() const { return arcs.size() - 1; }
 		    Node source(const Arc& arc) const { return arcs[arc.id].source;}
 		    Node target(const Arc& arc) const { return arcs[arc.id].target;}
 		    typedef typename ItemSetTraits<GR, Node>::ItemNotifier NodeNotifier;
 		    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) { }
 		      NodeMap& operator=(const NodeMap& cmap) {
 		        return operator=<NodeMap>(cmap);
+		      }
 		      template <typename CMap>
 		      NodeMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		  };
 		  /// \ingroup semi_adaptors
 		  ///
 		  /// \brief Digraph using a node set of another digraph or graph and
 		  /// an own arc set.
 		  ///
 		  /// This structure can be used to establish another directed graph
 		  /// over a node set of an existing one. This class uses the same
 		  /// Node type as the underlying graph, and each valid node of the
 		  /// original graph is valid in this arc set, therefore the node
 		  /// objects of the original graph can be used directly with this
 		  /// class. The node handling functions (id handling, observing, and
 		  /// iterators) works equivalently as in the original graph.
 		  ///
 		  /// \param GR The type of the graph which shares its node set with
 		  /// this class. Its interface must conform to the
 		  /// \ref concepts::Digraph "Digraph" or \ref concepts::Graph "Graph"
 		  /// concept.
 		  ///
 		  /// This implementation is slightly faster than the \c ListArcSet,
 		  /// because it uses continuous storage for arcs and it uses just
 		  /// single-linked lists for enumerate outgoing and incoming
 		  /// arcs. Therefore the arcs cannot be erased from the arc sets.
 		  ///
 		  /// \warning If a node is erased from the underlying graph and this
 		  /// node is the source or target of one arc in the arc set, then
 		  /// the arc set is invalidated, and it cannot be used anymore. The
 		  /// 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 &&
 		          typename Parent::OutArcIt(*this, node) == INVALID) {
 		        return;
+		      }
 		      throw typename NodesImplBase::Notifier::ImmediateDetach();
+		    }
 		    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 {
 		        return Parent::attached();
+		      }
 		    protected:
 		      virtual void erase(const Node& node) {
 		        try {
 		          _arcset.eraseNode(node);
 		          Parent::erase(node);
 		        } catch (const typename NodesImplBase::Notifier::ImmediateDetach&) {
 		          Parent::clear();
 		          throw;
+		        }
+		      }
 		      virtual void erase(const std::vector<Node>& nodes) {
 		        try {
 		          for (int i = 0; i < int(nodes.size()); ++i) {
 		            _arcset.eraseNode(nodes[i]);
+		          }
 		          Parent::erase(nodes);
 		        } catch (const typename NodesImplBase::Notifier::ImmediateDetach&) {
 		          Parent::clear();
 		          throw;
+		        }
+		      }
 		      virtual void clear() {
 		        _arcset.clearNodes();
 		        Parent::clear();
+		      }
 		    private:
 		      SmartArcSet& _arcset;
 		    };
 		    NodesImpl _nodes;
 		  public:
 		    /// \brief Constructor of the ArcSet.
 		    ///
 		    /// Constructor of the ArcSet.
 		    SmartArcSet(const GR& graph) : _nodes(graph, *this) {
 		      Parent::initalize(graph, _nodes);
+		    }
 		    /// \brief Add a new arc to the digraph.
 		    ///
 		    /// Add a new arc to the digraph with source node \c s
 		    /// and target node \c t.
 		    /// \return The new arc.
 		    Arc addArc(const Node& s, const Node& t) {
 		      return Parent::addArc(s, t);
+		    }
 		    /// \brief Validity check
 		    ///
 		    /// This functions gives back false if the ArcSet is
 		    /// invalidated. It occurs when a node in the underlying graph is
 		    /// erased and it is not isolated in the ArcSet.
 		    bool valid() const {
 		      return _nodes.attached();
+		    }
 		  };
 		  template <typename GR>
 		  class SmartEdgeSetBase {
 		  public:
 		    typedef GR Graph;
 		    typedef typename GR::Node Node;
 		    typedef typename GR::NodeIt NodeIt;
 		  protected:
 		    struct NodeT {
 		      int first_out;
 		      NodeT() : first_out(-1) {}
 		    };
 		    typedef typename ItemSetTraits<GR, Node>::
 		    template Map<NodeT>::Type NodesImplBase;
 		    NodesImplBase* _nodes;
 		    struct ArcT {
 		      Node target;
 		      int next_out;
 		      ArcT() {}
 		    };
 		    std::vector<ArcT> arcs;
 		    const GR* _graph;
 		    void initalize(const GR& graph, NodesImplBase& nodes) {
 		      _graph = &graph;
 		      _nodes = &nodes;
+		    }
 		  public:
 		    class Edge {
 		      friend class SmartEdgeSetBase;
 		    protected:
 		      int id;
 		      explicit Edge(int _id) { id = _id;}
 		    public:
 		      Edge() {}
 		      Edge (Invalid) { id = -1; }
 		      bool operator==(const Edge& arc) const {return id == arc.id;}
 		      bool operator!=(const Edge& arc) const {return id != arc.id;}
 		      bool operator<(const Edge& arc) const {return id < arc.id;}
 		    };
 		    class Arc {
 		      friend class SmartEdgeSetBase;
 		    protected:
 		      Arc(int _id) : id(_id) {}
 		      int id;
 		    public:
 		      operator Edge() const { return edgeFromId(id / 2); }
 		      Arc() {}
 		      Arc(Invalid) : id(-1) {}
 		      bool operator==(const Arc& arc) const { return id == arc.id; }
 		      bool operator!=(const Arc& arc) const { return id != arc.id; }
 		      bool operator<(const Arc& arc) const { return id < arc.id; }
 		    };
 		    SmartEdgeSetBase() {}
 		    Edge addEdge(const Node& u, const Node& v) {
 		      int n = arcs.size();
 		      arcs.push_back(ArcT());
 		      arcs.push_back(ArcT());
 		      arcs[n].target = u;
 		      arcs[n | 1].target = v;
 		      arcs[n].next_out = (*_nodes)[v].first_out;
 		      (*_nodes)[v].first_out = n;
 		      arcs[n | 1].next_out = (*_nodes)[u].first_out;
 		      (*_nodes)[u].first_out = (n | 1);
 		      return Edge(n / 2);
+		    }
 		    void clear() {
 		      Node node;
 		      for (first(node); node != INVALID; next(node)) {
 		        (*_nodes)[node].first_out = -1;
+		      }
 		      arcs.clear();
+		    }
 		    void first(Node& node) const {
 		      _graph->first(node);
+		    }
 		    void next(Node& node) const {
 		      _graph->next(node);
+		    }
 		    void first(Arc& arc) const {
 		      arc.id = arcs.size() - 1;
+		    }
 		    void next(Arc& arc) const {
 		      --arc.id;
+		    }
 		    void first(Edge& arc) const {
 		      arc.id = arcs.size() / 2 - 1;
+		    }
 		    void next(Edge& arc) const {
 		      --arc.id;
+		    }
 		    void firstOut(Arc& arc, const Node& node) const {
 		      arc.id = (*_nodes)[node].first_out;
+		    }
 		    void nextOut(Arc& arc) const {
 		      arc.id = arcs[arc.id].next_out;
+		    }
 		    void firstIn(Arc& arc, const Node& node) const {
 		      arc.id = (((*_nodes)[node].first_out) ^ 1);
 		      if (arc.id == -2) arc.id = -1;
+		    }
 		    void nextIn(Arc& arc) const {
 		      arc.id = ((arcs[arc.id ^ 1].next_out) ^ 1);
 		      if (arc.id == -2) arc.id = -1;
+		    }
 		    void firstInc(Edge &arc, bool& dir, const Node& node) const {
 		      int de = (*_nodes)[node].first_out;
 		      if (de != -1 ) {
 		        arc.id = de / 2;
 		        dir = ((de & 1) == 1);
 		      } else {
 		        arc.id = -1;
 		        dir = true;
+		      }
+		    }
 		    void nextInc(Edge &arc, bool& dir) const {
 		      int de = (arcs[(arc.id * 2) | (dir ? 1 : 0)].next_out);
 		      if (de != -1 ) {
 		        arc.id = de / 2;
 		        dir = ((de & 1) == 1);
 		      } else {
 		        arc.id = -1;
 		        dir = true;
+		      }
+		    }
 		    static bool direction(Arc arc) {
 		      return (arc.id & 1) == 1;
+		    }
 		    static Arc direct(Edge edge, bool dir) {
 		      return Arc(edge.id * 2 + (dir ? 1 : 0));
+		    }
 		    int id(Node node) const { return _graph->id(node); }
 		    static int id(Arc arc) { return arc.id; }
 		    static int id(Edge arc) { return arc.id; }
 		    Node nodeFromId(int id) const { return _graph->nodeFromId(id); }
 		    static Arc arcFromId(int id) { return Arc(id); }
 		    static Edge edgeFromId(int id) { return Edge(id);}
 		    int maxNodeId() const { return _graph->maxNodeId(); };
 		    int maxArcId() const { return arcs.size() - 1; }
 		    int maxEdgeId() const { return arcs.size() / 2 - 1; }
 		    Node source(Arc e) const { return arcs[e.id ^ 1].target; }
 		    Node target(Arc e) const { return arcs[e.id].target; }
 		    Node u(Edge e) const { return arcs[2 * e.id].target; }
 		    Node v(Edge e) const { return arcs[2 * e.id + 1].target; }
 		    typedef typename ItemSetTraits<GR, Node>::ItemNotifier NodeNotifier;
 		    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) { }
 		      NodeMap& operator=(const NodeMap& cmap) {
 		        return operator=<NodeMap>(cmap);
+		      }
 		      template <typename CMap>
 		      NodeMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		  };
 		  /// \ingroup semi_adaptors
 		  ///
 		  /// \brief Graph using a node set of another digraph or graph and an
 		  /// own edge set.
 		  ///
 		  /// This structure can be used to establish another graph over a
 		  /// node set of an existing one. This class uses the same Node type
 		  /// as the underlying graph, and each valid node of the original
 		  /// graph is valid in this arc set, therefore the node objects of
 		  /// the original graph can be used directly with this class. The
 		  /// node handling functions (id handling, observing, and iterators)
 		  /// works equivalently as in the original graph.
 		  ///
 		  /// \param GR The type of the graph which shares its node set
 		  /// with this class. Its interface must conform to the
 		  /// \ref concepts::Digraph "Digraph" or \ref concepts::Graph "Graph"
 		  ///  concept.
 		  ///
 		  /// This implementation is slightly faster than the \c ListEdgeSet,
 		  /// because it uses continuous storage for edges and it uses just
 		  /// single-linked lists for enumerate incident edges. Therefore the
 		  /// edges cannot be erased from the edge sets.
 		  ///
 		  /// \warning If a node is erased from the underlying graph and this
 		  /// node is incident to one edge in the edge set, then the edge set
 		  /// is invalidated, and it cannot be used anymore. The validity can
 		  /// 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) {
 		        return;
+		      }
 		      throw typename NodesImplBase::Notifier::ImmediateDetach();
+		    }
 		    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 {
 		        return Parent::attached();
+		      }
 		    protected:
 		      virtual void erase(const Node& node) {
 		        try {
 		          _arcset.eraseNode(node);
 		          Parent::erase(node);
 		        } catch (const typename NodesImplBase::Notifier::ImmediateDetach&) {
 		          Parent::clear();
 		          throw;
+		        }
+		      }
 		      virtual void erase(const std::vector<Node>& nodes) {
 		        try {
 		          for (int i = 0; i < int(nodes.size()); ++i) {
 		            _arcset.eraseNode(nodes[i]);
+		          }
 		          Parent::erase(nodes);
 		        } catch (const typename NodesImplBase::Notifier::ImmediateDetach&) {
 		          Parent::clear();
 		          throw;
+		        }
+		      }
 		      virtual void clear() {
 		        _arcset.clearNodes();
 		        Parent::clear();
+		      }
 		    private:
 		      SmartEdgeSet& _arcset;
 		    };
 		    NodesImpl _nodes;
 		  public:
 		    /// \brief Constructor of the EdgeSet.
 		    ///
 		    /// Constructor of the EdgeSet.
 		    SmartEdgeSet(const GR& graph) : _nodes(graph, *this) {
 		      Parent::initalize(graph, _nodes);
+		    }
 		    /// \brief Add a new edge to the graph.
 		    ///
 		    /// Add a new edge to the graph with node \c u
 		    /// and node \c v endpoints.
 		    /// \return The new edge.
 		    Edge addEdge(const Node& u, const Node& v) {
 		      return Parent::addEdge(u, v);
+		    }
 		    /// \brief Validity check
 		    ///
 		    /// This functions gives back false if the EdgeSet is
 		    /// invalidated. It occurs when a node in the underlying graph is
 		    /// erased and it is not isolated in the EdgeSet.
 		    bool valid() const {
 		      return _nodes.attached();
+		    }
 		  };
+		}
 		#endif

lemon/full_graph.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2009
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_FULL_GRAPH_H
 		#define LEMON_FULL_GRAPH_H
 		#include <lemon/core.h>
 		#include <lemon/bits/graph_extender.h>
 		///\ingroup graphs
 		///\file
 		///\brief FullGraph and FullDigraph classes.
 		namespace lemon {
 		  class FullDigraphBase {
 		  public:
-		    typedef FullDigraphBase Graph;
+		    typedef FullDigraphBase Digraph;
 		    class Node;
 		    class Arc;
 		  protected:
 		    int _node_num;
 		    int _arc_num;
 		    FullDigraphBase() {}
 		    void construct(int n) { _node_num = n; _arc_num = n * n; }
 		  public:
 		    typedef True NodeNumTag;
 		    typedef True ArcNumTag;
 		    Node operator()(int ix) const { return Node(ix); }
 		    int index(const Node& node) const { return node._id; }
 		    Arc arc(const Node& s, const Node& t) const {
 		      return Arc(s._id * _node_num + t._id);
+		    }
 		    int nodeNum() const { return _node_num; }
 		    int arcNum() const { return _arc_num; }
 		    int maxNodeId() const { return _node_num - 1; }
 		    int maxArcId() const { return _arc_num - 1; }
 		    Node source(Arc arc) const { return arc._id / _node_num; }
 		    Node target(Arc arc) const { return arc._id % _node_num; }
 		    static int id(Node node) { return node._id; }
 		    static int id(Arc arc) { return arc._id; }
 		    static Node nodeFromId(int id) { return Node(id);}
 		    static Arc arcFromId(int id) { return Arc(id);}
 		    typedef True FindArcTag;
 		    Arc findArc(Node s, Node t, Arc prev = INVALID) const {
 		      return prev == INVALID ? arc(s, t) : INVALID;
+		    }
 		    class Node {
 		      friend class FullDigraphBase;
 		    protected:
 		      int _id;
 		      Node(int id) : _id(id) {}
 		    public:
 		      Node() {}
 		      Node (Invalid) : _id(-1) {}
 		      bool operator==(const Node node) const {return _id == node._id;}
 		      bool operator!=(const Node node) const {return _id != node._id;}
 		      bool operator<(const Node node) const {return _id < node._id;}
 		    };
 		    class Arc {
 		      friend class FullDigraphBase;
 		    protected:
 		      int _id;  // _node_num * source + target;
 		      Arc(int id) : _id(id) {}
 		    public:
 		      Arc() { }
 		      Arc (Invalid) { _id = -1; }
 		      bool operator==(const Arc arc) const {return _id == arc._id;}
 		      bool operator!=(const Arc arc) const {return _id != arc._id;}
 		      bool operator<(const Arc arc) const {return _id < arc._id;}
 		    };
 		    void first(Node& node) const {
 		      node._id = _node_num - 1;
+		    }
 		    static void next(Node& node) {
 		      --node._id;
+		    }
 		    void first(Arc& arc) const {
 		      arc._id = _arc_num - 1;
+		    }
 		    static void next(Arc& arc) {
 		      --arc._id;
+		    }
 		    void firstOut(Arc& arc, const Node& node) const {
 		      arc._id = (node._id + 1) * _node_num - 1;
+		    }
 		    void nextOut(Arc& arc) const {
 		      if (arc._id % _node_num == 0) arc._id = 0;
 		      --arc._id;
+		    }
 		    void firstIn(Arc& arc, const Node& node) const {
 		      arc._id = _arc_num + node._id - _node_num;
+		    }
 		    void nextIn(Arc& arc) const {
 		      arc._id -= _node_num;
 		      if (arc._id < 0) arc._id = -1;
+		    }
 		  };
 		  typedef DigraphExtender<FullDigraphBase> ExtendedFullDigraphBase;
 		  /// \ingroup graphs
 		  ///
 		  /// \brief A full digraph class.
 		  ///
 		  /// This is a simple and fast directed full graph implementation.
 		  /// From each node go arcs to each node (including the source node),
 		  /// therefore the number of the arcs in the digraph is the square of
 		  /// the node number. This digraph type is completely static, so you
 		  /// can neither add nor delete either arcs or nodes, and it needs
 		  /// constant space in memory.
 		  ///
 		  /// This class fully conforms to the \ref concepts::Digraph
 		  /// "Digraph concept".
 		  ///
 		  /// The \c FullDigraph and \c FullGraph classes are very similar,
 		  /// but there are two differences. While this class conforms only
 		  /// to the \ref concepts::Digraph "Digraph" concept, the \c FullGraph
 		  /// 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.
 		    /// \param n The number of the nodes.
 		    FullDigraph(int n) { construct(n); }
 		    /// \brief Resizes the digraph
 		    ///
 		    /// Resizes the digraph. The function will fully destroy and
 		    /// rebuild the digraph. This cause that the maps of the digraph will
 		    /// reallocated automatically and the previous values will be lost.
 		    void resize(int n) {
 		      Parent::notifier(Arc()).clear();
 		      Parent::notifier(Node()).clear();
 		      construct(n);
 		      Parent::notifier(Node()).build();
 		      Parent::notifier(Arc()).build();
+		    }
 		    /// \brief Returns the node with the given index.
 		    ///
 		    /// Returns the node with the given index. Since it is a static
 		    /// digraph its nodes can be indexed with integers from the range
 		    /// <tt>[0..nodeNum()-1]</tt>.
 		    /// \sa index()
 		    Node operator()(int ix) const { return Parent::operator()(ix); }
 		    /// \brief Returns the index of the given node.
 		    ///
 		    /// Returns the index of the given node. Since it is a static
 		    /// digraph its nodes can be indexed with integers from the range
 		    /// <tt>[0..nodeNum()-1]</tt>.
 		    /// \sa operator()
 		    int index(const Node& node) const { return Parent::index(node); }
 		    /// \brief Returns the arc connecting the given nodes.
 		    ///
 		    /// Returns the arc connecting the given nodes.
 		    Arc arc(const Node& u, const Node& v) const {
 		      return Parent::arc(u, v);
+		    }
 		    /// \brief Number of nodes.
 		    int nodeNum() const { return Parent::nodeNum(); }
 		    /// \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;
 		      int v = e % _node_num;
 		      return u < v ? u : _node_num - 2 - u;
+		    }
 		    int _vid(int e) const {
 		      int u = e / _node_num;
 		      int v = e % _node_num;
 		      return u < v ? v : _node_num - 1 - v;
+		    }
 		    void _uvid(int e, int& u, int& v) const {
 		      u = e / _node_num;
 		      v = e % _node_num;
 		      if  (u >= v) {
 		        u = _node_num - 2 - u;
 		        v = _node_num - 1 - v;
+		      }
+		    }
 		    void _stid(int a, int& s, int& t) const {
 		      if ((a & 1) == 1) {
 		        _uvid(a >> 1, s, t);
 		      } else {
 		        _uvid(a >> 1, t, s);
+		      }
+		    }
 		    int _eid(int u, int v) const {
 		      if (u < (_node_num - 1) / 2) {
 		        return u * _node_num + v;
 		      } else {
 		        return (_node_num - 1 - u) * _node_num - v - 1;
+		      }
+		    }
 		  public:
 		    Node operator()(int ix) const { return Node(ix); }
 		    int index(const Node& node) const { return node._id; }
 		    Edge edge(const Node& u, const Node& v) const {
 		      if (u._id < v._id) {
 		        return Edge(_eid(u._id, v._id));
 		      } else if (u._id != v._id) {
 		        return Edge(_eid(v._id, u._id));
 		      } else {
 		        return INVALID;
+		      }
+		    }
 		    Arc arc(const Node& s, const Node& t) const {
 		      if (s._id < t._id) {
 		        return Arc((_eid(s._id, t._id) << 1) | 1);
 		      } else if (s._id != t._id) {
 		        return Arc(_eid(t._id, s._id) << 1);
 		      } else {
 		        return INVALID;
+		      }
+		    }
 		    typedef True NodeNumTag;
 		    typedef True ArcNumTag;
 		    typedef True EdgeNumTag;
 		    int nodeNum() const { return _node_num; }
 		    int arcNum() const { return 2 * _edge_num; }
 		    int edgeNum() const { return _edge_num; }
 		    static int id(Node node) { return node._id; }
 		    static int id(Arc arc) { return arc._id; }
 		    static int id(Edge edge) { return edge._id; }
 		    int maxNodeId() const { return _node_num-1; }
 		    int maxArcId() const { return 2 * _edge_num-1; }
 		    int maxEdgeId() const { return _edge_num-1; }
 		    static Node nodeFromId(int id) { return Node(id);}
 		    static Arc arcFromId(int id) { return Arc(id);}
 		    static Edge edgeFromId(int id) { return Edge(id);}
 		    Node u(Edge edge) const {
 		      return Node(_uid(edge._id));
+		    }
 		    Node v(Edge edge) const {
 		      return Node(_vid(edge._id));
+		    }
 		    Node source(Arc arc) const {
 		      return Node((arc._id & 1) == 1 ?
 		                  _uid(arc._id >> 1) : _vid(arc._id >> 1));
+		    }
 		    Node target(Arc arc) const {
 		      return Node((arc._id & 1) == 1 ?
 		                  _vid(arc._id >> 1) : _uid(arc._id >> 1));
+		    }
 		    typedef True FindEdgeTag;
 		    typedef True FindArcTag;
 		    Edge findEdge(Node u, Node v, Edge prev = INVALID) const {
 		      return prev != INVALID ? INVALID : edge(u, v);
+		    }
 		    Arc findArc(Node s, Node t, Arc prev = INVALID) const {
 		      return prev != INVALID ? INVALID : arc(s, t);
+		    }
 		    class Node {
 		      friend class FullGraphBase;
 		    protected:
 		      int _id;
 		      Node(int id) : _id(id) {}
 		    public:
 		      Node() {}
 		      Node (Invalid) { _id = -1; }
 		      bool operator==(const Node node) const {return _id == node._id;}
 		      bool operator!=(const Node node) const {return _id != node._id;}
 		      bool operator<(const Node node) const {return _id < node._id;}
 		    };
 		    class Edge {
 		      friend class FullGraphBase;
 		      friend class Arc;
 		    protected:
 		      int _id;
 		      Edge(int id) : _id(id) {}
 		    public:
 		      Edge() { }
 		      Edge (Invalid) { _id = -1; }
 		      bool operator==(const Edge edge) const {return _id == edge._id;}
 		      bool operator!=(const Edge edge) const {return _id != edge._id;}
 		      bool operator<(const Edge edge) const {return _id < edge._id;}
 		    };
 		    class Arc {
 		      friend class FullGraphBase;
 		    protected:
 		      int _id;
 		      Arc(int id) : _id(id) {}
 		    public:
 		      Arc() { }
 		      Arc (Invalid) { _id = -1; }
 		      operator Edge() const { return Edge(_id != -1 ? (_id >> 1) : -1); }
 		      bool operator==(const Arc arc) const {return _id == arc._id;}
 		      bool operator!=(const Arc arc) const {return _id != arc._id;}
 		      bool operator<(const Arc arc) const {return _id < arc._id;}
 		    };
 		    static bool direction(Arc arc) {
 		      return (arc._id & 1) == 1;
+		    }
 		    static Arc direct(Edge edge, bool dir) {
 		      return Arc((edge._id << 1) | (dir ? 1 : 0));
+		    }
 		    void first(Node& node) const {
 		      node._id = _node_num - 1;
+		    }
 		    static void next(Node& node) {
 		      --node._id;
+		    }
 		    void first(Arc& arc) const {
 		      arc._id = (_edge_num << 1) - 1;
+		    }
 		    static void next(Arc& arc) {
 		      --arc._id;
+		    }
 		    void first(Edge& edge) const {
 		      edge._id = _edge_num - 1;
+		    }
 		    static void next(Edge& edge) {
 		      --edge._id;
+		    }
 		    void firstOut(Arc& arc, const Node& node) const {
 		      int s = node._id, t = _node_num - 1;
 		      if (s < t) {
 		        arc._id = (_eid(s, t) << 1) | 1;
 		      } else {
 		        --t;
 		        arc._id = (t != -1 ? (_eid(t, s) << 1) : -1);
+		      }
+		    }
 		    void nextOut(Arc& arc) const {
 		      int s, t;
 		      _stid(arc._id, s, t);
 		      --t;
 		      if (s < t) {
 		        arc._id = (_eid(s, t) << 1) | 1;
 		      } else {
 		        if (s == t) --t;
 		        arc._id = (t != -1 ? (_eid(t, s) << 1) : -1);
+		      }
+		    }
 		    void firstIn(Arc& arc, const Node& node) const {
 		      int s = _node_num - 1, t = node._id;
 		      if (s > t) {
 		        arc._id = (_eid(t, s) << 1);
 		      } else {
 		        --s;
 		        arc._id = (s != -1 ? (_eid(s, t) << 1) | 1 : -1);
+		      }
+		    }
 		    void nextIn(Arc& arc) const {
 		      int s, t;
 		      _stid(arc._id, s, t);
 		      --s;
 		      if (s > t) {
 		        arc._id = (_eid(t, s) << 1);
 		      } else {
 		        if (s == t) --s;
 		        arc._id = (s != -1 ? (_eid(s, t) << 1) | 1 : -1);
+		      }
+		    }
 		    void firstInc(Edge& edge, bool& dir, const Node& node) const {
 		      int u = node._id, v = _node_num - 1;
 		      if (u < v) {
 		        edge._id = _eid(u, v);
 		        dir = true;
 		      } else {
 		        --v;
 		        edge._id = (v != -1 ? _eid(v, u) : -1);
 		        dir = false;
+		      }
+		    }
 		    void nextInc(Edge& edge, bool& dir) const {
 		      int u, v;
 		      if (dir) {
 		        _uvid(edge._id, u, v);
 		        --v;
 		        if (u < v) {
 		          edge._id = _eid(u, v);
 		        } else {
 		          --v;
 		          edge._id = (v != -1 ? _eid(v, u) : -1);
 		          dir = false;
+		        }
 		      } else {
 		        _uvid(edge._id, v, u);
 		        --v;
 		        edge._id = (v != -1 ? _eid(v, u) : -1);
+		      }
+		    }
 		  };
 		  typedef GraphExtender<FullGraphBase> ExtendedFullGraphBase;
 		  /// \ingroup graphs
 		  ///
 		  /// \brief An undirected full graph class.
 		  ///
 		  /// This is a simple and fast undirected full graph
 		  /// implementation. From each node go edge to each other node,
 		  /// therefore the number of edges in the graph is \f$n(n-1)/2\f$.
 		  /// This graph type is completely static, so you can neither
 		  /// add nor delete either edges or nodes, and it needs constant
 		  /// space in memory.
 		  ///
 		  /// This class fully conforms to the \ref concepts::Graph "Graph concept".
 		  ///
 		  /// The \c FullGraph and \c FullDigraph classes are very similar,
 		  /// but there are two differences. While the \c FullDigraph class
 		  /// conforms only to the \ref concepts::Digraph "Digraph" concept,
 		  /// 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.
 		    /// \param n The number of the nodes.
 		    FullGraph(int n) { construct(n); }
 		    /// \brief Resizes the graph
 		    ///
 		    /// Resizes the graph. The function will fully destroy and
 		    /// rebuild the graph. This cause that the maps of the graph will
 		    /// reallocated automatically and the previous values will be lost.
 		    void resize(int n) {
 		      Parent::notifier(Arc()).clear();
 		      Parent::notifier(Edge()).clear();
 		      Parent::notifier(Node()).clear();
 		      construct(n);
 		      Parent::notifier(Node()).build();
 		      Parent::notifier(Edge()).build();
 		      Parent::notifier(Arc()).build();
+		    }
 		    /// \brief Returns the node with the given index.
 		    ///
 		    /// Returns the node with the given index. Since it is a static
 		    /// graph its nodes can be indexed with integers from the range
 		    /// <tt>[0..nodeNum()-1]</tt>.
 		    /// \sa index()
 		    Node operator()(int ix) const { return Parent::operator()(ix); }
 		    /// \brief Returns the index of the given node.
 		    ///
 		    /// Returns the index of the given node. Since it is a static
 		    /// graph its nodes can be indexed with integers from the range
 		    /// <tt>[0..nodeNum()-1]</tt>.
 		    /// \sa operator()
 		    int index(const Node& node) const { return Parent::index(node); }
 		    /// \brief Returns the arc connecting the given nodes.
 		    ///
 		    /// Returns the arc connecting the given nodes.
 		    Arc arc(const Node& s, const Node& t) const {
 		      return Parent::arc(s, t);
+		    }
 		    /// \brief Returns the edge connects the given nodes.
 		    ///
 		    /// Returns the edge connects the given nodes.
 		    Edge edge(const Node& u, const Node& v) const {
 		      return Parent::edge(u, v);
+		    }
 		    /// \brief Number of nodes.
 		    int nodeNum() const { return Parent::nodeNum(); }
 		    /// \brief Number of arcs.
 		    int arcNum() const { return Parent::arcNum(); }
 		    /// \brief Number of edges.
 		    int edgeNum() const { return Parent::edgeNum(); }
 		  };
 		} //namespace lemon
 		#endif //LEMON_FULL_GRAPH_H

lemon/graph_to_eps.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2009
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_GRAPH_TO_EPS_H
 		#define LEMON_GRAPH_TO_EPS_H
 		#include<iostream>
 		#include<fstream>
 		#include<sstream>
 		#include<algorithm>
 		#include<vector>
 		#ifndef WIN32
 		#include<sys/time.h>
 		#include<ctime>
 		#else
 		#include<lemon/bits/windows.h>
 		#endif
 		#include<lemon/math.h>
 		#include<lemon/core.h>
 		#include<lemon/dim2.h>
 		#include<lemon/maps.h>
 		#include<lemon/color.h>
 		#include<lemon/bits/bezier.h>
 		#include<lemon/error.h>
 		///\ingroup eps_io
 		///\file
 		///\brief A well configurable tool for visualizing graphs
 		namespace lemon {
 		  namespace _graph_to_eps_bits {
 		    template<class MT>
 		    class _NegY {
 		    public:
 		      typedef typename MT::Key Key;
 		      typedef typename MT::Value Value;
 		      const MT &map;
 		      int yscale;
 		      _NegY(const MT &m,bool b) : map(m), yscale(1-b*2) {}
 		      Value operator[](Key n) { return Value(map[n].x,map[n].y*yscale);}
 		    };
+		  }
 		///Default traits class of GraphToEps
 		///Default traits class of \ref GraphToEps.
 		///
 		///\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;
 		  const Graph &g;
 		  std::ostream& os;
 		  typedef ConstMap<typename Graph::Node,dim2::Point<double> > CoordsMapType;
 		  CoordsMapType _coords;
 		  ConstMap<typename Graph::Node,double > _nodeSizes;
 		  ConstMap<typename Graph::Node,int > _nodeShapes;
 		  ConstMap<typename Graph::Node,Color > _nodeColors;
 		  ConstMap<typename Graph::Arc,Color > _arcColors;
 		  ConstMap<typename Graph::Arc,double > _arcWidths;
 		  double _arcWidthScale;
 		  double _nodeScale;
 		  double _xBorder, _yBorder;
 		  double _scale;
 		  double _nodeBorderQuotient;
 		  bool _drawArrows;
 		  double _arrowLength, _arrowWidth;
 		  bool _showNodes, _showArcs;
 		  bool _enableParallel;
 		  double _parArcDist;
 		  bool _showNodeText;
 		  ConstMap<typename Graph::Node,bool > _nodeTexts;
 		  double _nodeTextSize;
 		  bool _showNodePsText;
 		  ConstMap<typename Graph::Node,bool > _nodePsTexts;
 		  char *_nodePsTextsPreamble;
 		  bool _undirected;
 		  bool _pleaseRemoveOsStream;
 		  bool _scaleToA4;
 		  std::string _title;
 		  std::string _copyright;
 		  enum NodeTextColorType
 		    { DIST_COL=0, DIST_BW=1, CUST_COL=2, SAME_COL=3 } _nodeTextColorType;
 		  ConstMap<typename Graph::Node,Color > _nodeTextColors;
 		  bool _autoNodeScale;
 		  bool _autoArcWidthScale;
 		  bool _absoluteNodeSizes;
 		  bool _absoluteArcWidths;
 		  bool _negY;
 		  bool _preScale;
 		  ///Constructor
 		  ///Constructor
 		  ///\param gr  Reference to the graph to be printed.
 		  ///\param ost Reference to the output stream.
 		  ///By default it is <tt>std::cout</tt>.
 		  ///\param pros If it is \c true, then the \c ostream referenced by \c os
 		  ///will be explicitly deallocated by the destructor.
 		  DefaultGraphToEpsTraits(const GR &gr, std::ostream& ost = std::cout,
 		                          bool pros = false) :
 		    g(gr), os(ost),
 		    _coords(dim2::Point<double>(1,1)), _nodeSizes(1), _nodeShapes(0),
 		    _nodeColors(WHITE), _arcColors(BLACK),
 		    _arcWidths(1.0), _arcWidthScale(0.003),
 		    _nodeScale(.01), _xBorder(10), _yBorder(10), _scale(1.0),
 		    _nodeBorderQuotient(.1),
 		    _drawArrows(false), _arrowLength(1), _arrowWidth(0.3),
 		    _showNodes(true), _showArcs(true),
 		    _enableParallel(false), _parArcDist(1),
 		    _showNodeText(false), _nodeTexts(false), _nodeTextSize(1),
 		    _showNodePsText(false), _nodePsTexts(false), _nodePsTextsPreamble(0),
 		    _undirected(lemon::UndirectedTagIndicator<GR>::value),
 		    _pleaseRemoveOsStream(pros), _scaleToA4(false),
 		    _nodeTextColorType(SAME_COL), _nodeTextColors(BLACK),
 		    _autoNodeScale(false),
 		    _autoArcWidthScale(false),
 		    _absoluteNodeSizes(false),
 		    _absoluteArcWidths(false),
 		    _negY(false),
 		    _preScale(true)
 		  {}
 		};
 		///Auxiliary class to implement the named parameters of \ref graphToEps()
 		///Auxiliary class to implement the named parameters of \ref graphToEps().
 		///
 		///For detailed examples see the \ref graph_to_eps_demo.cc demo file.
 		template<class T> class GraphToEps : public T
+		{
 		  // Can't believe it is required by the C++ standard
 		  using T::g;
 		  using T::os;
 		  using T::_coords;
 		  using T::_nodeSizes;
 		  using T::_nodeShapes;
 		  using T::_nodeColors;
 		  using T::_arcColors;
 		  using T::_arcWidths;
 		  using T::_arcWidthScale;
 		  using T::_nodeScale;
 		  using T::_xBorder;
 		  using T::_yBorder;
 		  using T::_scale;
 		  using T::_nodeBorderQuotient;
 		  using T::_drawArrows;
 		  using T::_arrowLength;
 		  using T::_arrowWidth;
 		  using T::_showNodes;
 		  using T::_showArcs;
 		  using T::_enableParallel;
 		  using T::_parArcDist;
 		  using T::_showNodeText;
 		  using T::_nodeTexts;
 		  using T::_nodeTextSize;
 		  using T::_showNodePsText;
 		  using T::_nodePsTexts;
 		  using T::_nodePsTextsPreamble;
 		  using T::_undirected;
 		  using T::_pleaseRemoveOsStream;
 		  using T::_scaleToA4;
 		  using T::_title;
 		  using T::_copyright;
 		  using T::NodeTextColorType;
 		  using T::CUST_COL;
 		  using T::DIST_COL;
 		  using T::DIST_BW;
 		  using T::_nodeTextColorType;
 		  using T::_nodeTextColors;
 		  using T::_autoNodeScale;
 		  using T::_autoArcWidthScale;
 		  using T::_absoluteNodeSizes;
 		  using T::_absoluteArcWidths;
 		  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;
 		  static const int INTERPOL_PREC;
 		  static const double A4HEIGHT;
 		  static const double A4WIDTH;
 		  static const double A4BORDER;
 		  bool dontPrint;
 		public:
 		  ///Node shapes
 		  ///Node shapes.
 		  ///
 		  enum NodeShapes {
 		    /// = 0
 		    ///\image html nodeshape_0.png
 		    ///\image latex nodeshape_0.eps "CIRCLE shape (0)" width=2cm
 		    CIRCLE=0,
 		    /// = 1
 		    ///\image html nodeshape_1.png
 		    ///\image latex nodeshape_1.eps "SQUARE shape (1)" width=2cm
 		    SQUARE=1,
 		    /// = 2
 		    ///\image html nodeshape_2.png
 		    ///\image latex nodeshape_2.eps "DIAMOND shape (2)" width=2cm
 		    DIAMOND=2,
 		    /// = 3
 		    ///\image html nodeshape_3.png
 		    ///\image latex nodeshape_3.eps "MALE shape (3)" width=2cm
 		    MALE=3,
 		    /// = 4
 		    ///\image html nodeshape_4.png
 		    ///\image latex nodeshape_4.eps "FEMALE shape (4)" width=2cm
 		    FEMALE=4
 		  };
 		private:
 		  class arcLess {
 		    const Graph &g;
 		  public:
 		    arcLess(const Graph &_g) : g(_g) {}
 		    bool operator()(Arc a,Arc b) const
+		    {
 		      Node ai=std::min(g.source(a),g.target(a));
 		      Node aa=std::max(g.source(a),g.target(a));
 		      Node bi=std::min(g.source(b),g.target(b));
 		      Node ba=std::max(g.source(b),g.target(b));
 		      return ai<bi ||
 		        (ai==bi && (aa < ba ||
 		                    (aa==ba && ai==g.source(a) && bi==g.target(b))));
+		    }
 		  };
 		  bool isParallel(Arc e,Arc f) const
+		  {
 		    return (g.source(e)==g.source(f)&&
 		            g.target(e)==g.target(f)) ||
 		      (g.source(e)==g.target(f)&&
 		       g.target(e)==g.source(f));
+		  }
 		  template<class TT>
 		  static std::string psOut(const dim2::Point<TT> &p)
+		    {
 		      std::ostringstream os;
 		      os << p.x << ' ' << p.y;
 		      return os.str();
+		    }
 		  static std::string psOut(const Color &c)
+		    {
 		      std::ostringstream os;
 		      os << c.red() << ' ' << c.green() << ' ' << c.blue();
 		      return os.str();
+		    }
 		public:
 		  GraphToEps(const T &t) : T(t), dontPrint(false) {};
 		  template<class X> struct CoordsTraits : public T {
 		  typedef X CoordsMapType;
 		    const X &_coords;
 		    CoordsTraits(const T &t,const X &x) : T(t), _coords(x) {}
 		  };
 		  ///Sets the map of the node coordinates
 		  ///Sets the map of the node coordinates.
 		  ///\param x must be a node map with \ref dim2::Point "dim2::Point<double>" or
 		  ///\ref dim2::Point "dim2::Point<int>" values.
 		  template<class X> GraphToEps<CoordsTraits<X> > coords(const X &x) {
 		    dontPrint=true;
 		    return GraphToEps<CoordsTraits<X> >(CoordsTraits<X>(*this,x));
+		  }
 		  template<class X> struct NodeSizesTraits : public T {
 		    const X &_nodeSizes;
 		    NodeSizesTraits(const T &t,const X &x) : T(t), _nodeSizes(x) {}
 		  };
 		  ///Sets the map of the node sizes
 		  ///Sets the map of the node sizes.
 		  ///\param x must be a node map with \c double (or convertible) values.
 		  template<class X> GraphToEps<NodeSizesTraits<X> > nodeSizes(const X &x)
+		  {
 		    dontPrint=true;
 		    return GraphToEps<NodeSizesTraits<X> >(NodeSizesTraits<X>(*this,x));
+		  }
 		  template<class X> struct NodeShapesTraits : public T {
 		    const X &_nodeShapes;
 		    NodeShapesTraits(const T &t,const X &x) : T(t), _nodeShapes(x) {}
 		  };
 		  ///Sets the map of the node shapes
 		  ///Sets the map of the node shapes.
 		  ///The available shape values
 		  ///can be found in \ref NodeShapes "enum NodeShapes".
 		  ///\param x must be a node map with \c int (or convertible) values.
 		  ///\sa NodeShapes
 		  template<class X> GraphToEps<NodeShapesTraits<X> > nodeShapes(const X &x)
+		  {
 		    dontPrint=true;
 		    return GraphToEps<NodeShapesTraits<X> >(NodeShapesTraits<X>(*this,x));
+		  }
 		  template<class X> struct NodeTextsTraits : public T {
 		    const X &_nodeTexts;
 		    NodeTextsTraits(const T &t,const X &x) : T(t), _nodeTexts(x) {}
 		  };
 		  ///Sets the text printed on the nodes
 		  ///Sets the text printed on the nodes.
 		  ///\param x must be a node map with type that can be pushed to a standard
 		  ///\c ostream.
 		  template<class X> GraphToEps<NodeTextsTraits<X> > nodeTexts(const X &x)
+		  {
 		    dontPrint=true;
 		    _showNodeText=true;
 		    return GraphToEps<NodeTextsTraits<X> >(NodeTextsTraits<X>(*this,x));
+		  }
 		  template<class X> struct NodePsTextsTraits : public T {
 		    const X &_nodePsTexts;
 		    NodePsTextsTraits(const T &t,const X &x) : T(t), _nodePsTexts(x) {}
 		  };
 		  ///Inserts a PostScript block to the nodes
 		  ///With this command it is possible to insert a verbatim PostScript
 		  ///block to the nodes.
 		  ///The PS current point will be moved to the center of the node before
 		  ///the PostScript block inserted.
 		  ///
 		  ///Before and after the block a newline character is inserted so you
 		  ///don't have to bother with the separators.
 		  ///
 		  ///\param x must be a node map with type that can be pushed to a standard
 		  ///\c ostream.
 		  ///
 		  ///\sa nodePsTextsPreamble()
 		  template<class X> GraphToEps<NodePsTextsTraits<X> > nodePsTexts(const X &x)
+		  {
 		    dontPrint=true;
 		    _showNodePsText=true;
 		    return GraphToEps<NodePsTextsTraits<X> >(NodePsTextsTraits<X>(*this,x));
+		  }
 		  template<class X> struct ArcWidthsTraits : public T {
 		    const X &_arcWidths;
 		    ArcWidthsTraits(const T &t,const X &x) : T(t), _arcWidths(x) {}
 		  };
 		  ///Sets the map of the arc widths
 		  ///Sets the map of the arc widths.
 		  ///\param x must be an arc map with \c double (or convertible) values.
 		  template<class X> GraphToEps<ArcWidthsTraits<X> > arcWidths(const X &x)
+		  {
 		    dontPrint=true;
 		    return GraphToEps<ArcWidthsTraits<X> >(ArcWidthsTraits<X>(*this,x));
+		  }
 		  template<class X> struct NodeColorsTraits : public T {
 		    const X &_nodeColors;
 		    NodeColorsTraits(const T &t,const X &x) : T(t), _nodeColors(x) {}
 		  };
 		  ///Sets the map of the node colors
 		  ///Sets the map of the node colors.
 		  ///\param x must be a node map with \ref Color values.
 		  ///
 		  ///\sa Palette
 		  template<class X> GraphToEps<NodeColorsTraits<X> >
 		  nodeColors(const X &x)
+		  {
 		    dontPrint=true;
 		    return GraphToEps<NodeColorsTraits<X> >(NodeColorsTraits<X>(*this,x));
+		  }
 		  template<class X> struct NodeTextColorsTraits : public T {
 		    const X &_nodeTextColors;
 		    NodeTextColorsTraits(const T &t,const X &x) : T(t), _nodeTextColors(x) {}
 		  };
 		  ///Sets the map of the node text colors
 		  ///Sets the map of the node text colors.
 		  ///\param x must be a node map with \ref Color values.
 		  ///
 		  ///\sa Palette
 		  template<class X> GraphToEps<NodeTextColorsTraits<X> >
 		  nodeTextColors(const X &x)
+		  {
 		    dontPrint=true;
 		    _nodeTextColorType=CUST_COL;
 		    return GraphToEps<NodeTextColorsTraits<X> >
 		      (NodeTextColorsTraits<X>(*this,x));
+		  }
 		  template<class X> struct ArcColorsTraits : public T {
 		    const X &_arcColors;
 		    ArcColorsTraits(const T &t,const X &x) : T(t), _arcColors(x) {}
 		  };
 		  ///Sets the map of the arc colors
 		  ///Sets the map of the arc colors.
 		  ///\param x must be an arc map with \ref Color values.
 		  ///
 		  ///\sa Palette
 		  template<class X> GraphToEps<ArcColorsTraits<X> >
 		  arcColors(const X &x)
+		  {
 		    dontPrint=true;
 		    return GraphToEps<ArcColorsTraits<X> >(ArcColorsTraits<X>(*this,x));
+		  }
 		  ///Sets a global scale factor for node sizes
 		  ///Sets a global scale factor for node sizes.
 		  ///
 		  /// If nodeSizes() is not given, this function simply sets the node
 		  /// sizes to \c d.  If nodeSizes() is given, but
 		  /// autoNodeScale() is not, then the node size given by
 		  /// nodeSizes() will be multiplied by the value \c d.
 		  /// If both nodeSizes() and autoNodeScale() are used, then the
 		  /// node sizes will be scaled in such a way that the greatest size will be
 		  /// equal to \c d.
 		  /// \sa nodeSizes()
 		  /// \sa autoNodeScale()
 		  GraphToEps<T> &nodeScale(double d=.01) {_nodeScale=d;return *this;}
 		  ///Turns on/off the automatic node size scaling.
 		  ///Turns on/off the automatic node size scaling.
 		  ///
 		  ///\sa nodeScale()
 		  ///
 		  GraphToEps<T> &autoNodeScale(bool b=true) {
 		    _autoNodeScale=b;return *this;
+		  }
 		  ///Turns on/off the absolutematic node size scaling.
 		  ///Turns on/off the absolutematic node size scaling.
 		  ///

lemon/grid_graph.h

Show inline comments

@@ -246,458 +246,458 @@
 		      arc._id = 2 * _edge_num - 1;
+		    }
 		    static void next(Arc& arc) {
 		      --arc._id;
+		    }
 		    void firstOut(Arc& arc, const Node& node) const {
 		      if (node._id % _width < _width - 1) {
 		        arc._id = (_edge_limit + node._id % _width +
 		                   (node._id / _width) * (_width - 1)) << 1 | 1;
 		        return;
+		      }
 		      if (node._id < _node_num - _width) {
 		        arc._id = node._id << 1 | 1;
 		        return;
+		      }
 		      if (node._id % _width > 0) {
 		        arc._id = (_edge_limit + node._id % _width +
 		                   (node._id / _width) * (_width - 1) - 1) << 1;
 		        return;
+		      }
 		      if (node._id >= _width) {
 		        arc._id = (node._id - _width) << 1;
 		        return;
+		      }
 		      arc._id = -1;
+		    }
 		    void nextOut(Arc& arc) const {
 		      int nid = arc._id >> 1;
 		      if ((arc._id & 1) == 1) {
 		        if (nid >= _edge_limit) {
 		          nid = (nid - _edge_limit) % (_width - 1) +
 		            (nid - _edge_limit) / (_width - 1) * _width;
 		          if (nid < _node_num - _width) {
 		            arc._id = nid << 1 | 1;
 		            return;
+		          }
+		        }
 		        if (nid % _width > 0) {
 		          arc._id = (_edge_limit + nid % _width +
 		                     (nid / _width) * (_width - 1) - 1) << 1;
 		          return;
+		        }
 		        if (nid >= _width) {
 		          arc._id = (nid - _width) << 1;
 		          return;
+		        }
 		      } else {
 		        if (nid >= _edge_limit) {
 		          nid = (nid - _edge_limit) % (_width - 1) +
 		            (nid - _edge_limit) / (_width - 1) * _width + 1;
 		          if (nid >= _width) {
 		            arc._id = (nid - _width) << 1;
 		            return;
+		          }
+		        }
+		      }
 		      arc._id = -1;
+		    }
 		    void firstIn(Arc& arc, const Node& node) const {
 		      if (node._id % _width < _width - 1) {
 		        arc._id = (_edge_limit + node._id % _width +
 		                   (node._id / _width) * (_width - 1)) << 1;
 		        return;
+		      }
 		      if (node._id < _node_num - _width) {
 		        arc._id = node._id << 1;
 		        return;
+		      }
 		      if (node._id % _width > 0) {
 		        arc._id = (_edge_limit + node._id % _width +
 		                   (node._id / _width) * (_width - 1) - 1) << 1 | 1;
 		        return;
+		      }
 		      if (node._id >= _width) {
 		        arc._id = (node._id - _width) << 1 | 1;
 		        return;
+		      }
 		      arc._id = -1;
+		    }
 		    void nextIn(Arc& arc) const {
 		      int nid = arc._id >> 1;
 		      if ((arc._id & 1) == 0) {
 		        if (nid >= _edge_limit) {
 		          nid = (nid - _edge_limit) % (_width - 1) +
 		            (nid - _edge_limit) / (_width - 1) * _width;
 		          if (nid < _node_num - _width) {
 		            arc._id = nid << 1;
 		            return;
+		          }
+		        }
 		        if (nid % _width > 0) {
 		          arc._id = (_edge_limit + nid % _width +
 		                     (nid / _width) * (_width - 1) - 1) << 1 | 1;
 		          return;
+		        }
 		        if (nid >= _width) {
 		          arc._id = (nid - _width) << 1 | 1;
 		          return;
+		        }
 		      } else {
 		        if (nid >= _edge_limit) {
 		          nid = (nid - _edge_limit) % (_width - 1) +
 		            (nid - _edge_limit) / (_width - 1) * _width + 1;
 		          if (nid >= _width) {
 		            arc._id = (nid - _width) << 1 | 1;
 		            return;
+		          }
+		        }
+		      }
 		      arc._id = -1;
+		    }
 		    void firstInc(Edge& edge, bool& dir, const Node& node) const {
 		      if (node._id % _width < _width - 1) {
 		        edge._id = _edge_limit + node._id % _width +
 		          (node._id / _width) * (_width - 1);
 		        dir = true;
 		        return;
+		      }
 		      if (node._id < _node_num - _width) {
 		        edge._id = node._id;
 		        dir = true;
 		        return;
+		      }
 		      if (node._id % _width > 0) {
 		        edge._id = _edge_limit + node._id % _width +
 		          (node._id / _width) * (_width - 1) - 1;
 		        dir = false;
 		        return;
+		      }
 		      if (node._id >= _width) {
 		        edge._id = node._id - _width;
 		        dir = false;
 		        return;
+		      }
 		      edge._id = -1;
 		      dir = true;
+		    }
 		    void nextInc(Edge& edge, bool& dir) const {
 		      int nid = edge._id;
 		      if (dir) {
 		        if (nid >= _edge_limit) {
 		          nid = (nid - _edge_limit) % (_width - 1) +
 		            (nid - _edge_limit) / (_width - 1) * _width;
 		          if (nid < _node_num - _width) {
 		            edge._id = nid;
 		            return;
+		          }
+		        }
 		        if (nid % _width > 0) {
 		          edge._id = _edge_limit + nid % _width +
 		            (nid / _width) * (_width - 1) - 1;
 		          dir = false;
 		          return;
+		        }
 		        if (nid >= _width) {
 		          edge._id = nid - _width;
 		          dir = false;
 		          return;
+		        }
 		      } else {
 		        if (nid >= _edge_limit) {
 		          nid = (nid - _edge_limit) % (_width - 1) +
 		            (nid - _edge_limit) / (_width - 1) * _width + 1;
 		          if (nid >= _width) {
 		            edge._id = nid - _width;
 		            return;
+		          }
+		        }
+		      }
 		      edge._id = -1;
 		      dir = true;
+		    }
 		    Arc right(Node n) const {
 		      if (n._id % _width < _width - 1) {
 		        return Arc(((_edge_limit + n._id % _width +
 		                    (n._id / _width) * (_width - 1)) << 1) | 1);
 		      } else {
 		        return INVALID;
+		      }
+		    }
 		    Arc left(Node n) const {
 		      if (n._id % _width > 0) {
 		        return Arc((_edge_limit + n._id % _width +
 		                     (n._id / _width) * (_width - 1) - 1) << 1);
 		      } else {
 		        return INVALID;
+		      }
+		    }
 		    Arc up(Node n) const {
 		      if (n._id < _edge_limit) {
 		        return Arc((n._id << 1) | 1);
 		      } else {
 		        return INVALID;
+		      }
+		    }
 		    Arc down(Node n) const {
 		      if (n._id >= _width) {
 		        return Arc((n._id - _width) << 1);
 		      } else {
 		        return INVALID;
+		      }
+		    }
 		  private:
 		    int _width, _height;
 		    int _node_num, _edge_num;
 		    int _edge_limit;
 		  };
 		  typedef GraphExtender<GridGraphBase> ExtendedGridGraphBase;
 		  /// \ingroup graphs
 		  ///
 		  /// \brief Grid graph class
 		  ///
 		  /// This class implements a special graph type. The nodes of the
 		  /// graph can be indexed by two integer \c (i,j) value where \c i is
 		  /// in the \c [0..width()-1] range and j is in the \c
 		  /// [0..height()-1] range.  Two nodes are connected in the graph if
 		  /// the indexes differ exactly on one position and exactly one is
 		  /// the difference. The nodes of the graph can be indexed by position
 		  /// with the \c operator()() function. The positions of the nodes can be
 		  /// get with \c pos(), \c col() and \c row() members. The outgoing
 		  /// arcs can be retrieved with the \c right(), \c up(), \c left()
 		  /// and \c down() functions, where the bottom-left corner is the
 		  /// origin.
 		  ///
 		  /// \image html grid_graph.png
 		  /// \image latex grid_graph.eps "Grid graph" width=\textwidth
 		  ///
 		  /// A short example about the basic usage:
 		  ///\code
 		  /// GridGraph graph(rows, cols);
 		  /// GridGraph::NodeMap<int> val(graph);
 		  /// for (int i = 0; i < graph.width(); ++i) {
 		  ///   for (int j = 0; j < graph.height(); ++j) {
 		  ///     val[graph(i, j)] = i + j;
 		  ///   }
 		  /// }
 		  ///\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
 		      typedef GridGraph::Node Key;
 		      /// \brief The value type of the map
 		      typedef dim2::Point<int> Value;
 		      /// \brief Constructor
 		      ///
 		      /// Constructor
 		      IndexMap(const GridGraph& graph) : _graph(graph) {}
 		      /// \brief The subscript operator
 		      ///
 		      /// The subscript operator.
 		      Value operator[](Key key) const {
 		        return _graph.pos(key);
+		      }
 		    private:
 		      const GridGraph& _graph;
 		    };
 		    /// \brief Map to get the column of the nodes.
 		    ///
 		    /// Map to get the column of the nodes.
 		    class ColMap {
 		    public:
 		      /// \brief The key type of the map
 		      typedef GridGraph::Node Key;
 		      /// \brief The value type of the map
 		      typedef int Value;
 		      /// \brief Constructor
 		      ///
 		      /// Constructor
 		      ColMap(const GridGraph& graph) : _graph(graph) {}
 		      /// \brief The subscript operator
 		      ///
 		      /// The subscript operator.
 		      Value operator[](Key key) const {
 		        return _graph.col(key);
+		      }
 		    private:
 		      const GridGraph& _graph;
 		    };
 		    /// \brief Map to get the row of the nodes.
 		    ///
 		    /// Map to get the row of the nodes.
 		    class RowMap {
 		    public:
 		      /// \brief The key type of the map
 		      typedef GridGraph::Node Key;
 		      /// \brief The value type of the map
 		      typedef int Value;
 		      /// \brief Constructor
 		      ///
 		      /// Constructor
 		      RowMap(const GridGraph& graph) : _graph(graph) {}
 		      /// \brief The subscript operator
 		      ///
 		      /// The subscript operator.
 		      Value operator[](Key key) const {
 		        return _graph.row(key);
+		      }
 		    private:
 		      const GridGraph& _graph;
 		    };
 		    /// \brief Constructor
 		    ///
 		    /// Construct a grid graph with given size.
 		    GridGraph(int width, int height) { construct(width, height); }
 		    /// \brief Resize the graph
 		    ///
 		    /// Resize the graph. The function will fully destroy and rebuild
 		    /// the graph.  This cause that the maps of the graph will
 		    /// reallocated automatically and the previous values will be
 		    /// lost.
 		    void resize(int width, int height) {
 		      Parent::notifier(Arc()).clear();
 		      Parent::notifier(Edge()).clear();
 		      Parent::notifier(Node()).clear();
 		      construct(width, height);
 		      Parent::notifier(Node()).build();
 		      Parent::notifier(Edge()).build();
 		      Parent::notifier(Arc()).build();
+		    }
 		    /// \brief The node on the given position.
 		    ///
 		    /// Gives back the node on the given position.
 		    Node operator()(int i, int j) const {
 		      return Parent::operator()(i, j);
+		    }
 		    /// \brief Gives back the column index of the node.
 		    ///
 		    /// Gives back the column index of the node.
 		    int col(Node n) const {
 		      return Parent::col(n);
+		    }
 		    /// \brief Gives back the row index of the node.
 		    ///
 		    /// Gives back the row index of the node.
 		    int row(Node n) const {
 		      return Parent::row(n);
+		    }
 		    /// \brief Gives back the position of the node.
 		    ///
 		    /// Gives back the position of the node, ie. the <tt>(col,row)</tt> pair.
 		    dim2::Point<int> pos(Node n) const {
 		      return Parent::pos(n);
+		    }
 		    /// \brief Gives back the number of the columns.
 		    ///
 		    /// Gives back the number of the columns.
 		    int width() const {
 		      return Parent::width();
+		    }
 		    /// \brief Gives back the number of the rows.
 		    ///
 		    /// Gives back the number of the rows.
 		    int height() const {
 		      return Parent::height();
+		    }
 		    /// \brief Gives back the arc goes right from the node.
 		    ///
 		    /// Gives back the arc goes right from the node. If there is not
 		    /// outgoing arc then it gives back INVALID.
 		    Arc right(Node n) const {
 		      return Parent::right(n);
+		    }
 		    /// \brief Gives back the arc goes left from the node.
 		    ///
 		    /// Gives back the arc goes left from the node. If there is not
 		    /// outgoing arc then it gives back INVALID.
 		    Arc left(Node n) const {
 		      return Parent::left(n);
+		    }
 		    /// \brief Gives back the arc goes up from the node.
 		    ///
 		    /// Gives back the arc goes up from the node. If there is not
 		    /// outgoing arc then it gives back INVALID.
 		    Arc up(Node n) const {
 		      return Parent::up(n);
+		    }
 		    /// \brief Gives back the arc goes down from the node.
 		    ///
 		    /// Gives back the arc goes down from the node. If there is not
 		    /// outgoing arc then it gives back INVALID.
 		    Arc down(Node n) const {
 		      return Parent::down(n);
+		    }
 		    /// \brief Index map of the grid graph
 		    ///
 		    /// Just returns an IndexMap for the grid graph.
 		    IndexMap indexMap() const {
 		      return IndexMap(*this);
+		    }
 		    /// \brief Row map of the grid graph
 		    ///
 		    /// Just returns a RowMap for the grid graph.
 		    RowMap rowMap() const {
 		      return RowMap(*this);
+		    }
 		    /// \brief Column map of the grid graph
 		    ///
 		    /// Just returns a ColMap for the grid graph.
 		    ColMap colMap() const {
 		      return ColMap(*this);
+		    }
 		  };
+		}
 		#endif

lemon/hypercube_graph.h

Show inline comments

@@ -41,398 +41,398 @@
 		    class Arc;
 		  public:
 		    HypercubeGraphBase() {}
 		  protected:
 		    void construct(int dim) {
 		      LEMON_ASSERT(dim >= 1, "The number of dimensions must be at least 1.");
 		      _dim = dim;
 		      _node_num = 1 << dim;
 		      _edge_num = dim * (1 << (dim-1));
+		    }
 		  public:
 		    typedef True NodeNumTag;
 		    typedef True EdgeNumTag;
 		    typedef True ArcNumTag;
 		    int nodeNum() const { return _node_num; }
 		    int edgeNum() const { return _edge_num; }
 		    int arcNum() const { return 2 * _edge_num; }
 		    int maxNodeId() const { return _node_num - 1; }
 		    int maxEdgeId() const { return _edge_num - 1; }
 		    int maxArcId() const { return 2 * _edge_num - 1; }
 		    static Node nodeFromId(int id) { return Node(id); }
 		    static Edge edgeFromId(int id) { return Edge(id); }
 		    static Arc arcFromId(int id) { return Arc(id); }
 		    static int id(Node node) { return node._id; }
 		    static int id(Edge edge) { return edge._id; }
 		    static int id(Arc arc) { return arc._id; }
 		    Node u(Edge edge) const {
 		      int base = edge._id & ((1 << (_dim-1)) - 1);
 		      int k = edge._id >> (_dim-1);
 		      return ((base >> k) << (k+1)) | (base & ((1 << k) - 1));
+		    }
 		    Node v(Edge edge) const {
 		      int base = edge._id & ((1 << (_dim-1)) - 1);
 		      int k = edge._id >> (_dim-1);
 		      return ((base >> k) << (k+1)) | (base & ((1 << k) - 1)) | (1 << k);
+		    }
 		    Node source(Arc arc) const {
 		      return (arc._id & 1) == 1 ? u(arc) : v(arc);
+		    }
 		    Node target(Arc arc) const {
 		      return (arc._id & 1) == 1 ? v(arc) : u(arc);
+		    }
 		    typedef True FindEdgeTag;
 		    typedef True FindArcTag;
 		    Edge findEdge(Node u, Node v, Edge prev = INVALID) const {
 		      if (prev != INVALID) return INVALID;
 		      int d = u._id ^ v._id;
 		      int k = 0;
 		      if (d == 0) return INVALID;
 		      for ( ; (d & 1) == 0; d >>= 1) ++k;
 		      if (d >> 1 != 0) return INVALID;
 		      return (k << (_dim-1)) | ((u._id >> (k+1)) << k) |
 		        (u._id & ((1 << k) - 1));
+		    }
 		    Arc findArc(Node u, Node v, Arc prev = INVALID) const {
 		      Edge edge = findEdge(u, v, prev);
 		      if (edge == INVALID) return INVALID;
 		      int k = edge._id >> (_dim-1);
 		      return ((u._id >> k) & 1) == 1 ? edge._id << 1 : (edge._id << 1) | 1;
+		    }
 		    class Node {
 		      friend class HypercubeGraphBase;
 		    protected:
 		      int _id;
 		      Node(int id) : _id(id) {}
 		    public:
 		      Node() {}
 		      Node (Invalid) : _id(-1) {}
 		      bool operator==(const Node node) const {return _id == node._id;}
 		      bool operator!=(const Node node) const {return _id != node._id;}
 		      bool operator<(const Node node) const {return _id < node._id;}
 		    };
 		    class Edge {
 		      friend class HypercubeGraphBase;
 		      friend class Arc;
 		    protected:
 		      int _id;
 		      Edge(int id) : _id(id) {}
 		    public:
 		      Edge() {}
 		      Edge (Invalid) : _id(-1) {}
 		      bool operator==(const Edge edge) const {return _id == edge._id;}
 		      bool operator!=(const Edge edge) const {return _id != edge._id;}
 		      bool operator<(const Edge edge) const {return _id < edge._id;}
 		    };
 		    class Arc {
 		      friend class HypercubeGraphBase;
 		    protected:
 		      int _id;
 		      Arc(int id) : _id(id) {}
 		    public:
 		      Arc() {}
 		      Arc (Invalid) : _id(-1) {}
 		      operator Edge() const { return _id != -1 ? Edge(_id >> 1) : INVALID; }
 		      bool operator==(const Arc arc) const {return _id == arc._id;}
 		      bool operator!=(const Arc arc) const {return _id != arc._id;}
 		      bool operator<(const Arc arc) const {return _id < arc._id;}
 		    };
 		    void first(Node& node) const {
 		      node._id = _node_num - 1;
+		    }
 		    static void next(Node& node) {
 		      --node._id;
+		    }
 		    void first(Edge& edge) const {
 		      edge._id = _edge_num - 1;
+		    }
 		    static void next(Edge& edge) {
 		      --edge._id;
+		    }
 		    void first(Arc& arc) const {
 		      arc._id = 2 * _edge_num - 1;
+		    }
 		    static void next(Arc& arc) {
 		      --arc._id;
+		    }
 		    void firstInc(Edge& edge, bool& dir, const Node& node) const {
 		      edge._id = node._id >> 1;
 		      dir = (node._id & 1) == 0;
+		    }
 		    void nextInc(Edge& edge, bool& dir) const {
 		      Node n = dir ? u(edge) : v(edge);
 		      int k = (edge._id >> (_dim-1)) + 1;
 		      if (k < _dim) {
 		        edge._id = (k << (_dim-1)) |
 		          ((n._id >> (k+1)) << k) | (n._id & ((1 << k) - 1));
 		        dir = ((n._id >> k) & 1) == 0;
 		      } else {
 		        edge._id = -1;
 		        dir = true;
+		      }
+		    }
 		    void firstOut(Arc& arc, const Node& node) const {
 		      arc._id = ((node._id >> 1) << 1) | (~node._id & 1);
+		    }
 		    void nextOut(Arc& arc) const {
 		      Node n = (arc._id & 1) == 1 ? u(arc) : v(arc);
 		      int k = (arc._id >> _dim) + 1;
 		      if (k < _dim) {
 		        arc._id = (k << (_dim-1)) |
 		          ((n._id >> (k+1)) << k) | (n._id & ((1 << k) - 1));
 		        arc._id = (arc._id << 1) | (~(n._id >> k) & 1);
 		      } else {
 		        arc._id = -1;
+		      }
+		    }
 		    void firstIn(Arc& arc, const Node& node) const {
 		      arc._id = ((node._id >> 1) << 1) | (node._id & 1);
+		    }
 		    void nextIn(Arc& arc) const {
 		      Node n = (arc._id & 1) == 1 ? v(arc) : u(arc);
 		      int k = (arc._id >> _dim) + 1;
 		      if (k < _dim) {
 		        arc._id = (k << (_dim-1)) |
 		          ((n._id >> (k+1)) << k) | (n._id & ((1 << k) - 1));
 		        arc._id = (arc._id << 1) | ((n._id >> k) & 1);
 		      } else {
 		        arc._id = -1;
+		      }
+		    }
 		    static bool direction(Arc arc) {
 		      return (arc._id & 1) == 1;
+		    }
 		    static Arc direct(Edge edge, bool dir) {
 		      return Arc((edge._id << 1) | (dir ? 1 : 0));
+		    }
 		    int dimension() const {
 		      return _dim;
+		    }
 		    bool projection(Node node, int n) const {
 		      return static_cast<bool>(node._id & (1 << n));
+		    }
 		    int dimension(Edge edge) const {
 		      return edge._id >> (_dim-1);
+		    }
 		    int dimension(Arc arc) const {
 		      return arc._id >> _dim;
+		    }
 		    int index(Node node) const {
 		      return node._id;
+		    }
 		    Node operator()(int ix) const {
 		      return Node(ix);
+		    }
 		  private:
 		    int _dim;
 		    int _node_num, _edge_num;
 		  };
 		  typedef GraphExtender<HypercubeGraphBase> ExtendedHypercubeGraphBase;
 		  /// \ingroup graphs
 		  ///
 		  /// \brief Hypercube graph class
 		  ///
 		  /// This class implements a special graph type. The nodes of the graph
 		  /// are indiced with integers with at most \c dim binary digits.
 		  /// Two nodes are connected in the graph if and only if their indices
 		  /// differ only on one position in the binary form.
 		  ///
 		  /// \note The type of the indices is chosen to \c int for efficiency
 		  /// 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.
 		    ///
 		    /// Gives back the number of dimensions.
 		    int dimension() const {
 		      return Parent::dimension();
+		    }
 		    /// \brief Returns \c true if the n'th bit of the node is one.
 		    ///
 		    /// Returns \c true if the n'th bit of the node is one.
 		    bool projection(Node node, int n) const {
 		      return Parent::projection(node, n);
+		    }
 		    /// \brief The dimension id of an edge.
 		    ///
 		    /// Gives back the dimension id of the given edge.
 		    /// It is in the [0..dim-1] range.
 		    int dimension(Edge edge) const {
 		      return Parent::dimension(edge);
+		    }
 		    /// \brief The dimension id of an arc.
 		    ///
 		    /// Gives back the dimension id of the given arc.
 		    /// It is in the [0..dim-1] range.
 		    int dimension(Arc arc) const {
 		      return Parent::dimension(arc);
+		    }
 		    /// \brief The index of a node.
 		    ///
 		    /// Gives back the index of the given node.
 		    /// The lower bits of the integer describes the node.
 		    int index(Node node) const {
 		      return Parent::index(node);
+		    }
 		    /// \brief Gives back a node by its index.
 		    ///
 		    /// Gives back a node by its index.
 		    Node operator()(int ix) const {
 		      return Parent::operator()(ix);
+		    }
 		    /// \brief Number of nodes.
 		    int nodeNum() const { return Parent::nodeNum(); }
 		    /// \brief Number of edges.
 		    int edgeNum() const { return Parent::edgeNum(); }
 		    /// \brief Number of arcs.
 		    int arcNum() const { return Parent::arcNum(); }
 		    /// \brief Linear combination map.
 		    ///
 		    /// This map makes possible to give back a linear combination
 		    /// for each node. It works like the \c std::accumulate function,
 		    /// so it accumulates the \c bf binary function with the \c fv first
 		    /// value. The map accumulates only on that positions (dimensions)
 		    /// where the index of the node is one. The values that have to be
 		    /// accumulated should be given by the \c begin and \c end iterators
 		    /// and the length of this range should be equal to the dimension
 		    /// number of the graph.
 		    ///
 		    ///\code
 		    /// const int DIM = 3;
 		    /// HypercubeGraph graph(DIM);
 		    /// dim2::Point<double> base[DIM];
 		    /// for (int k = 0; k < DIM; ++k) {
 		    ///   base[k].x = rnd();
 		    ///   base[k].y = rnd();
 		    /// }
 		    /// HypercubeGraph::HyperMap<dim2::Point<double> >
 		    ///   pos(graph, base, base + DIM, dim2::Point<double>(0.0, 0.0));
 		    ///\endcode
 		    ///
 		    /// \see HypercubeGraph
 		    template <typename T, typename BF = std::plus<T> >
 		    class HyperMap {
 		    public:
 		      /// \brief The key type of the map
 		      typedef Node Key;
 		      /// \brief The value type of the map
 		      typedef T Value;
 		      /// \brief Constructor for HyperMap.
 		      ///
 		      /// Construct a HyperMap for the given graph. The values that have
 		      /// to be accumulated should be given by the \c begin and \c end
 		      /// iterators and the length of this range should be equal to the
 		      /// dimension number of the graph.
 		      ///
 		      /// This map accumulates the \c bf binary function with the \c fv
 		      /// first value on that positions (dimensions) where the index of
 		      /// the node is one.
 		      template <typename It>
 		      HyperMap(const Graph& graph, It begin, It end,
 		               T fv = 0, const BF& bf = BF())
 		        : _graph(graph), _values(begin, end), _first_value(fv), _bin_func(bf)
+		      {
 		        LEMON_ASSERT(_values.size() == graph.dimension(),
 		                     "Wrong size of range");
+		      }
 		      /// \brief The partial accumulated value.
 		      ///
 		      /// Gives back the partial accumulated value.
 		      Value operator[](const Key& k) const {
 		        Value val = _first_value;
 		        int id = _graph.index(k);
 		        int n = 0;
 		        while (id != 0) {
 		          if (id & 1) {
 		            val = _bin_func(val, _values[n]);
+		          }
 		          id >>= 1;
 		          ++n;
+		        }
 		        return val;
+		      }
 		    private:
 		      const Graph& _graph;
 		      std::vector<T> _values;
 		      T _first_value;
 		      BF _bin_func;
 		    };
 		  };
+		}
 		#endif

lemon/list_graph.h

Show inline comments

@@ -70,1386 +70,1386 @@
 		    public:
 		      Node() {}
 		      Node (Invalid) { id = -1; }
 		      bool operator==(const Node& node) const {return id == node.id;}
 		      bool operator!=(const Node& node) const {return id != node.id;}
 		      bool operator<(const Node& node) const {return id < node.id;}
 		    };
 		    class Arc {
 		      friend class ListDigraphBase;
 		    protected:
 		      int id;
 		      explicit Arc(int pid) { id = pid;}
 		    public:
 		      Arc() {}
 		      Arc (Invalid) { id = -1; }
 		      bool operator==(const Arc& arc) const {return id == arc.id;}
 		      bool operator!=(const Arc& arc) const {return id != arc.id;}
 		      bool operator<(const Arc& arc) const {return id < arc.id;}
 		    };
 		    ListDigraphBase()
 		      : nodes(), first_node(-1),
 		        first_free_node(-1), arcs(), first_free_arc(-1) {}
 		    int maxNodeId() const { return nodes.size()-1; }
 		    int maxArcId() const { return arcs.size()-1; }
 		    Node source(Arc e) const { return Node(arcs[e.id].source); }
 		    Node target(Arc e) const { return Node(arcs[e.id].target); }
 		    void first(Node& node) const {
 		      node.id = first_node;
+		    }
 		    void next(Node& node) const {
 		      node.id = nodes[node.id].next;
+		    }
 		    void first(Arc& arc) const {
 		      int n;
 		      for(n = first_node;
 		          n!=-1 && nodes[n].first_in == -1;
 		          n = nodes[n].next) {}
 		      arc.id = (n == -1) ? -1 : nodes[n].first_in;
+		    }
 		    void next(Arc& arc) const {
 		      if (arcs[arc.id].next_in != -1) {
 		        arc.id = arcs[arc.id].next_in;
 		      } else {
 		        int n;
 		        for(n = nodes[arcs[arc.id].target].next;
 		            n!=-1 && nodes[n].first_in == -1;
 		            n = nodes[n].next) {}
 		        arc.id = (n == -1) ? -1 : nodes[n].first_in;
+		      }
+		    }
 		    void firstOut(Arc &e, const Node& v) const {
 		      e.id = nodes[v.id].first_out;
+		    }
 		    void nextOut(Arc &e) const {
 		      e.id=arcs[e.id].next_out;
+		    }
 		    void firstIn(Arc &e, const Node& v) const {
 		      e.id = nodes[v.id].first_in;
+		    }
 		    void nextIn(Arc &e) const {
 		      e.id=arcs[e.id].next_in;
+		    }
 		    static int id(Node v) { return v.id; }
 		    static int id(Arc e) { return e.id; }
 		    static Node nodeFromId(int id) { return Node(id);}
 		    static Arc arcFromId(int id) { return Arc(id);}
 		    bool valid(Node n) const {
 		      return n.id >= 0 && n.id < static_cast<int>(nodes.size()) &&
 		        nodes[n.id].prev != -2;
+		    }
 		    bool valid(Arc a) const {
 		      return a.id >= 0 && a.id < static_cast<int>(arcs.size()) &&
 		        arcs[a.id].prev_in != -2;
+		    }
 		    Node addNode() {
 		      int n;
 		      if(first_free_node==-1) {
 		        n = nodes.size();
 		        nodes.push_back(NodeT());
 		      } else {
 		        n = first_free_node;
 		        first_free_node = nodes[n].next;
+		      }
 		      nodes[n].next = first_node;
 		      if(first_node != -1) nodes[first_node].prev = n;
 		      first_node = n;
 		      nodes[n].prev = -1;
 		      nodes[n].first_in = nodes[n].first_out = -1;
 		      return Node(n);
+		    }
 		    Arc addArc(Node u, Node v) {
 		      int n;
 		      if (first_free_arc == -1) {
 		        n = arcs.size();
 		        arcs.push_back(ArcT());
 		      } else {
 		        n = first_free_arc;
 		        first_free_arc = arcs[n].next_in;
+		      }
 		      arcs[n].source = u.id;
 		      arcs[n].target = v.id;
 		      arcs[n].next_out = nodes[u.id].first_out;
 		      if(nodes[u.id].first_out != -1) {
 		        arcs[nodes[u.id].first_out].prev_out = n;
+		      }
 		      arcs[n].next_in = nodes[v.id].first_in;
 		      if(nodes[v.id].first_in != -1) {
 		        arcs[nodes[v.id].first_in].prev_in = n;
+		      }
 		      arcs[n].prev_in = arcs[n].prev_out = -1;
 		      nodes[u.id].first_out = nodes[v.id].first_in = n;
 		      return Arc(n);
+		    }
 		    void erase(const Node& node) {
 		      int n = node.id;
 		      if(nodes[n].next != -1) {
 		        nodes[nodes[n].next].prev = nodes[n].prev;
+		      }
 		      if(nodes[n].prev != -1) {
 		        nodes[nodes[n].prev].next = nodes[n].next;
 		      } else {
 		        first_node = nodes[n].next;
+		      }
 		      nodes[n].next = first_free_node;
 		      first_free_node = n;
 		      nodes[n].prev = -2;
+		    }
 		    void erase(const Arc& arc) {
 		      int n = arc.id;
 		      if(arcs[n].next_in!=-1) {
 		        arcs[arcs[n].next_in].prev_in = arcs[n].prev_in;
+		      }
 		      if(arcs[n].prev_in!=-1) {
 		        arcs[arcs[n].prev_in].next_in = arcs[n].next_in;
 		      } else {
 		        nodes[arcs[n].target].first_in = arcs[n].next_in;
+		      }
 		      if(arcs[n].next_out!=-1) {
 		        arcs[arcs[n].next_out].prev_out = arcs[n].prev_out;
+		      }
 		      if(arcs[n].prev_out!=-1) {
 		        arcs[arcs[n].prev_out].next_out = arcs[n].next_out;
 		      } else {
 		        nodes[arcs[n].source].first_out = arcs[n].next_out;
+		      }
 		      arcs[n].next_in = first_free_arc;
 		      first_free_arc = n;
 		      arcs[n].prev_in = -2;
+		    }
 		    void clear() {
 		      arcs.clear();
 		      nodes.clear();
 		      first_node = first_free_node = first_free_arc = -1;
+		    }
 		  protected:
 		    void changeTarget(Arc e, Node n)
+		    {
 		      if(arcs[e.id].next_in != -1)
 		        arcs[arcs[e.id].next_in].prev_in = arcs[e.id].prev_in;
 		      if(arcs[e.id].prev_in != -1)
 		        arcs[arcs[e.id].prev_in].next_in = arcs[e.id].next_in;
 		      else nodes[arcs[e.id].target].first_in = arcs[e.id].next_in;
 		      if (nodes[n.id].first_in != -1) {
 		        arcs[nodes[n.id].first_in].prev_in = e.id;
+		      }
 		      arcs[e.id].target = n.id;
 		      arcs[e.id].prev_in = -1;
 		      arcs[e.id].next_in = nodes[n.id].first_in;
 		      nodes[n.id].first_in = e.id;
+		    }
 		    void changeSource(Arc e, Node n)
+		    {
 		      if(arcs[e.id].next_out != -1)
 		        arcs[arcs[e.id].next_out].prev_out = arcs[e.id].prev_out;
 		      if(arcs[e.id].prev_out != -1)
 		        arcs[arcs[e.id].prev_out].next_out = arcs[e.id].next_out;
 		      else nodes[arcs[e.id].source].first_out = arcs[e.id].next_out;
 		      if (nodes[n.id].first_out != -1) {
 		        arcs[nodes[n.id].first_out].prev_out = e.id;
+		      }
 		      arcs[e.id].source = n.id;
 		      arcs[e.id].prev_out = -1;
 		      arcs[e.id].next_out = nodes[n.id].first_out;
 		      nodes[n.id].first_out = e.id;
+		    }
 		  };
 		  typedef DigraphExtender<ListDigraphBase> ExtendedListDigraphBase;
 		  /// \addtogroup graphs
 		  /// @{
 		  ///A general directed graph structure.
 		  ///\ref ListDigraph is a simple and fast <em>directed graph</em>
 		  ///implementation based on static linked lists that are stored in
 		  ///\c std::vector structures.
 		  ///
 		  ///It conforms to the \ref concepts::Digraph "Digraph concept" and it
 		  ///also provides several useful additional functionalities.
 		  ///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() {};
 		    ///\brief Assignment of ListDigraph to another one is \e not allowed.
 		    ///Use copyDigraph() instead.
 		    ///Assignment of ListDigraph to another one is \e not allowed.
 		    ///Use copyDigraph() instead.
 		    void operator=(const ListDigraph &) {}
 		  public:
 		    typedef ExtendedListDigraphBase Parent;
 		    /// Constructor
 		    /// Constructor.
 		    ///
 		    ListDigraph() {}
 		    ///Add a new node to the digraph.
 		    ///Add a new node to the digraph.
 		    ///\return The new node.
 		    Node addNode() { return Parent::addNode(); }
 		    ///Add a new arc to the digraph.
 		    ///Add a new arc to the digraph with source node \c s
 		    ///and target node \c t.
 		    ///\return The new arc.
 		    Arc addArc(const Node& s, const Node& t) {
 		      return Parent::addArc(s, t);
+		    }
 		    ///\brief Erase a node from the digraph.
 		    ///
 		    ///Erase a node from the digraph.
 		    ///
 		    void erase(const Node& n) { Parent::erase(n); }
 		    ///\brief Erase an arc from the digraph.
 		    ///
 		    ///Erase an arc from the digraph.
 		    ///
 		    void erase(const Arc& a) { Parent::erase(a); }
 		    /// Node validity check
 		    /// This function gives back true if the given node is valid,
 		    /// ie. it is a real node of the graph.
 		    ///
 		    /// \warning A Node pointing to a removed item
 		    /// could become valid again later if new nodes are
 		    /// added to the graph.
 		    bool valid(Node n) const { return Parent::valid(n); }
 		    /// Arc validity check
 		    /// This function gives back true if the given arc is valid,
 		    /// ie. it is a real arc of the graph.
 		    ///
 		    /// \warning An Arc pointing to a removed item
 		    /// could become valid again later if new nodes are
 		    /// added to the graph.
 		    bool valid(Arc a) const { return Parent::valid(a); }
 		    /// Change the target of \c a to \c n
 		    /// Change the target of \c a to \c n
 		    ///
 		    ///\note The <tt>ArcIt</tt>s and <tt>OutArcIt</tt>s referencing
 		    ///the changed arc remain valid. However <tt>InArcIt</tt>s are
 		    ///invalidated.
 		    ///
 		    ///\warning This functionality cannot be used together with the Snapshot
 		    ///feature.
 		    void changeTarget(Arc a, Node n) {
 		      Parent::changeTarget(a,n);
+		    }
 		    /// Change the source of \c a to \c n
 		    /// Change the source of \c a to \c n
 		    ///
 		    ///\note The <tt>InArcIt</tt>s referencing the changed arc remain
 		    ///valid. However the <tt>ArcIt</tt>s and <tt>OutArcIt</tt>s are
 		    ///invalidated.
 		    ///
 		    ///\warning This functionality cannot be used together with the Snapshot
 		    ///feature.
 		    void changeSource(Arc a, Node n) {
 		      Parent::changeSource(a,n);
+		    }
 		    /// Invert the direction of an arc.
 		    ///\note The <tt>ArcIt</tt>s referencing the changed arc remain
 		    ///valid. However <tt>OutArcIt</tt>s and <tt>InArcIt</tt>s are
 		    ///invalidated.
 		    ///
 		    ///\warning This functionality cannot be used together with the Snapshot
 		    ///feature.
 		    void reverseArc(Arc e) {
 		      Node t=target(e);
 		      changeTarget(e,source(e));
 		      changeSource(e,t);
+		    }
 		    /// Reserve memory for nodes.
 		    /// Using this function it is possible to avoid the superfluous memory
 		    /// allocation: if you know that the digraph you want to build will
 		    /// be very large (e.g. it will contain millions of nodes and/or arcs)
 		    /// then it is worth reserving space for this amount before starting
 		    /// to build the digraph.
 		    /// \sa reserveArc
 		    void reserveNode(int n) { nodes.reserve(n); };
 		    /// Reserve memory for arcs.
 		    /// Using this function it is possible to avoid the superfluous memory
 		    /// allocation: if you know that the digraph you want to build will
 		    /// be very large (e.g. it will contain millions of nodes and/or arcs)
 		    /// then it is worth reserving space for this amount before starting
 		    /// to build the digraph.
 		    /// \sa reserveNode
 		    void reserveArc(int m) { arcs.reserve(m); };
 		    ///Contract two nodes.
 		    ///This function contracts two nodes.
 		    ///Node \p b will be removed but instead of deleting
 		    ///incident arcs, they will be joined to \p a.
 		    ///The last parameter \p r controls whether to remove loops. \c true
 		    ///means that loops will be removed.
 		    ///
 		    ///\note The <tt>ArcIt</tt>s referencing a moved arc remain
 		    ///valid. However <tt>InArcIt</tt>s and <tt>OutArcIt</tt>s
 		    ///may be invalidated.
 		    ///
 		    ///\warning This functionality cannot be used together with the Snapshot
 		    ///feature.
 		    void contract(Node a, Node b, bool r = true)
+		    {
 		      for(OutArcIt e(*this,b);e!=INVALID;) {
 		        OutArcIt f=e;
 		        ++f;
 		        if(r && target(e)==a) erase(e);
 		        else changeSource(e,a);
 		        e=f;
+		      }
 		      for(InArcIt e(*this,b);e!=INVALID;) {
 		        InArcIt f=e;
 		        ++f;
 		        if(r && source(e)==a) erase(e);
 		        else changeTarget(e,a);
 		        e=f;
+		      }
 		      erase(b);
+		    }
 		    ///Split a node.
 		    ///This function splits a node. First a new node is added to the digraph,
 		    ///then the source of each outgoing arc of \c n is moved to this new node.
 		    ///If \c connect is \c true (this is the default value), then a new arc
 		    ///from \c n to the newly created node is also added.
 		    ///\return The newly created node.
 		    ///
 		    ///\note The <tt>ArcIt</tt>s referencing a moved arc remain
 		    ///valid. However <tt>InArcIt</tt>s and <tt>OutArcIt</tt>s may
 		    ///be invalidated.
 		    ///
 		    ///\warning This functionality cannot be used in conjunction with the
 		    ///Snapshot feature.
 		    Node split(Node n, bool connect = true) {
 		      Node b = addNode();
 		      for(OutArcIt e(*this,n);e!=INVALID;) {
 		        OutArcIt f=e;
 		        ++f;
 		        changeSource(e,b);
 		        e=f;
+		      }
 		      if (connect) addArc(n,b);
 		      return b;
+		    }
 		    ///Split an arc.
 		    ///This function splits an arc. First a new node \c b is added to
 		    ///the digraph, then the original arc is re-targeted to \c
 		    ///b. Finally an arc from \c b to the original target is added.
 		    ///
 		    ///\return The newly created node.
 		    ///
 		    ///\warning This functionality cannot be used together with the
 		    ///Snapshot feature.
 		    Node split(Arc e) {
 		      Node b = addNode();
 		      addArc(b,target(e));
 		      changeTarget(e,b);
 		      return b;
+		    }
 		    /// \brief Class to make a snapshot of the digraph and restore
 		    /// it later.
 		    ///
 		    /// Class to make a snapshot of the digraph and restore it later.
 		    ///
 		    /// The newly added nodes and arcs can be removed using the
 		    /// restore() function.
 		    ///
 		    /// \warning Arc and node deletions and other modifications (e.g.
 		    /// contracting, splitting, reversing arcs or nodes) cannot be
 		    /// restored. These events invalidate the snapshot.
 		    class Snapshot {
 		    protected:
 		      typedef Parent::NodeNotifier NodeNotifier;
 		      class NodeObserverProxy : public NodeNotifier::ObserverBase {
 		      public:
 		        NodeObserverProxy(Snapshot& _snapshot)
 		          : snapshot(_snapshot) {}
 		        using NodeNotifier::ObserverBase::attach;
 		        using NodeNotifier::ObserverBase::detach;
 		        using NodeNotifier::ObserverBase::attached;
 		      protected:
 		        virtual void add(const Node& node) {
 		          snapshot.addNode(node);
+		        }
 		        virtual void add(const std::vector<Node>& nodes) {
 		          for (int i = nodes.size() - 1; i >= 0; ++i) {
 		            snapshot.addNode(nodes[i]);
+		          }
+		        }
 		        virtual void erase(const Node& node) {
 		          snapshot.eraseNode(node);
+		        }
 		        virtual void erase(const std::vector<Node>& nodes) {
 		          for (int i = 0; i < int(nodes.size()); ++i) {
 		            snapshot.eraseNode(nodes[i]);
+		          }
+		        }
 		        virtual void build() {
 		          Node node;
 		          std::vector<Node> nodes;
 		          for (notifier()->first(node); node != INVALID;
 		               notifier()->next(node)) {
 		            nodes.push_back(node);
+		          }
 		          for (int i = nodes.size() - 1; i >= 0; --i) {
 		            snapshot.addNode(nodes[i]);
+		          }
+		        }
 		        virtual void clear() {
 		          Node node;
 		          for (notifier()->first(node); node != INVALID;
 		               notifier()->next(node)) {
 		            snapshot.eraseNode(node);
+		          }
+		        }
 		        Snapshot& snapshot;
 		      };
 		      class ArcObserverProxy : public ArcNotifier::ObserverBase {
 		      public:
 		        ArcObserverProxy(Snapshot& _snapshot)
 		          : snapshot(_snapshot) {}
 		        using ArcNotifier::ObserverBase::attach;
 		        using ArcNotifier::ObserverBase::detach;
 		        using ArcNotifier::ObserverBase::attached;
 		      protected:
 		        virtual void add(const Arc& arc) {
 		          snapshot.addArc(arc);
+		        }
 		        virtual void add(const std::vector<Arc>& arcs) {
 		          for (int i = arcs.size() - 1; i >= 0; ++i) {
 		            snapshot.addArc(arcs[i]);
+		          }
+		        }
 		        virtual void erase(const Arc& arc) {
 		          snapshot.eraseArc(arc);
+		        }
 		        virtual void erase(const std::vector<Arc>& arcs) {
 		          for (int i = 0; i < int(arcs.size()); ++i) {
 		            snapshot.eraseArc(arcs[i]);
+		          }
+		        }
 		        virtual void build() {
 		          Arc arc;
 		          std::vector<Arc> arcs;
 		          for (notifier()->first(arc); arc != INVALID;
 		               notifier()->next(arc)) {
 		            arcs.push_back(arc);
+		          }
 		          for (int i = arcs.size() - 1; i >= 0; --i) {
 		            snapshot.addArc(arcs[i]);
+		          }
+		        }
 		        virtual void clear() {
 		          Arc arc;
 		          for (notifier()->first(arc); arc != INVALID;
 		               notifier()->next(arc)) {
 		            snapshot.eraseArc(arc);
+		          }
+		        }
 		        Snapshot& snapshot;
 		      };
 		      ListDigraph *digraph;
 		      NodeObserverProxy node_observer_proxy;
 		      ArcObserverProxy arc_observer_proxy;
 		      std::list<Node> added_nodes;
 		      std::list<Arc> added_arcs;
 		      void addNode(const Node& node) {
 		        added_nodes.push_front(node);
+		      }
 		      void eraseNode(const Node& node) {
 		        std::list<Node>::iterator it =
 		          std::find(added_nodes.begin(), added_nodes.end(), node);
 		        if (it == added_nodes.end()) {
 		          clear();
 		          arc_observer_proxy.detach();
 		          throw NodeNotifier::ImmediateDetach();
 		        } else {
 		          added_nodes.erase(it);
+		        }
+		      }
 		      void addArc(const Arc& arc) {
 		        added_arcs.push_front(arc);
+		      }
 		      void eraseArc(const Arc& arc) {
 		        std::list<Arc>::iterator it =
 		          std::find(added_arcs.begin(), added_arcs.end(), arc);
 		        if (it == added_arcs.end()) {
 		          clear();
 		          node_observer_proxy.detach();
 		          throw ArcNotifier::ImmediateDetach();
 		        } else {
 		          added_arcs.erase(it);
+		        }
+		      }
 		      void attach(ListDigraph &_digraph) {
 		        digraph = &_digraph;
 		        node_observer_proxy.attach(digraph->notifier(Node()));
 		        arc_observer_proxy.attach(digraph->notifier(Arc()));
+		      }
 		      void detach() {
 		        node_observer_proxy.detach();
 		        arc_observer_proxy.detach();
+		      }
 		      bool attached() const {
 		        return node_observer_proxy.attached();
+		      }
 		      void clear() {
 		        added_nodes.clear();
 		        added_arcs.clear();
+		      }
 		    public:
 		      /// \brief Default constructor.
 		      ///
 		      /// Default constructor.
 		      /// To actually make a snapshot you must call save().
 		      Snapshot()
 		        : digraph(0), node_observer_proxy(*this),
 		          arc_observer_proxy(*this) {}
 		      /// \brief Constructor that immediately makes a snapshot.
 		      ///
 		      /// This constructor immediately makes a snapshot of the digraph.
 		      /// \param _digraph The digraph we make a snapshot of.
 		      Snapshot(ListDigraph &_digraph)
 		        : node_observer_proxy(*this),
 		          arc_observer_proxy(*this) {
 		        attach(_digraph);
+		      }
 		      /// \brief Make a snapshot.
 		      ///
 		      /// Make a snapshot of the digraph.
 		      ///
 		      /// This function can be called more than once. In case of a repeated
 		      /// call, the previous snapshot gets lost.
 		      /// \param _digraph The digraph we make the snapshot of.
 		      void save(ListDigraph &_digraph) {
 		        if (attached()) {
 		          detach();
 		          clear();
+		        }
 		        attach(_digraph);
+		      }
 		      /// \brief Undo the changes until the last snapshot.
 		      //
 		      /// Undo the changes until the last snapshot created by save().
 		      void restore() {
 		        detach();
 		        for(std::list<Arc>::iterator it = added_arcs.begin();
 		            it != added_arcs.end(); ++it) {
 		          digraph->erase(*it);
+		        }
 		        for(std::list<Node>::iterator it = added_nodes.begin();
 		            it != added_nodes.end(); ++it) {
 		          digraph->erase(*it);
+		        }
 		        clear();
+		      }
 		      /// \brief Gives back true when the snapshot is valid.
 		      ///
 		      /// Gives back true when the snapshot is valid.
 		      bool valid() const {
 		        return attached();
+		      }
 		    };
 		  };
 		  ///@}
 		  class ListGraphBase {
 		  protected:
 		    struct NodeT {
 		      int first_out;
 		      int prev, next;
 		    };
 		    struct ArcT {
 		      int target;
 		      int prev_out, next_out;
 		    };
 		    std::vector<NodeT> nodes;
 		    int first_node;
 		    int first_free_node;
 		    std::vector<ArcT> arcs;
 		    int first_free_arc;
 		  public:
-		    typedef ListGraphBase Digraph;
+		    typedef ListGraphBase Graph;
 		    class Node;
 		    class Arc;
 		    class Edge;
 		    class Node {
 		      friend class ListGraphBase;
 		    protected:
 		      int id;
 		      explicit Node(int pid) { id = pid;}
 		    public:
 		      Node() {}
 		      Node (Invalid) { id = -1; }
 		      bool operator==(const Node& node) const {return id == node.id;}
 		      bool operator!=(const Node& node) const {return id != node.id;}
 		      bool operator<(const Node& node) const {return id < node.id;}
 		    };
 		    class Edge {
 		      friend class ListGraphBase;
 		    protected:
 		      int id;
 		      explicit Edge(int pid) { id = pid;}
 		    public:
 		      Edge() {}
 		      Edge (Invalid) { id = -1; }
 		      bool operator==(const Edge& edge) const {return id == edge.id;}
 		      bool operator!=(const Edge& edge) const {return id != edge.id;}
 		      bool operator<(const Edge& edge) const {return id < edge.id;}
 		    };
 		    class Arc {
 		      friend class ListGraphBase;
 		    protected:
 		      int id;
 		      explicit Arc(int pid) { id = pid;}
 		    public:
 		      operator Edge() const {
 		        return id != -1 ? edgeFromId(id / 2) : INVALID;
+		      }
 		      Arc() {}
 		      Arc (Invalid) { id = -1; }
 		      bool operator==(const Arc& arc) const {return id == arc.id;}
 		      bool operator!=(const Arc& arc) const {return id != arc.id;}
 		      bool operator<(const Arc& arc) const {return id < arc.id;}
 		    };
 		    ListGraphBase()
 		      : nodes(), first_node(-1),
 		        first_free_node(-1), arcs(), first_free_arc(-1) {}
 		    int maxNodeId() const { return nodes.size()-1; }
 		    int maxEdgeId() const { return arcs.size() / 2 - 1; }
 		    int maxArcId() const { return arcs.size()-1; }
 		    Node source(Arc e) const { return Node(arcs[e.id ^ 1].target); }
 		    Node target(Arc e) const { return Node(arcs[e.id].target); }
 		    Node u(Edge e) const { return Node(arcs[2 * e.id].target); }
 		    Node v(Edge e) const { return Node(arcs[2 * e.id + 1].target); }
 		    static bool direction(Arc e) {
 		      return (e.id & 1) == 1;
+		    }
 		    static Arc direct(Edge e, bool d) {
 		      return Arc(e.id * 2 + (d ? 1 : 0));
+		    }
 		    void first(Node& node) const {
 		      node.id = first_node;
+		    }
 		    void next(Node& node) const {
 		      node.id = nodes[node.id].next;
+		    }
 		    void first(Arc& e) const {
 		      int n = first_node;
 		      while (n != -1 && nodes[n].first_out == -1) {
 		        n = nodes[n].next;
+		      }
 		      e.id = (n == -1) ? -1 : nodes[n].first_out;
+		    }
 		    void next(Arc& e) const {
 		      if (arcs[e.id].next_out != -1) {
 		        e.id = arcs[e.id].next_out;
 		      } else {
 		        int n = nodes[arcs[e.id ^ 1].target].next;
 		        while(n != -1 && nodes[n].first_out == -1) {
 		          n = nodes[n].next;
+		        }
 		        e.id = (n == -1) ? -1 : nodes[n].first_out;
+		      }
+		    }
 		    void first(Edge& e) const {
 		      int n = first_node;
 		      while (n != -1) {
 		        e.id = nodes[n].first_out;
 		        while ((e.id & 1) != 1) {
 		          e.id = arcs[e.id].next_out;
+		        }
 		        if (e.id != -1) {
 		          e.id /= 2;
 		          return;
+		        }
 		        n = nodes[n].next;
+		      }
 		      e.id = -1;
+		    }
 		    void next(Edge& e) const {
 		      int n = arcs[e.id * 2].target;
 		      e.id = arcs[(e.id * 2) | 1].next_out;
 		      while ((e.id & 1) != 1) {
 		        e.id = arcs[e.id].next_out;
+		      }
 		      if (e.id != -1) {
 		        e.id /= 2;
 		        return;
+		      }
 		      n = nodes[n].next;
 		      while (n != -1) {
 		        e.id = nodes[n].first_out;
 		        while ((e.id & 1) != 1) {
 		          e.id = arcs[e.id].next_out;
+		        }
 		        if (e.id != -1) {
 		          e.id /= 2;
 		          return;
+		        }
 		        n = nodes[n].next;
+		      }
 		      e.id = -1;
+		    }
 		    void firstOut(Arc &e, const Node& v) const {
 		      e.id = nodes[v.id].first_out;
+		    }
 		    void nextOut(Arc &e) const {
 		      e.id = arcs[e.id].next_out;
+		    }
 		    void firstIn(Arc &e, const Node& v) const {
 		      e.id = ((nodes[v.id].first_out) ^ 1);
 		      if (e.id == -2) e.id = -1;
+		    }
 		    void nextIn(Arc &e) const {
 		      e.id = ((arcs[e.id ^ 1].next_out) ^ 1);
 		      if (e.id == -2) e.id = -1;
+		    }
 		    void firstInc(Edge &e, bool& d, const Node& v) const {
 		      int a = nodes[v.id].first_out;
 		      if (a != -1 ) {
 		        e.id = a / 2;
 		        d = ((a & 1) == 1);
 		      } else {
 		        e.id = -1;
 		        d = true;
+		      }
+		    }
 		    void nextInc(Edge &e, bool& d) const {
 		      int a = (arcs[(e.id * 2) | (d ? 1 : 0)].next_out);
 		      if (a != -1 ) {
 		        e.id = a / 2;
 		        d = ((a & 1) == 1);
 		      } else {
 		        e.id = -1;
 		        d = true;
+		      }
+		    }
 		    static int id(Node v) { return v.id; }
 		    static int id(Arc e) { return e.id; }
 		    static int id(Edge e) { return e.id; }
 		    static Node nodeFromId(int id) { return Node(id);}
 		    static Arc arcFromId(int id) { return Arc(id);}
 		    static Edge edgeFromId(int id) { return Edge(id);}
 		    bool valid(Node n) const {
 		      return n.id >= 0 && n.id < static_cast<int>(nodes.size()) &&
 		        nodes[n.id].prev != -2;
+		    }
 		    bool valid(Arc a) const {
 		      return a.id >= 0 && a.id < static_cast<int>(arcs.size()) &&
 		        arcs[a.id].prev_out != -2;
+		    }
 		    bool valid(Edge e) const {
 		      return e.id >= 0 && 2 * e.id < static_cast<int>(arcs.size()) &&
 		        arcs[2 * e.id].prev_out != -2;
+		    }
 		    Node addNode() {
 		      int n;
 		      if(first_free_node==-1) {
 		        n = nodes.size();
 		        nodes.push_back(NodeT());
 		      } else {
 		        n = first_free_node;
 		        first_free_node = nodes[n].next;
+		      }
 		      nodes[n].next = first_node;
 		      if (first_node != -1) nodes[first_node].prev = n;
 		      first_node = n;
 		      nodes[n].prev = -1;
 		      nodes[n].first_out = -1;
 		      return Node(n);
+		    }
 		    Edge addEdge(Node u, Node v) {
 		      int n;
 		      if (first_free_arc == -1) {
 		        n = arcs.size();
 		        arcs.push_back(ArcT());
 		        arcs.push_back(ArcT());
 		      } else {
 		        n = first_free_arc;
 		        first_free_arc = arcs[n].next_out;
+		      }
 		      arcs[n].target = u.id;
 		      arcs[n | 1].target = v.id;
 		      arcs[n].next_out = nodes[v.id].first_out;
 		      if (nodes[v.id].first_out != -1) {
 		        arcs[nodes[v.id].first_out].prev_out = n;
+		      }
 		      arcs[n].prev_out = -1;
 		      nodes[v.id].first_out = n;
 		      arcs[n | 1].next_out = nodes[u.id].first_out;
 		      if (nodes[u.id].first_out != -1) {
 		        arcs[nodes[u.id].first_out].prev_out = (n | 1);
+		      }
 		      arcs[n | 1].prev_out = -1;
 		      nodes[u.id].first_out = (n | 1);
 		      return Edge(n / 2);
+		    }
 		    void erase(const Node& node) {
 		      int n = node.id;
 		      if(nodes[n].next != -1) {
 		        nodes[nodes[n].next].prev = nodes[n].prev;
+		      }
 		      if(nodes[n].prev != -1) {
 		        nodes[nodes[n].prev].next = nodes[n].next;
 		      } else {
 		        first_node = nodes[n].next;
+		      }
 		      nodes[n].next = first_free_node;
 		      first_free_node = n;
 		      nodes[n].prev = -2;
+		    }
 		    void erase(const Edge& edge) {
 		      int n = edge.id * 2;
 		      if (arcs[n].next_out != -1) {
 		        arcs[arcs[n].next_out].prev_out = arcs[n].prev_out;
+		      }
 		      if (arcs[n].prev_out != -1) {
 		        arcs[arcs[n].prev_out].next_out = arcs[n].next_out;
 		      } else {
 		        nodes[arcs[n | 1].target].first_out = arcs[n].next_out;
+		      }
 		      if (arcs[n | 1].next_out != -1) {
 		        arcs[arcs[n | 1].next_out].prev_out = arcs[n | 1].prev_out;
+		      }
 		      if (arcs[n | 1].prev_out != -1) {
 		        arcs[arcs[n | 1].prev_out].next_out = arcs[n | 1].next_out;
 		      } else {
 		        nodes[arcs[n].target].first_out = arcs[n | 1].next_out;
+		      }
 		      arcs[n].next_out = first_free_arc;
 		      first_free_arc = n;
 		      arcs[n].prev_out = -2;
 		      arcs[n | 1].prev_out = -2;
+		    }
 		    void clear() {
 		      arcs.clear();
 		      nodes.clear();
 		      first_node = first_free_node = first_free_arc = -1;
+		    }
 		  protected:
 		    void changeV(Edge e, Node n) {
 		      if(arcs[2 * e.id].next_out != -1) {
 		        arcs[arcs[2 * e.id].next_out].prev_out = arcs[2 * e.id].prev_out;
+		      }
 		      if(arcs[2 * e.id].prev_out != -1) {
 		        arcs[arcs[2 * e.id].prev_out].next_out =
 		          arcs[2 * e.id].next_out;
 		      } else {
 		        nodes[arcs[(2 * e.id) | 1].target].first_out =
 		          arcs[2 * e.id].next_out;
+		      }
 		      if (nodes[n.id].first_out != -1) {
 		        arcs[nodes[n.id].first_out].prev_out = 2 * e.id;
+		      }
 		      arcs[(2 * e.id) | 1].target = n.id;
 		      arcs[2 * e.id].prev_out = -1;
 		      arcs[2 * e.id].next_out = nodes[n.id].first_out;
 		      nodes[n.id].first_out = 2 * e.id;
+		    }
 		    void changeU(Edge e, Node n) {
 		      if(arcs[(2 * e.id) | 1].next_out != -1) {
 		        arcs[arcs[(2 * e.id) | 1].next_out].prev_out =
 		          arcs[(2 * e.id) | 1].prev_out;
+		      }
 		      if(arcs[(2 * e.id) | 1].prev_out != -1) {
 		        arcs[arcs[(2 * e.id) | 1].prev_out].next_out =
 		          arcs[(2 * e.id) | 1].next_out;
 		      } else {
 		        nodes[arcs[2 * e.id].target].first_out =
 		          arcs[(2 * e.id) | 1].next_out;
+		      }
 		      if (nodes[n.id].first_out != -1) {
 		        arcs[nodes[n.id].first_out].prev_out = ((2 * e.id) | 1);
+		      }
 		      arcs[2 * e.id].target = n.id;
 		      arcs[(2 * e.id) | 1].prev_out = -1;
 		      arcs[(2 * e.id) | 1].next_out = nodes[n.id].first_out;
 		      nodes[n.id].first_out = ((2 * e.id) | 1);
+		    }
 		  };
 		  typedef GraphExtender<ListGraphBase> ExtendedListGraphBase;
 		  /// \addtogroup graphs
 		  /// @{
 		  ///A general undirected graph structure.
 		  ///\ref ListGraph is a simple and fast <em>undirected graph</em>
 		  ///implementation based on static linked lists that are stored in
 		  ///\c std::vector structures.
 		  ///
 		  ///It conforms to the \ref concepts::Graph "Graph concept" and it
 		  ///also provides several useful additional functionalities.
 		  ///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()  {};
 		    ///\brief Assignment of ListGraph to another one is \e not allowed.
 		    ///Use copyGraph() instead.
 		    ///Assignment of ListGraph to another one is \e not allowed.
 		    ///Use copyGraph() instead.
 		    void operator=(const ListGraph &) {}
 		  public:
 		    /// 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.
 		    Node addNode() { return Parent::addNode(); }
 		    /// \brief Add a new edge to the graph.
 		    ///
 		    /// Add a new edge to the graph with source node \c s
 		    /// and target node \c t.
 		    /// \return The new edge.
 		    Edge addEdge(const Node& s, const Node& t) {
 		      return Parent::addEdge(s, t);
+		    }
 		    /// \brief Erase a node from the graph.
 		    ///
 		    /// Erase a node from the graph.
 		    ///
 		    void erase(const Node& n) { Parent::erase(n); }
 		    /// \brief Erase an edge from the graph.
 		    ///
 		    /// Erase an edge from the graph.
 		    ///
 		    void erase(const Edge& e) { Parent::erase(e); }
 		    /// Node validity check
 		    /// This function gives back true if the given node is valid,
 		    /// ie. it is a real node of the graph.
 		    ///
 		    /// \warning A Node pointing to a removed item
 		    /// could become valid again later if new nodes are
 		    /// added to the graph.
 		    bool valid(Node n) const { return Parent::valid(n); }
 		    /// Arc validity check
 		    /// This function gives back true if the given arc is valid,
 		    /// ie. it is a real arc of the graph.
 		    ///
 		    /// \warning An Arc pointing to a removed item
 		    /// could become valid again later if new edges are
 		    /// added to the graph.
 		    bool valid(Arc a) const { return Parent::valid(a); }
 		    /// Edge validity check
 		    /// This function gives back true if the given edge is valid,
 		    /// ie. it is a real arc of the graph.
 		    ///
 		    /// \warning A Edge pointing to a removed item
 		    /// could become valid again later if new edges are
 		    /// added to the graph.
 		    bool valid(Edge e) const { return Parent::valid(e); }
 		    /// \brief Change the end \c u of \c e to \c n
 		    ///
 		    /// This function changes the end \c u of \c e to node \c n.
 		    ///
 		    ///\note The <tt>EdgeIt</tt>s and <tt>ArcIt</tt>s referencing the
 		    ///changed edge are invalidated and if the changed node is the
 		    ///base node of an iterator then this iterator is also
 		    ///invalidated.
 		    ///
 		    ///\warning This functionality cannot be used together with the
 		    ///Snapshot feature.
 		    void changeU(Edge e, Node n) {
 		      Parent::changeU(e,n);
+		    }
 		    /// \brief Change the end \c v of \c e to \c n
 		    ///
 		    /// This function changes the end \c v of \c e to \c n.
 		    ///
 		    ///\note The <tt>EdgeIt</tt>s referencing the changed edge remain
 		    ///valid, however <tt>ArcIt</tt>s and if the changed node is the
 		    ///base node of an iterator then this iterator is invalidated.
 		    ///
 		    ///\warning This functionality cannot be used together with the
 		    ///Snapshot feature.
 		    void changeV(Edge e, Node n) {
 		      Parent::changeV(e,n);
+		    }
 		    /// \brief Contract two nodes.
 		    ///
 		    /// This function contracts two nodes.
 		    /// Node \p b will be removed but instead of deleting
 		    /// its neighboring arcs, they will be joined to \p a.
 		    /// The last parameter \p r controls whether to remove loops. \c true
 		    /// means that loops will be removed.
 		    ///
 		    /// \note The <tt>ArcIt</tt>s referencing a moved arc remain
 		    /// valid.
 		    ///
 		    ///\warning This functionality cannot be used together with the
 		    ///Snapshot feature.
 		    void contract(Node a, Node b, bool r = true) {
 		      for(IncEdgeIt e(*this, b); e!=INVALID;) {
 		        IncEdgeIt f = e; ++f;
 		        if (r && runningNode(e) == a) {
 		          erase(e);
 		        } else if (u(e) == b) {
 		          changeU(e, a);
 		        } else {
 		          changeV(e, a);
+		        }
 		        e = f;
+		      }
 		      erase(b);
+		    }
 		    /// \brief Class to make a snapshot of the graph and restore
 		    /// it later.
 		    ///
 		    /// Class to make a snapshot of the graph and restore it later.
 		    ///
 		    /// The newly added nodes and edges can be removed
 		    /// using the restore() function.
 		    ///
 		    /// \warning Edge and node deletions and other modifications
 		    /// (e.g. changing nodes of edges, contracting nodes) cannot be
 		    /// restored. These events invalidate the snapshot.
 		    class Snapshot {
 		    protected:
 		      typedef Parent::NodeNotifier NodeNotifier;
 		      class NodeObserverProxy : public NodeNotifier::ObserverBase {
 		      public:
 		        NodeObserverProxy(Snapshot& _snapshot)
 		          : snapshot(_snapshot) {}
 		        using NodeNotifier::ObserverBase::attach;
 		        using NodeNotifier::ObserverBase::detach;
 		        using NodeNotifier::ObserverBase::attached;
 		      protected:
 		        virtual void add(const Node& node) {
 		          snapshot.addNode(node);
+		        }
 		        virtual void add(const std::vector<Node>& nodes) {
 		          for (int i = nodes.size() - 1; i >= 0; ++i) {
 		            snapshot.addNode(nodes[i]);
+		          }
+		        }
 		        virtual void erase(const Node& node) {
 		          snapshot.eraseNode(node);
+		        }
 		        virtual void erase(const std::vector<Node>& nodes) {
 		          for (int i = 0; i < int(nodes.size()); ++i) {
 		            snapshot.eraseNode(nodes[i]);
+		          }
+		        }
 		        virtual void build() {
 		          Node node;
 		          std::vector<Node> nodes;
 		          for (notifier()->first(node); node != INVALID;
 		               notifier()->next(node)) {
 		            nodes.push_back(node);
+		          }
 		          for (int i = nodes.size() - 1; i >= 0; --i) {
 		            snapshot.addNode(nodes[i]);
+		          }
+		        }
 		        virtual void clear() {
 		          Node node;
 		          for (notifier()->first(node); node != INVALID;
 		               notifier()->next(node)) {
 		            snapshot.eraseNode(node);
+		          }
+		        }
 		        Snapshot& snapshot;
 		      };
 		      class EdgeObserverProxy : public EdgeNotifier::ObserverBase {
 		      public:
 		        EdgeObserverProxy(Snapshot& _snapshot)
 		          : snapshot(_snapshot) {}
 		        using EdgeNotifier::ObserverBase::attach;
 		        using EdgeNotifier::ObserverBase::detach;
 		        using EdgeNotifier::ObserverBase::attached;
 		      protected:
 		        virtual void add(const Edge& edge) {
 		          snapshot.addEdge(edge);
+		        }
 		        virtual void add(const std::vector<Edge>& edges) {
 		          for (int i = edges.size() - 1; i >= 0; ++i) {
 		            snapshot.addEdge(edges[i]);
+		          }
+		        }
 		        virtual void erase(const Edge& edge) {
 		          snapshot.eraseEdge(edge);
+		        }
 		        virtual void erase(const std::vector<Edge>& edges) {
 		          for (int i = 0; i < int(edges.size()); ++i) {
 		            snapshot.eraseEdge(edges[i]);
+		          }
+		        }
 		        virtual void build() {
 		          Edge edge;
 		          std::vector<Edge> edges;
 		          for (notifier()->first(edge); edge != INVALID;
 		               notifier()->next(edge)) {
 		            edges.push_back(edge);
+		          }
 		          for (int i = edges.size() - 1; i >= 0; --i) {
 		            snapshot.addEdge(edges[i]);
+		          }
+		        }
 		        virtual void clear() {
 		          Edge edge;
 		          for (notifier()->first(edge); edge != INVALID;
 		               notifier()->next(edge)) {
 		            snapshot.eraseEdge(edge);
+		          }
+		        }
 		        Snapshot& snapshot;
 		      };
 		      ListGraph *graph;
 		      NodeObserverProxy node_observer_proxy;
 		      EdgeObserverProxy edge_observer_proxy;
 		      std::list<Node> added_nodes;
 		      std::list<Edge> added_edges;
 		      void addNode(const Node& node) {
 		        added_nodes.push_front(node);
+		      }
 		      void eraseNode(const Node& node) {
 		        std::list<Node>::iterator it =
 		          std::find(added_nodes.begin(), added_nodes.end(), node);
 		        if (it == added_nodes.end()) {
 		          clear();
 		          edge_observer_proxy.detach();
 		          throw NodeNotifier::ImmediateDetach();
 		        } else {
 		          added_nodes.erase(it);
+		        }
+		      }
 		      void addEdge(const Edge& edge) {
 		        added_edges.push_front(edge);
+		      }
 		      void eraseEdge(const Edge& edge) {
 		        std::list<Edge>::iterator it =

lemon/maps.h

Show inline comments

@@ -1585,1198 +1585,1203 @@
 		  /// Returns a \c NotWriteMap class
 		  /// This function just returns a \c NotWriteMap class.
 		  ///
 		  /// For example, if \c m is a map with \c bool values, then
 		  /// <tt>notWriteMap(m)[x]</tt> will be equal to <tt>!m[x]</tt>.
 		  /// Moreover it makes also possible to write the map.
 		  ///
 		  /// \relates NotWriteMap
 		  template <typename M>
 		  inline NotWriteMap<M> notWriteMap(M &m) {
 		    return NotWriteMap<M>(m);
+		  }
 		  /// Combination of two maps using the \c == operator
 		  /// This \ref concepts::ReadMap "read-only map" assigns \c true to
 		  /// the keys for which the corresponding values of the two maps are
 		  /// equal.
 		  /// Its \c Key type is inherited from \c M1 and its \c Value type is
 		  /// \c bool. \c M2::Key must be convertible to \c M1::Key.
 		  ///
 		  /// If \c m1 is of type \c M1 and \c m2 is of \c M2, then for
 		  /// \code
 		  ///   EqualMap<M1,M2> em(m1,m2);
 		  /// \endcode
 		  /// <tt>em[x]</tt> will be equal to <tt>m1[x]==m2[x]</tt>.
 		  ///
 		  /// The simplest way of using this map is through the equalMap()
 		  /// function.
 		  ///
 		  /// \sa LessMap
 		  template<typename M1, typename M2>
 		  class EqualMap : public MapBase<typename M1::Key, bool> {
 		    const M1 &_m1;
 		    const M2 &_m2;
 		  public:
 		    ///\e
 		    typedef typename M1::Key Key;
 		    ///\e
 		    typedef bool Value;
 		    /// Constructor
 		    EqualMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
 		    ///\e
 		    Value operator[](const Key &k) const { return _m1[k]==_m2[k]; }
 		  };
 		  /// Returns an \c EqualMap class
 		  /// This function just returns an \c EqualMap class.
 		  ///
 		  /// For example, if \c m1 and \c m2 are maps with keys and values of
 		  /// the same type, then <tt>equalMap(m1,m2)[x]</tt> will be equal to
 		  /// <tt>m1[x]==m2[x]</tt>.
 		  ///
 		  /// \relates EqualMap
 		  template<typename M1, typename M2>
 		  inline EqualMap<M1, M2> equalMap(const M1 &m1, const M2 &m2) {
 		    return EqualMap<M1, M2>(m1,m2);
+		  }
 		  /// Combination of two maps using the \c < operator
 		  /// This \ref concepts::ReadMap "read-only map" assigns \c true to
 		  /// the keys for which the corresponding value of the first map is
 		  /// less then the value of the second map.
 		  /// Its \c Key type is inherited from \c M1 and its \c Value type is
 		  /// \c bool. \c M2::Key must be convertible to \c M1::Key.
 		  ///
 		  /// If \c m1 is of type \c M1 and \c m2 is of \c M2, then for
 		  /// \code
 		  ///   LessMap<M1,M2> lm(m1,m2);
 		  /// \endcode
 		  /// <tt>lm[x]</tt> will be equal to <tt>m1[x]<m2[x]</tt>.
 		  ///
 		  /// The simplest way of using this map is through the lessMap()
 		  /// function.
 		  ///
 		  /// \sa EqualMap
 		  template<typename M1, typename M2>
 		  class LessMap : public MapBase<typename M1::Key, bool> {
 		    const M1 &_m1;
 		    const M2 &_m2;
 		  public:
 		    ///\e
 		    typedef typename M1::Key Key;
 		    ///\e
 		    typedef bool Value;
 		    /// Constructor
 		    LessMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
 		    ///\e
 		    Value operator[](const Key &k) const { return _m1[k]<_m2[k]; }
 		  };
 		  /// Returns an \c LessMap class
 		  /// This function just returns an \c LessMap class.
 		  ///
 		  /// For example, if \c m1 and \c m2 are maps with keys and values of
 		  /// the same type, then <tt>lessMap(m1,m2)[x]</tt> will be equal to
 		  /// <tt>m1[x]<m2[x]</tt>.
 		  ///
 		  /// \relates LessMap
 		  template<typename M1, typename M2>
 		  inline LessMap<M1, M2> lessMap(const M1 &m1, const M2 &m2) {
 		    return LessMap<M1, M2>(m1,m2);
+		  }
 		  namespace _maps_bits {
 		    template <typename _Iterator, typename Enable = void>
 		    struct IteratorTraits {
 		      typedef typename std::iterator_traits<_Iterator>::value_type Value;
 		    };
 		    template <typename _Iterator>
 		    struct IteratorTraits<_Iterator,
 		      typename exists<typename _Iterator::container_type>::type>
+		    {
 		      typedef typename _Iterator::container_type::value_type Value;
 		    };
+		  }
 		  /// @}
 		  /// \addtogroup maps
 		  /// @{
 		  /// \brief Writable bool map for logging each \c true assigned element
 		  ///
 		  /// A \ref concepts::WriteMap "writable" bool map for logging
 		  /// each \c true assigned element, i.e it copies subsequently each
 		  /// keys set to \c true to the given iterator.
 		  /// The most important usage of it is storing certain nodes or arcs
 		  /// that were marked \c true by an algorithm.
 		  ///
 		  /// There are several algorithms that provide solutions through bool
 		  /// maps and most of them assign \c true at most once for each key.
 		  /// In these cases it is a natural request to store each \c true
 		  /// assigned elements (in order of the assignment), which can be
 		  /// easily done with LoggerBoolMap.
 		  ///
 		  /// The simplest way of using this map is through the loggerBoolMap()
 		  /// function.
 		  ///
 		  /// \tparam IT The type of the iterator.
 		  /// \tparam KEY The key type of the map. The default value set
 		  /// according to the iterator type should work in most cases.
 		  ///
 		  /// \note The container of the iterator must contain enough space
 		  /// for the elements or the iterator should be an inserter iterator.
 		#ifdef DOXYGEN
 		  template <typename IT, typename KEY>
 		#else
 		  template <typename IT,
 		            typename KEY = typename _maps_bits::IteratorTraits<IT>::Value>
 		#endif
 		  class LoggerBoolMap : public MapBase<KEY, bool> {
 		  public:
 		    ///\e
 		    typedef KEY Key;
 		    ///\e
 		    typedef bool Value;
 		    ///\e
 		    typedef IT Iterator;
 		    /// Constructor
 		    LoggerBoolMap(Iterator it)
 		      : _begin(it), _end(it) {}
 		    /// Gives back the given iterator set for the first key
 		    Iterator begin() const {
 		      return _begin;
+		    }
 		    /// Gives back the the 'after the last' iterator
 		    Iterator end() const {
 		      return _end;
+		    }
 		    /// The set function of the map
 		    void set(const Key& key, Value value) {
 		      if (value) {
 		        *_end++ = key;
+		      }
+		    }
 		  private:
 		    Iterator _begin;
 		    Iterator _end;
 		  };
 		  /// Returns a \c LoggerBoolMap class
 		  /// This function just returns a \c LoggerBoolMap class.
 		  ///
 		  /// The most important usage of it is storing certain nodes or arcs
 		  /// that were marked \c true by an algorithm.
 		  /// For example it makes easier to store the nodes in the processing
 		  /// order of Dfs algorithm, as the following examples show.
 		  /// \code
 		  ///   std::vector<Node> v;
 		  ///   dfs(g,s).processedMap(loggerBoolMap(std::back_inserter(v))).run();
 		  /// \endcode
 		  /// \code
 		  ///   std::vector<Node> v(countNodes(g));
 		  ///   dfs(g,s).processedMap(loggerBoolMap(v.begin())).run();
 		  /// \endcode
 		  ///
 		  /// \note The container of the iterator must contain enough space
 		  /// for the elements or the iterator should be an inserter iterator.
 		  ///
 		  /// \note LoggerBoolMap is just \ref concepts::WriteMap "writable", so
 		  /// it cannot be used when a readable map is needed, for example as
 		  /// \c ReachedMap for \c Bfs, \c Dfs and \c Dijkstra algorithms.
 		  ///
 		  /// \relates LoggerBoolMap
 		  template<typename Iterator>
 		  inline LoggerBoolMap<Iterator> loggerBoolMap(Iterator it) {
 		    return LoggerBoolMap<Iterator>(it);
+		  }
 		  /// @}
 		  /// \addtogroup graph_maps
 		  /// @{
 		  /// \brief Provides an immutable and unique id for each item in a graph.
 		  ///
 		  /// IdMap provides a unique and immutable id for each item of the
 		  /// same type (\c Node, \c Arc or \c Edge) in a graph. This id is
 		  ///  - \b unique: different items get different ids,
 		  ///  - \b immutable: the id of an item does not change (even if you
 		  ///    delete other nodes).
 		  ///
 		  /// Using this map you get access (i.e. can read) the inner id values of
 		  /// the items stored in the graph, which is returned by the \c id()
 		  /// function of the graph. This map can be inverted with its member
 		  /// class \c InverseMap or with the \c operator() member.
 		  ///
 		  /// \tparam GR The graph type.
 		  /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
 		  /// \c GR::Edge).
 		  ///
 		  /// \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;
 		    /// \brief Constructor.
 		    ///
 		    /// Constructor of the map.
 		    explicit IdMap(const Graph& graph) : _graph(&graph) {}
 		    /// \brief Gives back the \e id of the item.
 		    ///
 		    /// Gives back the immutable and unique \e id of the item.
 		    int operator[](const Item& item) const { return _graph->id(item);}
 		    /// \brief Gives back the \e item by its id.
 		    ///
 		    /// Gives back the \e item by its id.
 		    Item operator()(int id) { return _graph->fromId(id, Item()); }
 		  private:
 		    const Graph* _graph;
 		  public:
 		    /// \brief This class represents the inverse of its owner (IdMap).
 		    ///
 		    /// This class represents the inverse of its owner (IdMap).
 		    /// \see inverse()
 		    class InverseMap {
 		    public:
 		      /// \brief Constructor.
 		      ///
 		      /// Constructor for creating an id-to-item map.
 		      explicit InverseMap(const Graph& graph) : _graph(&graph) {}
 		      /// \brief Constructor.
 		      ///
 		      /// Constructor for creating an id-to-item map.
 		      explicit InverseMap(const IdMap& map) : _graph(map._graph) {}
 		      /// \brief Gives back the given item from its id.
 		      ///
 		      /// Gives back the given item from its id.
 		      Item operator[](int id) const { return _graph->fromId(id, Item());}
 		    private:
 		      const Graph* _graph;
 		    };
 		    /// \brief Gives back the inverse of the map.
 		    ///
 		    /// Gives back the inverse of the IdMap.
 		    InverseMap inverse() const { return InverseMap(*_graph);}
 		  };
 		  /// \brief General cross reference graph map type.
 		  /// This class provides simple invertable graph maps.
 		  /// It wraps an arbitrary \ref concepts::ReadWriteMap "ReadWriteMap"
 		  /// and if a key is set to a new value then store it
 		  /// in the inverse map.
 		  ///
 		  /// The values of the map can be accessed
 		  /// with stl compatible forward iterator.
 		  ///
 		  /// \tparam GR The graph type.
 		  /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
 		  /// \c GR::Edge).
 		  /// \tparam V The value type of the map.
 		  ///
 		  /// \see IterableValueMap
 		  template <typename GR, typename K, typename V>
 		  class CrossRefMap
 		    : protected ItemSetTraits<GR, K>::template Map<V>::Type {
 		  private:
 		    typedef typename ItemSetTraits<GR, K>::
 		      template Map<V>::Type Map;
 		    typedef std::map<V, K> Container;
 		    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;
 		    /// \brief Constructor.
 		    ///
 		    /// Construct a new CrossRefMap for the given graph.
 		    explicit CrossRefMap(const Graph& graph) : Map(graph) {}
 		    /// \brief Forward iterator for values.
 		    ///
 		    /// This iterator is an stl compatible forward
 		    /// iterator on the values of the map. The values can
 		    /// be accessed in the <tt>[beginValue, endValue)</tt> range.
 		    class ValueIterator
 		      : public std::iterator<std::forward_iterator_tag, Value> {
 		      friend class CrossRefMap;
 		    private:
 		      ValueIterator(typename Container::const_iterator _it)
 		        : it(_it) {}
 		    public:
 		      ValueIterator() {}
 		      ValueIterator& operator++() { ++it; return *this; }
 		      ValueIterator operator++(int) {
 		        ValueIterator tmp(*this);
 		        operator++();
 		        return tmp;
+		      }
 		      const Value& operator*() const { return it->first; }
 		      const Value* operator->() const { return &(it->first); }
 		      bool operator==(ValueIterator jt) const { return it == jt.it; }
 		      bool operator!=(ValueIterator jt) const { return it != jt.it; }
 		    private:
 		      typename Container::const_iterator it;
 		    };
 		    /// \brief Returns an iterator to the first value.
 		    ///
 		    /// Returns an stl compatible iterator to the
 		    /// first value of the map. The values of the
 		    /// map can be accessed in the <tt>[beginValue, endValue)</tt>
 		    /// range.
 		    ValueIterator beginValue() const {
 		      return ValueIterator(_inv_map.begin());
+		    }
 		    /// \brief Returns an iterator after the last value.
 		    ///
 		    /// Returns an stl compatible iterator after the
 		    /// last value of the map. The values of the
 		    /// map can be accessed in the <tt>[beginValue, endValue)</tt>
 		    /// range.
 		    ValueIterator endValue() const {
 		      return ValueIterator(_inv_map.end());
+		    }
 		    /// \brief Sets the value associated with the given key.
 		    ///
 		    /// Sets the value associated with the given key.
 		    void set(const Key& key, const Value& val) {
 		      Value oldval = Map::operator[](key);
 		      typename Container::iterator it = _inv_map.find(oldval);
 		      if (it != _inv_map.end() && it->second == key) {
 		        _inv_map.erase(it);
+		      }
 		      _inv_map.insert(make_pair(val, key));
 		      Map::set(key, val);
+		    }
 		    /// \brief Returns the value associated with the given key.
 		    ///
 		    /// Returns the value associated with the given key.
 		    typename MapTraits<Map>::ConstReturnValue
 		    operator[](const Key& key) const {
 		      return Map::operator[](key);
+		    }
 		    /// \brief Gives back the item by its value.
 		    ///
 		    /// Gives back the item by its value.
 		    Key operator()(const Value& key) const {
 		      typename Container::const_iterator it = _inv_map.find(key);
 		      return it != _inv_map.end() ? it->second : INVALID;
+		    }
 		  protected:
 		    /// \brief Erase the key from the map and the inverse map.
 		    ///
 		    /// Erase the key from the map and the inverse map. It is called by the
 		    /// \c AlterationNotifier.
 		    virtual void erase(const Key& key) {
 		      Value val = Map::operator[](key);
 		      typename Container::iterator it = _inv_map.find(val);
 		      if (it != _inv_map.end() && it->second == key) {
 		        _inv_map.erase(it);
+		      }
 		      Map::erase(key);
+		    }
 		    /// \brief Erase more keys from the map and the inverse map.
 		    ///
 		    /// Erase more keys from the map and the inverse map. It is called by the
 		    /// \c AlterationNotifier.
 		    virtual void erase(const std::vector<Key>& keys) {
 		      for (int i = 0; i < int(keys.size()); ++i) {
 		        Value val = Map::operator[](keys[i]);
 		        typename Container::iterator it = _inv_map.find(val);
 		        if (it != _inv_map.end() && it->second == keys[i]) {
 		          _inv_map.erase(it);
+		        }
+		      }
 		      Map::erase(keys);
+		    }
 		    /// \brief Clear the keys from the map and the inverse map.
 		    ///
 		    /// Clear the keys from the map and the inverse map. It is called by the
 		    /// \c AlterationNotifier.
 		    virtual void clear() {
 		      _inv_map.clear();
 		      Map::clear();
+		    }
 		  public:
 		    /// \brief The inverse map type.
 		    ///
 		    /// The inverse of this map. The subscript operator of the map
 		    /// gives back the item that was last assigned to the value.
 		    class InverseMap {
 		    public:
 		      /// \brief Constructor
 		      ///
 		      /// Constructor of the InverseMap.
 		      explicit InverseMap(const CrossRefMap& inverted)
 		        : _inverted(inverted) {}
 		      /// The value type of the InverseMap.
 		      typedef typename CrossRefMap::Key Value;
 		      /// The key type of the InverseMap.
 		      typedef typename CrossRefMap::Value Key;
 		      /// \brief Subscript operator.
 		      ///
 		      /// Subscript operator. It gives back the item
 		      /// that was last assigned to the given value.
 		      Value operator[](const Key& key) const {
 		        return _inverted(key);
+		      }
 		    private:
 		      const CrossRefMap& _inverted;
 		    };
 		    /// \brief It gives back the read-only inverse map.
 		    ///
 		    /// It gives back the read-only inverse map.
 		    InverseMap inverse() const {
 		      return InverseMap(*this);
+		    }
 		  };
 		  /// \brief Provides continuous and unique ID for the
 		  /// items of a graph.
 		  ///
 		  /// RangeIdMap provides a unique and continuous
 		  /// ID for each item of a given type (\c Node, \c Arc or
 		  /// \c Edge) in a graph. This id is
 		  ///  - \b unique: different items get different ids,
 		  ///  - \b continuous: the range of the ids is the set of integers
 		  ///    between 0 and \c n-1, where \c n is the number of the items of
 		  ///    this type (\c Node, \c Arc or \c Edge).
 		  ///  - So, the ids can change when deleting an item of the same type.
 		  ///
 		  /// Thus this id is not (necessarily) the same as what can get using
 		  /// the \c id() function of the graph or \ref IdMap.
 		  /// This map can be inverted with its member class \c InverseMap,
 		  /// or with the \c operator() member.
 		  ///
 		  /// \tparam GR The graph type.
 		  /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
 		  /// \c GR::Edge).
 		  ///
 		  /// \see IdMap
 		  template <typename GR, typename K>
 		  class RangeIdMap
 		    : protected ItemSetTraits<GR, K>::template Map<int>::Type {
 		    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;
 		    /// \brief Constructor.
 		    ///
 		    /// Constructor.
 		    explicit RangeIdMap(const Graph& gr) : Map(gr) {
 		      Item it;
 		      const typename Map::Notifier* nf = Map::notifier();
 		      for (nf->first(it); it != INVALID; nf->next(it)) {
 		        Map::set(it, _inv_map.size());
 		        _inv_map.push_back(it);
+		      }
+		    }
 		  protected:
 		    /// \brief Adds a new key to the map.
 		    ///
 		    /// Add a new key to the map. It is called by the
 		    /// \c AlterationNotifier.
 		    virtual void add(const Item& item) {
 		      Map::add(item);
 		      Map::set(item, _inv_map.size());
 		      _inv_map.push_back(item);
+		    }
 		    /// \brief Add more new keys to the map.
 		    ///
 		    /// Add more new keys to the map. It is called by the
 		    /// \c AlterationNotifier.
 		    virtual void add(const std::vector<Item>& items) {
 		      Map::add(items);
 		      for (int i = 0; i < int(items.size()); ++i) {
 		        Map::set(items[i], _inv_map.size());
 		        _inv_map.push_back(items[i]);
+		      }
+		    }
 		    /// \brief Erase the key from the map.
 		    ///
 		    /// Erase the key from the map. It is called by the
 		    /// \c AlterationNotifier.
 		    virtual void erase(const Item& item) {
 		      Map::set(_inv_map.back(), Map::operator[](item));
 		      _inv_map[Map::operator[](item)] = _inv_map.back();
 		      _inv_map.pop_back();
 		      Map::erase(item);
+		    }
 		    /// \brief Erase more keys from the map.
 		    ///
 		    /// Erase more keys from the map. It is called by the
 		    /// \c AlterationNotifier.
 		    virtual void erase(const std::vector<Item>& items) {
 		      for (int i = 0; i < int(items.size()); ++i) {
 		        Map::set(_inv_map.back(), Map::operator[](items[i]));
 		        _inv_map[Map::operator[](items[i])] = _inv_map.back();
 		        _inv_map.pop_back();
+		      }
 		      Map::erase(items);
+		    }
 		    /// \brief Build the unique map.
 		    ///
 		    /// Build the unique map. It is called by the
 		    /// \c AlterationNotifier.
 		    virtual void build() {
 		      Map::build();
 		      Item it;
 		      const typename Map::Notifier* nf = Map::notifier();
 		      for (nf->first(it); it != INVALID; nf->next(it)) {
 		        Map::set(it, _inv_map.size());
 		        _inv_map.push_back(it);
+		      }
+		    }
 		    /// \brief Clear the keys from the map.
 		    ///
 		    /// Clear the keys from the map. It is called by the
 		    /// \c AlterationNotifier.
 		    virtual void clear() {
 		      _inv_map.clear();
 		      Map::clear();
+		    }
 		  public:
 		    /// \brief Returns the maximal value plus one.
 		    ///
 		    /// Returns the maximal value plus one in the map.
 		    unsigned int size() const {
 		      return _inv_map.size();
+		    }
 		    /// \brief Swaps the position of the two items in the map.
 		    ///
 		    /// Swaps the position of the two items in the map.
 		    void swap(const Item& p, const Item& q) {
 		      int pi = Map::operator[](p);
 		      int qi = Map::operator[](q);
 		      Map::set(p, qi);
 		      _inv_map[qi] = p;
 		      Map::set(q, pi);
 		      _inv_map[pi] = q;
+		    }
 		    /// \brief Gives back the \e RangeId of the item
 		    ///
 		    /// Gives back the \e RangeId of the item.
 		    int operator[](const Item& item) const {
 		      return Map::operator[](item);
+		    }
 		    /// \brief Gives back the item belonging to a \e RangeId
 		    ///
 		    /// Gives back the item belonging to a \e RangeId.
 		    Item operator()(int id) const {
 		      return _inv_map[id];
+		    }
 		  private:
 		    typedef std::vector<Item> Container;
 		    Container _inv_map;
 		  public:
 		    /// \brief The inverse map type of RangeIdMap.
 		    ///
 		    /// The inverse map type of RangeIdMap.
 		    class InverseMap {
 		    public:
 		      /// \brief Constructor
 		      ///
 		      /// Constructor of the InverseMap.
 		      explicit InverseMap(const RangeIdMap& inverted)
 		        : _inverted(inverted) {}
 		      /// The value type of the InverseMap.
 		      typedef typename RangeIdMap::Key Value;
 		      /// The key type of the InverseMap.
 		      typedef typename RangeIdMap::Value Key;
 		      /// \brief Subscript operator.
 		      ///
 		      /// Subscript operator. It gives back the item
 		      /// that the descriptor currently belongs to.
 		      Value operator[](const Key& key) const {
 		        return _inverted(key);
+		      }
 		      /// \brief Size of the map.
 		      ///
 		      /// Returns the size of the map.
 		      unsigned int size() const {
 		        return _inverted.size();
+		      }
 		    private:
 		      const RangeIdMap& _inverted;
 		    };
 		    /// \brief Gives back the inverse of the map.
 		    ///
 		    /// Gives back the inverse of the map.
 		    const InverseMap inverse() const {
 		      return InverseMap(*this);
+		    }
 		  };
 		  /// \brief Map of the source nodes of arcs in a digraph.
 		  ///
 		  /// SourceMap provides access for the source node of each arc in a digraph,
 		  /// which is returned by the \c source() function of the digraph.
 		  /// \tparam GR The digraph type.
 		  /// \see TargetMap
 		  template <typename GR>
 		  class SourceMap {
 		  public:
 		    ///\e
 		    typedef typename GR::Arc Key;
 		    ///\e
 		    typedef typename GR::Node Value;
 		    /// \brief Constructor
 		    ///
 		    /// Constructor.
 		    /// \param digraph The digraph that the map belongs to.
 		    explicit SourceMap(const GR& digraph) : _graph(digraph) {}
 		    /// \brief Returns the source node of the given arc.
 		    ///
 		    /// Returns the source node of the given arc.
 		    Value operator[](const Key& arc) const {
 		      return _graph.source(arc);
+		    }
 		  private:
 		    const GR& _graph;
 		  };
 		  /// \brief Returns a \c SourceMap class.
 		  ///
 		  /// This function just returns an \c SourceMap class.
 		  /// \relates SourceMap
 		  template <typename GR>
 		  inline SourceMap<GR> sourceMap(const GR& graph) {
 		    return SourceMap<GR>(graph);
+		  }
 		  /// \brief Map of the target nodes of arcs in a digraph.
 		  ///
 		  /// TargetMap provides access for the target node of each arc in a digraph,
 		  /// which is returned by the \c target() function of the digraph.
 		  /// \tparam GR The digraph type.
 		  /// \see SourceMap
 		  template <typename GR>
 		  class TargetMap {
 		  public:
 		    ///\e
 		    typedef typename GR::Arc Key;
 		    ///\e
 		    typedef typename GR::Node Value;
 		    /// \brief Constructor
 		    ///
 		    /// Constructor.
 		    /// \param digraph The digraph that the map belongs to.
 		    explicit TargetMap(const GR& digraph) : _graph(digraph) {}
 		    /// \brief Returns the target node of the given arc.
 		    ///
 		    /// Returns the target node of the given arc.
 		    Value operator[](const Key& e) const {
 		      return _graph.target(e);
+		    }
 		  private:
 		    const GR& _graph;
 		  };
 		  /// \brief Returns a \c TargetMap class.
 		  ///
 		  /// This function just returns a \c TargetMap class.
 		  /// \relates TargetMap
 		  template <typename GR>
 		  inline TargetMap<GR> targetMap(const GR& graph) {
 		    return TargetMap<GR>(graph);
+		  }
 		  /// \brief Map of the "forward" directed arc view of edges in a graph.
 		  ///
 		  /// ForwardMap provides access for the "forward" directed arc view of
 		  /// each edge in a graph, which is returned by the \c direct() function
 		  /// of the graph with \c true parameter.
 		  /// \tparam GR The graph type.
 		  /// \see BackwardMap
 		  template <typename GR>
 		  class ForwardMap {
 		  public:
 		    typedef typename GR::Arc Value;
 		    typedef typename GR::Edge Key;
 		    /// \brief Constructor
 		    ///
 		    /// Constructor.
 		    /// \param graph The graph that the map belongs to.
 		    explicit ForwardMap(const GR& graph) : _graph(graph) {}
 		    /// \brief Returns the "forward" directed arc view of the given edge.
 		    ///
 		    /// Returns the "forward" directed arc view of the given edge.
 		    Value operator[](const Key& key) const {
 		      return _graph.direct(key, true);
+		    }
 		  private:
 		    const GR& _graph;
 		  };
 		  /// \brief Returns a \c ForwardMap class.
 		  ///
 		  /// This function just returns an \c ForwardMap class.
 		  /// \relates ForwardMap
 		  template <typename GR>
 		  inline ForwardMap<GR> forwardMap(const GR& graph) {
 		    return ForwardMap<GR>(graph);
+		  }
 		  /// \brief Map of the "backward" directed arc view of edges in a graph.
 		  ///
 		  /// BackwardMap provides access for the "backward" directed arc view of
 		  /// each edge in a graph, which is returned by the \c direct() function
 		  /// of the graph with \c false parameter.
 		  /// \tparam GR The graph type.
 		  /// \see ForwardMap
 		  template <typename GR>
 		  class BackwardMap {
 		  public:
 		    typedef typename GR::Arc Value;
 		    typedef typename GR::Edge Key;
 		    /// \brief Constructor
 		    ///
 		    /// Constructor.
 		    /// \param graph The graph that the map belongs to.
 		    explicit BackwardMap(const GR& graph) : _graph(graph) {}
 		    /// \brief Returns the "backward" directed arc view of the given edge.
 		    ///
 		    /// Returns the "backward" directed arc view of the given edge.
 		    Value operator[](const Key& key) const {
 		      return _graph.direct(key, false);
+		    }
 		  private:
 		    const GR& _graph;
 		  };
 		  /// \brief Returns a \c BackwardMap class
 		  /// This function just returns a \c BackwardMap class.
 		  /// \relates BackwardMap
 		  template <typename GR>
 		  inline BackwardMap<GR> backwardMap(const GR& graph) {
 		    return BackwardMap<GR>(graph);
+		  }
 		  /// \brief Map of the in-degrees of nodes in a digraph.
 		  ///
 		  /// This map returns the in-degree of a node. Once it is constructed,
 		  /// the degrees are stored in a standard \c NodeMap, so each query is done
 		  /// in constant time. On the other hand, the values are updated automatically
 		  /// whenever the digraph changes.
 		  ///
 		  /// \warning Besides \c addNode() and \c addArc(), a digraph structure
 		  /// may provide alternative ways to modify the digraph.
 		  /// The correct behavior of InDegMap is not guarantied if these additional
 		  /// features are used. For example the functions
 		  /// \ref ListDigraph::changeSource() "changeSource()",
 		  /// \ref ListDigraph::changeTarget() "changeTarget()" and
 		  /// \ref ListDigraph::reverseArc() "reverseArc()"
 		  /// of \ref ListDigraph will \e not update the degree values correctly.
 		  ///
 		  /// \sa OutDegMap
 		  template <typename GR>
 		  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;
 		    typedef typename ItemSetTraits<Digraph, typename Digraph::Arc>
 		    ::ItemNotifier::ObserverBase Parent;
 		  private:
 		    class AutoNodeMap
 		      : public ItemSetTraits<Digraph, Key>::template Map<int>::Type {
 		    public:
 		      typedef typename ItemSetTraits<Digraph, Key>::
 		      template Map<int>::Type Parent;
 		      AutoNodeMap(const Digraph& digraph) : Parent(digraph, 0) {}
 		      virtual void add(const Key& key) {
 		        Parent::add(key);
 		        Parent::set(key, 0);
+		      }
 		      virtual void add(const std::vector<Key>& keys) {
 		        Parent::add(keys);
 		        for (int i = 0; i < int(keys.size()); ++i) {
 		          Parent::set(keys[i], 0);
+		        }
+		      }
 		      virtual void build() {
 		        Parent::build();
 		        Key it;
 		        typename Parent::Notifier* nf = Parent::notifier();
 		        for (nf->first(it); it != INVALID; nf->next(it)) {
 		          Parent::set(it, 0);
+		        }
+		      }
 		    };
 		  public:
 		    /// \brief Constructor.
 		    ///
 		    /// Constructor for creating an in-degree map.
 		    explicit InDegMap(const Digraph& graph)
 		      : _digraph(graph), _deg(graph) {
 		      Parent::attach(_digraph.notifier(typename Digraph::Arc()));
 		      for(typename Digraph::NodeIt it(_digraph); it != INVALID; ++it) {
 		        _deg[it] = countInArcs(_digraph, it);
+		      }
+		    }
 		    /// \brief Gives back the in-degree of a Node.
 		    ///
 		    /// Gives back the in-degree of a Node.
 		    int operator[](const Key& key) const {
 		      return _deg[key];
+		    }
 		  protected:
 		    typedef typename Digraph::Arc Arc;
 		    virtual void add(const Arc& arc) {
 		      ++_deg[_digraph.target(arc)];
+		    }
 		    virtual void add(const std::vector<Arc>& arcs) {
 		      for (int i = 0; i < int(arcs.size()); ++i) {
 		        ++_deg[_digraph.target(arcs[i])];
+		      }
+		    }
 		    virtual void erase(const Arc& arc) {
 		      --_deg[_digraph.target(arc)];
+		    }
 		    virtual void erase(const std::vector<Arc>& arcs) {
 		      for (int i = 0; i < int(arcs.size()); ++i) {
 		        --_deg[_digraph.target(arcs[i])];
+		      }
+		    }
 		    virtual void build() {
 		      for(typename Digraph::NodeIt it(_digraph); it != INVALID; ++it) {
 		        _deg[it] = countInArcs(_digraph, it);
+		      }
+		    }
 		    virtual void clear() {
 		      for(typename Digraph::NodeIt it(_digraph); it != INVALID; ++it) {
 		        _deg[it] = 0;
+		      }
+		    }
 		  private:
 		    const Digraph& _digraph;
 		    AutoNodeMap _deg;
 		  };
 		  /// \brief Map of the out-degrees of nodes in a digraph.
 		  ///
 		  /// This map returns the out-degree of a node. Once it is constructed,
 		  /// the degrees are stored in a standard \c NodeMap, so each query is done
 		  /// in constant time. On the other hand, the values are updated automatically
 		  /// whenever the digraph changes.
 		  ///
 		  /// \warning Besides \c addNode() and \c addArc(), a digraph structure
 		  /// may provide alternative ways to modify the digraph.
 		  /// The correct behavior of OutDegMap is not guarantied if these additional
 		  /// features are used. For example the functions
 		  /// \ref ListDigraph::changeSource() "changeSource()",
 		  /// \ref ListDigraph::changeTarget() "changeTarget()" and
 		  /// \ref ListDigraph::reverseArc() "reverseArc()"
 		  /// of \ref ListDigraph will \e not update the degree values correctly.
 		  ///
 		  /// \sa InDegMap
 		  template <typename GR>
 		  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;
 		    typedef typename ItemSetTraits<Digraph, typename Digraph::Arc>
 		    ::ItemNotifier::ObserverBase Parent;
 		  private:
 		    class AutoNodeMap
 		      : public ItemSetTraits<Digraph, Key>::template Map<int>::Type {
 		    public:
 		      typedef typename ItemSetTraits<Digraph, Key>::
 		      template Map<int>::Type Parent;
 		      AutoNodeMap(const Digraph& digraph) : Parent(digraph, 0) {}
 		      virtual void add(const Key& key) {
 		        Parent::add(key);
 		        Parent::set(key, 0);
+		      }
 		      virtual void add(const std::vector<Key>& keys) {
 		        Parent::add(keys);
 		        for (int i = 0; i < int(keys.size()); ++i) {
 		          Parent::set(keys[i], 0);
+		        }
+		      }
 		      virtual void build() {
 		        Parent::build();
 		        Key it;
 		        typename Parent::Notifier* nf = Parent::notifier();
 		        for (nf->first(it); it != INVALID; nf->next(it)) {
 		          Parent::set(it, 0);
+		        }
+		      }
 		    };
 		  public:
 		    /// \brief Constructor.
 		    ///
 		    /// Constructor for creating an out-degree map.
 		    explicit OutDegMap(const Digraph& graph)
 		      : _digraph(graph), _deg(graph) {
 		      Parent::attach(_digraph.notifier(typename Digraph::Arc()));
 		      for(typename Digraph::NodeIt it(_digraph); it != INVALID; ++it) {
 		        _deg[it] = countOutArcs(_digraph, it);
+		      }
+		    }
 		    /// \brief Gives back the out-degree of a Node.
 		    ///
 		    /// Gives back the out-degree of a Node.
 		    int operator[](const Key& key) const {
 		      return _deg[key];
+		    }
 		  protected:
 		    typedef typename Digraph::Arc Arc;
 		    virtual void add(const Arc& arc) {
 		      ++_deg[_digraph.source(arc)];
+		    }
 		    virtual void add(const std::vector<Arc>& arcs) {
 		      for (int i = 0; i < int(arcs.size()); ++i) {
 		        ++_deg[_digraph.source(arcs[i])];
+		      }
+		    }
 		    virtual void erase(const Arc& arc) {
 		      --_deg[_digraph.source(arc)];
+		    }
 		    virtual void erase(const std::vector<Arc>& arcs) {
 		      for (int i = 0; i < int(arcs.size()); ++i) {
 		        --_deg[_digraph.source(arcs[i])];
+		      }
+		    }
 		    virtual void build() {
 		      for(typename Digraph::NodeIt it(_digraph); it != INVALID; ++it) {
 		        _deg[it] = countOutArcs(_digraph, it);
+		      }
+		    }
 		    virtual void clear() {
 		      for(typename Digraph::NodeIt it(_digraph); it != INVALID; ++it) {
 		        _deg[it] = 0;
+		      }
+		    }
 		  private:
 		    const Digraph& _digraph;
 		    AutoNodeMap _deg;
 		  };
 		  /// \brief Potential difference map
 		  ///
 		  /// PotentialDifferenceMap returns the difference between the potentials of
 		  /// the source and target nodes of each arc in a digraph, i.e. it returns
 		  /// \code
 		  ///   potential[gr.target(arc)] - potential[gr.source(arc)].
 		  /// \endcode
 		  /// \tparam GR The digraph type.
 		  /// \tparam POT A node map storing the potentials.
 		  template <typename GR, typename POT>
 		  class PotentialDifferenceMap {
 		  public:
 		    /// Key type
 		    typedef typename GR::Arc Key;
 		    /// Value type
 		    typedef typename POT::Value Value;
 		    /// \brief Constructor
 		    ///
 		    /// Contructor of the map.
 		    explicit PotentialDifferenceMap(const GR& gr,
 		                                    const POT& potential)
 		      : _digraph(gr), _potential(potential) {}
 		    /// \brief Returns the potential difference for the given arc.
 		    ///
 		    /// Returns the potential difference for the given arc, i.e.
 		    /// \code
 		    ///   potential[gr.target(arc)] - potential[gr.source(arc)].
 		    /// \endcode
 		    Value operator[](const Key& arc) const {
 		      return _potential[_digraph.target(arc)] -
 		        _potential[_digraph.source(arc)];
+		    }
 		  private:
 		    const GR& _digraph;
 		    const POT& _potential;
 		  };
 		  /// \brief Returns a PotentialDifferenceMap.
 		  ///
 		  /// This function just returns a PotentialDifferenceMap.
 		  /// \relates PotentialDifferenceMap
 		  template <typename GR, typename POT>
 		  PotentialDifferenceMap<GR, POT>
 		  potentialDifferenceMap(const GR& gr, const POT& potential) {
 		    return PotentialDifferenceMap<GR, POT>(gr, potential);
+		  }
 		  /// @}
+		}
 		#endif // LEMON_MAPS_H

lemon/smart_graph.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2009
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_SMART_GRAPH_H
 		#define LEMON_SMART_GRAPH_H
 		///\ingroup graphs
 		///\file
 		///\brief SmartDigraph and SmartGraph classes.
 		#include <vector>
 		#include <lemon/core.h>
 		#include <lemon/error.h>
 		#include <lemon/bits/graph_extender.h>
 		namespace lemon {
 		  class SmartDigraph;
 		  ///Base of SmartDigraph
 		  ///Base of SmartDigraph
 		  ///
 		  class SmartDigraphBase {
 		  protected:
 		    struct NodeT
+		    {
 		      int first_in, first_out;
 		      NodeT() {}
 		    };
 		    struct ArcT
+		    {
 		      int target, source, next_in, next_out;
 		      ArcT() {}
 		    };
 		    std::vector<NodeT> nodes;
 		    std::vector<ArcT> arcs;
 		  public:
-		    typedef SmartDigraphBase Graph;
+		    typedef SmartDigraphBase Digraph;
 		    class Node;
 		    class Arc;
 		  public:
 		    SmartDigraphBase() : nodes(), arcs() { }
 		    SmartDigraphBase(const SmartDigraphBase &_g)
 		      : nodes(_g.nodes), arcs(_g.arcs) { }
 		    typedef True NodeNumTag;
 		    typedef True ArcNumTag;
 		    int nodeNum() const { return nodes.size(); }
 		    int arcNum() const { return arcs.size(); }
 		    int maxNodeId() const { return nodes.size()-1; }
 		    int maxArcId() const { return arcs.size()-1; }
 		    Node addNode() {
 		      int n = nodes.size();
 		      nodes.push_back(NodeT());
 		      nodes[n].first_in = -1;
 		      nodes[n].first_out = -1;
 		      return Node(n);
+		    }
 		    Arc addArc(Node u, Node v) {
 		      int n = arcs.size();
 		      arcs.push_back(ArcT());
 		      arcs[n].source = u._id;
 		      arcs[n].target = v._id;
 		      arcs[n].next_out = nodes[u._id].first_out;
 		      arcs[n].next_in = nodes[v._id].first_in;
 		      nodes[u._id].first_out = nodes[v._id].first_in = n;
 		      return Arc(n);
+		    }
 		    void clear() {
 		      arcs.clear();
 		      nodes.clear();
+		    }
 		    Node source(Arc a) const { return Node(arcs[a._id].source); }
 		    Node target(Arc a) const { return Node(arcs[a._id].target); }
 		    static int id(Node v) { return v._id; }
 		    static int id(Arc a) { return a._id; }
 		    static Node nodeFromId(int id) { return Node(id);}
 		    static Arc arcFromId(int id) { return Arc(id);}
 		    bool valid(Node n) const {
 		      return n._id >= 0 && n._id < static_cast<int>(nodes.size());
+		    }
 		    bool valid(Arc a) const {
 		      return a._id >= 0 && a._id < static_cast<int>(arcs.size());
+		    }
 		    class Node {
 		      friend class SmartDigraphBase;
 		      friend class SmartDigraph;
 		    protected:
 		      int _id;
 		      explicit Node(int id) : _id(id) {}
 		    public:
 		      Node() {}
 		      Node (Invalid) : _id(-1) {}
 		      bool operator==(const Node i) const {return _id == i._id;}
 		      bool operator!=(const Node i) const {return _id != i._id;}
 		      bool operator<(const Node i) const {return _id < i._id;}
 		    };
 		    class Arc {
 		      friend class SmartDigraphBase;
 		      friend class SmartDigraph;
 		    protected:
 		      int _id;
 		      explicit Arc(int id) : _id(id) {}
 		    public:
 		      Arc() { }
 		      Arc (Invalid) : _id(-1) {}
 		      bool operator==(const Arc i) const {return _id == i._id;}
 		      bool operator!=(const Arc i) const {return _id != i._id;}
 		      bool operator<(const Arc i) const {return _id < i._id;}
 		    };
 		    void first(Node& node) const {
 		      node._id = nodes.size() - 1;
+		    }
 		    static void next(Node& node) {
 		      --node._id;
+		    }
 		    void first(Arc& arc) const {
 		      arc._id = arcs.size() - 1;
+		    }
 		    static void next(Arc& arc) {
 		      --arc._id;
+		    }
 		    void firstOut(Arc& arc, const Node& node) const {
 		      arc._id = nodes[node._id].first_out;
+		    }
 		    void nextOut(Arc& arc) const {
 		      arc._id = arcs[arc._id].next_out;
+		    }
 		    void firstIn(Arc& arc, const Node& node) const {
 		      arc._id = nodes[node._id].first_in;
+		    }
 		    void nextIn(Arc& arc) const {
 		      arc._id = arcs[arc._id].next_in;
+		    }
 		  };
 		  typedef DigraphExtender<SmartDigraphBase> ExtendedSmartDigraphBase;
 		  ///\ingroup graphs
 		  ///
 		  ///\brief A smart directed graph class.
 		  ///
 		  ///This is a simple and fast digraph implementation.
 		  ///It is also quite memory efficient, but at the price
 		  ///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.
 		    ///SmartDigraph is \e not copy constructible. Use DigraphCopy() instead.
 		    ///
 		    SmartDigraph(const SmartDigraph &) : ExtendedSmartDigraphBase() {};
 		    ///\brief Assignment of SmartDigraph to another one is \e not allowed.
 		    ///Use DigraphCopy() instead.
 		    ///Assignment of SmartDigraph to another one is \e not allowed.
 		    ///Use DigraphCopy() instead.
 		    void operator=(const SmartDigraph &) {}
 		  public:
 		    /// Constructor
 		    /// Constructor.
 		    ///
 		    SmartDigraph() {};
 		    ///Add a new node to the digraph.
 		    /// Add a new node to the digraph.
 		    /// \return The new node.
 		    Node addNode() { return Parent::addNode(); }
 		    ///Add a new arc to the digraph.
 		    ///Add a new arc to the digraph with source node \c s
 		    ///and target node \c t.
 		    ///\return The new arc.
 		    Arc addArc(const Node& s, const Node& t) {
 		      return Parent::addArc(s, t);
+		    }
 		    /// \brief Using this it is possible to avoid the superfluous memory
 		    /// allocation.
 		    /// Using this it is possible to avoid the superfluous memory
 		    /// allocation: if you know that the digraph you want to build will
 		    /// be very large (e.g. it will contain millions of nodes and/or arcs)
 		    /// then it is worth reserving space for this amount before starting
 		    /// to build the digraph.
 		    /// \sa reserveArc
 		    void reserveNode(int n) { nodes.reserve(n); };
 		    /// \brief Using this it is possible to avoid the superfluous memory
 		    /// allocation.
 		    /// Using this it is possible to avoid the superfluous memory
 		    /// allocation: if you know that the digraph you want to build will
 		    /// be very large (e.g. it will contain millions of nodes and/or arcs)
 		    /// then it is worth reserving space for this amount before starting
 		    /// to build the digraph.
 		    /// \sa reserveNode
 		    void reserveArc(int m) { arcs.reserve(m); };
 		    /// \brief Node validity check
 		    ///
 		    /// This function gives back true if the given node is valid,
 		    /// ie. it is a real node of the graph.
 		    ///
 		    /// \warning A removed node (using Snapshot) could become valid again
 		    /// when new nodes are added to the graph.
 		    bool valid(Node n) const { return Parent::valid(n); }
 		    /// \brief Arc validity check
 		    ///
 		    /// This function gives back true if the given arc is valid,
 		    /// ie. it is a real arc of the graph.
 		    ///
 		    /// \warning A removed arc (using Snapshot) could become valid again
 		    /// when new arcs are added to the graph.
 		    bool valid(Arc a) const { return Parent::valid(a); }
 		    ///Clear the digraph.
 		    ///Erase all the nodes and arcs from the digraph.
 		    ///
 		    void clear() {
 		      Parent::clear();
+		    }
 		    ///Split a node.
 		    ///This function splits a node. First a new node is added to the digraph,
 		    ///then the source of each outgoing arc of \c n is moved to this new node.
 		    ///If \c connect is \c true (this is the default value), then a new arc
 		    ///from \c n to the newly created node is also added.
 		    ///\return The newly created node.
 		    ///
 		    ///\note The <tt>Arc</tt>s
 		    ///referencing a moved arc remain
 		    ///valid. However <tt>InArc</tt>'s and <tt>OutArc</tt>'s
 		    ///may be invalidated.
 		    ///\warning This functionality cannot be used together with the Snapshot
 		    ///feature.
 		    Node split(Node n, bool connect = true)
+		    {
 		      Node b = addNode();
 		      nodes[b._id].first_out=nodes[n._id].first_out;
 		      nodes[n._id].first_out=-1;
 		      for(int i=nodes[b._id].first_out; i!=-1; i=arcs[i].next_out) {
 		        arcs[i].source=b._id;
+		      }
 		      if(connect) addArc(n,b);
 		      return b;
+		    }
 		  public:
 		    class Snapshot;
 		  protected:
 		    void restoreSnapshot(const Snapshot &s)
+		    {
 		      while(s.arc_num<arcs.size()) {
 		        Arc arc = arcFromId(arcs.size()-1);
 		        Parent::notifier(Arc()).erase(arc);
 		        nodes[arcs.back().source].first_out=arcs.back().next_out;
 		        nodes[arcs.back().target].first_in=arcs.back().next_in;
 		        arcs.pop_back();
+		      }
 		      while(s.node_num<nodes.size()) {
 		        Node node = nodeFromId(nodes.size()-1);
 		        Parent::notifier(Node()).erase(node);
 		        nodes.pop_back();
+		      }
+		    }
 		  public:
 		    ///Class to make a snapshot of the digraph and to restrore to it later.
 		    ///Class to make a snapshot of the digraph and to restrore to it later.
 		    ///
 		    ///The newly added nodes and arcs can be removed using the
 		    ///restore() function.
 		    ///\note After you restore a state, you cannot restore
 		    ///a later state, in other word you cannot add again the arcs deleted
 		    ///by restore() using another one Snapshot instance.
 		    ///
 		    ///\warning If you do not use correctly the snapshot that can cause
 		    ///either broken program, invalid state of the digraph, valid but
 		    ///not the restored digraph or no change. Because the runtime performance
 		    ///the validity of the snapshot is not stored.
 		    class Snapshot
+		    {
 		      SmartDigraph *_graph;
 		    protected:
 		      friend class SmartDigraph;
 		      unsigned int node_num;
 		      unsigned int arc_num;
 		    public:
 		      ///Default constructor.
 		      ///Default constructor.
 		      ///To actually make a snapshot you must call save().
 		      ///
 		      Snapshot() : _graph(0) {}
 		      ///Constructor that immediately makes a snapshot
 		      ///This constructor immediately makes a snapshot of the digraph.
 		      ///\param graph The digraph we make a snapshot of.
 		      Snapshot(SmartDigraph &graph) : _graph(&graph) {
 		        node_num=_graph->nodes.size();
 		        arc_num=_graph->arcs.size();
+		      }
 		      ///Make a snapshot.
 		      ///Make a snapshot of the digraph.
 		      ///
 		      ///This function can be called more than once. In case of a repeated
 		      ///call, the previous snapshot gets lost.
 		      ///\param graph The digraph we make the snapshot of.
 		      void save(SmartDigraph &graph)
+		      {
 		        _graph=&graph;
 		        node_num=_graph->nodes.size();
 		        arc_num=_graph->arcs.size();
+		      }
 		      ///Undo the changes until a snapshot.
 		      ///Undo the changes until a snapshot created by save().
 		      ///
 		      ///\note After you restored a state, you cannot restore
 		      ///a later state, in other word you cannot add again the arcs deleted
 		      ///by restore().
 		      void restore()
+		      {
 		        _graph->restoreSnapshot(*this);
+		      }
 		    };
 		  };
 		  class SmartGraphBase {
 		  protected:
 		    struct NodeT {
 		      int first_out;
 		    };
 		    struct ArcT {
 		      int target;
 		      int next_out;
 		    };
 		    std::vector<NodeT> nodes;
 		    std::vector<ArcT> arcs;
 		    int first_free_arc;
 		  public:
-		    typedef SmartGraphBase Digraph;
+		    typedef SmartGraphBase Graph;
 		    class Node;
 		    class Arc;
 		    class Edge;
 		    class Node {
 		      friend class SmartGraphBase;
 		    protected:
 		      int _id;
 		      explicit Node(int id) { _id = id;}
 		    public:
 		      Node() {}
 		      Node (Invalid) { _id = -1; }
 		      bool operator==(const Node& node) const {return _id == node._id;}
 		      bool operator!=(const Node& node) const {return _id != node._id;}
 		      bool operator<(const Node& node) const {return _id < node._id;}
 		    };
 		    class Edge {
 		      friend class SmartGraphBase;
 		    protected:
 		      int _id;
 		      explicit Edge(int id) { _id = id;}
 		    public:
 		      Edge() {}
 		      Edge (Invalid) { _id = -1; }
 		      bool operator==(const Edge& arc) const {return _id == arc._id;}
 		      bool operator!=(const Edge& arc) const {return _id != arc._id;}
 		      bool operator<(const Edge& arc) const {return _id < arc._id;}
 		    };
 		    class Arc {
 		      friend class SmartGraphBase;
 		    protected:
 		      int _id;
 		      explicit Arc(int id) { _id = id;}
 		    public:
 		      operator Edge() const {
 		        return _id != -1 ? edgeFromId(_id / 2) : INVALID;
+		      }
 		      Arc() {}
 		      Arc (Invalid) { _id = -1; }
 		      bool operator==(const Arc& arc) const {return _id == arc._id;}
 		      bool operator!=(const Arc& arc) const {return _id != arc._id;}
 		      bool operator<(const Arc& arc) const {return _id < arc._id;}
 		    };
 		    SmartGraphBase()
 		      : nodes(), arcs() {}
 		    typedef True NodeNumTag;
 		    typedef True EdgeNumTag;
 		    typedef True ArcNumTag;
 		    int nodeNum() const { return nodes.size(); }
 		    int edgeNum() const { return arcs.size() / 2; }
 		    int arcNum() const { return arcs.size(); }
 		    int maxNodeId() const { return nodes.size()-1; }
 		    int maxEdgeId() const { return arcs.size() / 2 - 1; }
 		    int maxArcId() const { return arcs.size()-1; }
 		    Node source(Arc e) const { return Node(arcs[e._id ^ 1].target); }
 		    Node target(Arc e) const { return Node(arcs[e._id].target); }
 		    Node u(Edge e) const { return Node(arcs[2 * e._id].target); }
 		    Node v(Edge e) const { return Node(arcs[2 * e._id + 1].target); }
 		    static bool direction(Arc e) {
 		      return (e._id & 1) == 1;
+		    }
 		    static Arc direct(Edge e, bool d) {
 		      return Arc(e._id * 2 + (d ? 1 : 0));
+		    }
 		    void first(Node& node) const {
 		      node._id = nodes.size() - 1;
+		    }
 		    void next(Node& node) const {
 		      --node._id;
+		    }
 		    void first(Arc& arc) const {
 		      arc._id = arcs.size() - 1;
+		    }
 		    void next(Arc& arc) const {
 		      --arc._id;
+		    }
 		    void first(Edge& arc) const {
 		      arc._id = arcs.size() / 2 - 1;
+		    }
 		    void next(Edge& arc) const {
 		      --arc._id;
+		    }
 		    void firstOut(Arc &arc, const Node& v) const {
 		      arc._id = nodes[v._id].first_out;
+		    }
 		    void nextOut(Arc &arc) const {
 		      arc._id = arcs[arc._id].next_out;
+		    }
 		    void firstIn(Arc &arc, const Node& v) const {
 		      arc._id = ((nodes[v._id].first_out) ^ 1);
 		      if (arc._id == -2) arc._id = -1;
+		    }
 		    void nextIn(Arc &arc) const {
 		      arc._id = ((arcs[arc._id ^ 1].next_out) ^ 1);
 		      if (arc._id == -2) arc._id = -1;
+		    }
 		    void firstInc(Edge &arc, bool& d, const Node& v) const {
 		      int de = nodes[v._id].first_out;
 		      if (de != -1) {
 		        arc._id = de / 2;
 		        d = ((de & 1) == 1);
 		      } else {
 		        arc._id = -1;
 		        d = true;
+		      }
+		    }
 		    void nextInc(Edge &arc, bool& d) const {
 		      int de = (arcs[(arc._id * 2) | (d ? 1 : 0)].next_out);
 		      if (de != -1) {
 		        arc._id = de / 2;
 		        d = ((de & 1) == 1);
 		      } else {
 		        arc._id = -1;
 		        d = true;
+		      }
+		    }
 		    static int id(Node v) { return v._id; }
 		    static int id(Arc e) { return e._id; }
 		    static int id(Edge e) { return e._id; }
 		    static Node nodeFromId(int id) { return Node(id);}
 		    static Arc arcFromId(int id) { return Arc(id);}
 		    static Edge edgeFromId(int id) { return Edge(id);}
 		    bool valid(Node n) const {
 		      return n._id >= 0 && n._id < static_cast<int>(nodes.size());
+		    }
 		    bool valid(Arc a) const {
 		      return a._id >= 0 && a._id < static_cast<int>(arcs.size());
+		    }
 		    bool valid(Edge e) const {
 		      return e._id >= 0 && 2 * e._id < static_cast<int>(arcs.size());
+		    }
 		    Node addNode() {
 		      int n = nodes.size();
 		      nodes.push_back(NodeT());
 		      nodes[n].first_out = -1;
 		      return Node(n);
+		    }
 		    Edge addEdge(Node u, Node v) {
 		      int n = arcs.size();
 		      arcs.push_back(ArcT());
 		      arcs.push_back(ArcT());
 		      arcs[n].target = u._id;
 		      arcs[n | 1].target = v._id;
 		      arcs[n].next_out = nodes[v._id].first_out;
 		      nodes[v._id].first_out = n;
 		      arcs[n | 1].next_out = nodes[u._id].first_out;
 		      nodes[u._id].first_out = (n | 1);
 		      return Edge(n / 2);
+		    }
 		    void clear() {
 		      arcs.clear();
 		      nodes.clear();
+		    }
 		  };
 		  typedef GraphExtender<SmartGraphBase> ExtendedSmartGraphBase;
 		  /// \ingroup graphs
 		  ///
 		  /// \brief A smart undirected graph class.
 		  ///
 		  /// This is a simple and fast graph implementation.
 		  /// It is also quite memory efficient, but at the price
 		  /// 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.
 		    ///
 		    SmartGraph(const SmartGraph &) : ExtendedSmartGraphBase() {};
 		    ///\brief Assignment of SmartGraph to another one is \e not allowed.
 		    ///Use GraphCopy() instead.
 		    ///Assignment of SmartGraph to another one is \e not allowed.
 		    ///Use GraphCopy() instead.
 		    void operator=(const SmartGraph &) {}
 		  public:
 		    typedef ExtendedSmartGraphBase Parent;
 		    /// Constructor
 		    /// Constructor.
 		    ///
 		    SmartGraph() {}
 		    ///Add a new node to the graph.
 		    /// Add a new node to the graph.
 		    /// \return The new node.
 		    Node addNode() { return Parent::addNode(); }
 		    ///Add a new edge to the graph.
 		    ///Add a new edge to the graph with node \c s
 		    ///and \c t.
 		    ///\return The new edge.
 		    Edge addEdge(const Node& s, const Node& t) {
 		      return Parent::addEdge(s, t);
+		    }
 		    /// \brief Node validity check
 		    ///
 		    /// This function gives back true if the given node is valid,
 		    /// ie. it is a real node of the graph.
 		    ///
 		    /// \warning A removed node (using Snapshot) could become valid again
 		    /// when new nodes are added to the graph.
 		    bool valid(Node n) const { return Parent::valid(n); }
 		    /// \brief Arc validity check
 		    ///
 		    /// This function gives back true if the given arc is valid,
 		    /// ie. it is a real arc of the graph.
 		    ///
 		    /// \warning A removed arc (using Snapshot) could become valid again
 		    /// when new edges are added to the graph.
 		    bool valid(Arc a) const { return Parent::valid(a); }
 		    /// \brief Edge validity check
 		    ///
 		    /// This function gives back true if the given edge is valid,
 		    /// ie. it is a real edge of the graph.
 		    ///
 		    /// \warning A removed edge (using Snapshot) could become valid again
 		    /// when new edges are added to the graph.
 		    bool valid(Edge e) const { return Parent::valid(e); }
 		    ///Clear the graph.
 		    ///Erase all the nodes and edges from the graph.
 		    ///
 		    void clear() {
 		      Parent::clear();
+		    }
 		  public:
 		    class Snapshot;
 		  protected:
 		    void saveSnapshot(Snapshot &s)
+		    {
 		      s._graph = this;
 		      s.node_num = nodes.size();
 		      s.arc_num = arcs.size();
+		    }
 		    void restoreSnapshot(const Snapshot &s)
+		    {
 		      while(s.arc_num<arcs.size()) {
 		        int n=arcs.size()-1;
 		        Edge arc=edgeFromId(n/2);
 		        Parent::notifier(Edge()).erase(arc);
 		        std::vector<Arc> dir;
 		        dir.push_back(arcFromId(n));
 		        dir.push_back(arcFromId(n-1));
 		        Parent::notifier(Arc()).erase(dir);
 		        nodes[arcs[n-1].target].first_out=arcs[n].next_out;
 		        nodes[arcs[n].target].first_out=arcs[n-1].next_out;
 		        arcs.pop_back();
 		        arcs.pop_back();
+		      }
 		      while(s.node_num<nodes.size()) {
 		        int n=nodes.size()-1;
 		        Node node = nodeFromId(n);
 		        Parent::notifier(Node()).erase(node);
 		        nodes.pop_back();
+		      }
+		    }
 		  public:
 		    ///Class to make a snapshot of the digraph and to restrore to it later.
 		    ///Class to make a snapshot of the digraph and to restrore to it later.
 		    ///
 		    ///The newly added nodes and arcs can be removed using the
 		    ///restore() function.
 		    ///
 		    ///\note After you restore a state, you cannot restore
 		    ///a later state, in other word you cannot add again the arcs deleted
 		    ///by restore() using another one Snapshot instance.
 		    ///
 		    ///\warning If you do not use correctly the snapshot that can cause
 		    ///either broken program, invalid state of the digraph, valid but
 		    ///not the restored digraph or no change. Because the runtime performance
 		    ///the validity of the snapshot is not stored.
 		    class Snapshot
+		    {
 		      SmartGraph *_graph;
 		    protected:
 		      friend class SmartGraph;
 		      unsigned int node_num;
 		      unsigned int arc_num;
 		    public:
 		      ///Default constructor.
 		      ///Default constructor.
 		      ///To actually make a snapshot you must call save().
 		      ///
 		      Snapshot() : _graph(0) {}
 		      ///Constructor that immediately makes a snapshot
 		      ///This constructor immediately makes a snapshot of the digraph.
 		      ///\param graph The digraph we make a snapshot of.
 		      Snapshot(SmartGraph &graph) {
 		        graph.saveSnapshot(*this);
+		      }
 		      ///Make a snapshot.
 		      ///Make a snapshot of the graph.
 		      ///
 		      ///This function can be called more than once. In case of a repeated
 		      ///call, the previous snapshot gets lost.
 		      ///\param graph The digraph we make the snapshot of.
 		      void save(SmartGraph &graph)
+		      {
 		        graph.saveSnapshot(*this);
+		      }
 		      ///Undo the changes until a snapshot.
 		      ///Undo the changes until a snapshot created by save().
 		      ///
 		      ///\note After you restored a state, you cannot restore
 		      ///a later state, in other word you cannot add again the arcs deleted
 		      ///by restore().
 		      void restore()
+		      {
 		        _graph->restoreSnapshot(*this);
+		      }
 		    };
 		  };
 		} //namespace lemon
 		#endif //LEMON_SMART_GRAPH_H

0 comments (0 inline)

RhodeCode

Login to your account

1	1	/* -- mode: C++; indent-tabs-mode: nil; --
2	2	*
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).
8	8	*
9	9	* Permission to use, modify and distribute this software is granted
10	10	* provided that this copyright notice appears in all copies. For
11	11	* precise terms see the accompanying LICENSE file.
12	12	*
13	13	* This software is provided "AS IS" with no warranty of any kind,
14	14	* express or implied, and with no claim as to its suitability for any
15	15	* purpose.
16	16	*
17	17	*/
18	18
19	19	#ifndef LEMON_BITS_BASE_EXTENDER_H
20	20	#define LEMON_BITS_BASE_EXTENDER_H
21	21
22	22	#include <lemon/core.h>
23	23	#include <lemon/error.h>
24	24
25	25	#include <lemon/bits/map_extender.h>
26	26	#include <lemon/bits/default_map.h>
27	27
28	28	#include <lemon/concept_check.h>
29	29	#include <lemon/concepts/maps.h>
30	30
31	31	//\ingroup digraphbits
32	32	//\file
33	33	//\brief Extenders for the graph types
34	34	namespace lemon {
35	35
36	36	// \ingroup digraphbits
37	37	//
38	38	// \brief BaseDigraph to BaseGraph extender
39	39	template <typename Base>
40	40	class UndirDigraphExtender : public Base {
	41	typedef Base Parent;
41	42
42	43	public:
43	44
44		typedef Base Parent;
45	45	typedef typename Parent::Arc Edge;
46	46	typedef typename Parent::Node Node;
47	47
48	48	typedef True UndirectedTag;
49	49
50	50	class Arc : public Edge {
51	51	friend class UndirDigraphExtender;
52	52
53	53	protected:
54	54	bool forward;
55	55
56	56	Arc(const Edge &ue, bool _forward) :
57	57	Edge(ue), forward(_forward) {}
58	58
59	59	public:
60	60	Arc() {}
61	61
62	62	// Invalid arc constructor
63	63	Arc(Invalid i) : Edge(i), forward(true) {}
64	64
65	65	bool operator==(const Arc &that) const {
66	66	return forward==that.forward && Edge(*this)==Edge(that);
67	67	}
68	68	bool operator!=(const Arc &that) const {
69	69	return forward!=that.forward \|\| Edge(*this)!=Edge(that);
70	70	}
71	71	bool operator<(const Arc &that) const {
72	72	return forward<that.forward \|\|
73	73	(!(that.forward<forward) && Edge(*this)<Edge(that));
74	74	}
75	75	};
76	76
77	77	// First node of the edge
78	78	Node u(const Edge &e) const {
79	79	return Parent::source(e);
80	80	}
81	81
82	82	// Source of the given arc
83	83	Node source(const Arc &e) const {
84	84	return e.forward ? Parent::source(e) : Parent::target(e);
85	85	}
86	86
87	87	// Second node of the edge
88	88	Node v(const Edge &e) const {
89	89	return Parent::target(e);
90	90	}
91	91
92	92	// Target of the given arc
93	93	Node target(const Arc &e) const {
94	94	return e.forward ? Parent::target(e) : Parent::source(e);
95	95	}
96	96
97	97	// \brief Directed arc from an edge.
98	98	//
99	99	// Returns a directed arc corresponding to the specified edge.
100	100	// If the given bool is true, the first node of the given edge and
101	101	// the source node of the returned arc are the same.
102	102	static Arc direct(const Edge &e, bool d) {
103	103	return Arc(e, d);
104	104	}
105	105
106	106	// Returns whether the given directed arc has the same orientation
107	107	// as the corresponding edge.
108	108	static bool direction(const Arc &a) { return a.forward; }
109	109
110	110	using Parent::first;
111	111	using Parent::next;
112	112
113	113	void first(Arc &e) const {
114	114	Parent::first(e);
115	115	e.forward=true;
116	116	}
117	117
118	118	void next(Arc &e) const {
119	119	if( e.forward ) {
120	120	e.forward = false;
121	121	}
122	122	else {
123	123	Parent::next(e);
124	124	e.forward = true;
125	125	}
126	126	}
127	127
128	128	void firstOut(Arc &e, const Node &n) const {
129	129	Parent::firstIn(e,n);
130	130	if( Edge(e) != INVALID ) {
131	131	e.forward = false;
132	132	}
133	133	else {
134	134	Parent::firstOut(e,n);
135	135	e.forward = true;
136	136	}
137	137	}
138	138	void nextOut(Arc &e) const {
139	139	if( ! e.forward ) {
140	140	Node n = Parent::target(e);
141	141	Parent::nextIn(e);
142	142	if( Edge(e) == INVALID ) {
143	143	Parent::firstOut(e, n);
144	144	e.forward = true;
145	145	}
146	146	}
147	147	else {
148	148	Parent::nextOut(e);
149	149	}
150	150	}
151	151
152	152	void firstIn(Arc &e, const Node &n) const {
153	153	Parent::firstOut(e,n);
154	154	if( Edge(e) != INVALID ) {
155	155	e.forward = false;
156	156	}
157	157	else {
158	158	Parent::firstIn(e,n);
159	159	e.forward = true;
160	160	}
161	161	}
162	162	void nextIn(Arc &e) const {
163	163	if( ! e.forward ) {
164	164	Node n = Parent::source(e);
165	165	Parent::nextOut(e);
166	166	if( Edge(e) == INVALID ) {
167	167	Parent::firstIn(e, n);
168	168	e.forward = true;
169	169	}
170	170	}
171	171	else {
172	172	Parent::nextIn(e);
173	173	}
174	174	}
175	175
176	176	void firstInc(Edge &e, bool &d, const Node &n) const {
177	177	d = true;
178	178	Parent::firstOut(e, n);
179	179	if (e != INVALID) return;
180	180	d = false;
181	181	Parent::firstIn(e, n);
182	182	}
183	183
184	184	void nextInc(Edge &e, bool &d) const {
185	185	if (d) {
186	186	Node s = Parent::source(e);
187	187	Parent::nextOut(e);
188	188	if (e != INVALID) return;
189	189	d = false;
190	190	Parent::firstIn(e, s);
191	191	} else {
192	192	Parent::nextIn(e);
193	193	}
194	194	}
195	195
196	196	Node nodeFromId(int ix) const {
197	197	return Parent::nodeFromId(ix);
198	198	}
199	199
200	200	Arc arcFromId(int ix) const {
201	201	return direct(Parent::arcFromId(ix >> 1), bool(ix & 1));
202	202	}
203	203
204	204	Edge edgeFromId(int ix) const {
205	205	return Parent::arcFromId(ix);
206	206	}
207	207
208	208	int id(const Node &n) const {
209	209	return Parent::id(n);
210	210	}
211	211
212	212	int id(const Edge &e) const {
213	213	return Parent::id(e);
214	214	}
215	215
216	216	int id(const Arc &e) const {
217	217	return 2 * Parent::id(e) + int(e.forward);
218	218	}
219	219
220	220	int maxNodeId() const {
221	221	return Parent::maxNodeId();
222	222	}
223	223
224	224	int maxArcId() const {
225	225	return 2 * Parent::maxArcId() + 1;
226	226	}
227	227
228	228	int maxEdgeId() const {
229	229	return Parent::maxArcId();
230	230	}
231	231
232	232	int arcNum() const {
233	233	return 2 * Parent::arcNum();
234	234	}
235	235
236	236	int edgeNum() const {
237	237	return Parent::arcNum();
238	238	}
239	239
240	240	Arc findArc(Node s, Node t, Arc p = INVALID) const {
241	241	if (p == INVALID) {
242	242	Edge arc = Parent::findArc(s, t);
243	243	if (arc != INVALID) return direct(arc, true);
244	244	arc = Parent::findArc(t, s);
245	245	if (arc != INVALID) return direct(arc, false);
246	246	} else if (direction(p)) {
247	247	Edge arc = Parent::findArc(s, t, p);
248	248	if (arc != INVALID) return direct(arc, true);
249	249	arc = Parent::findArc(t, s);
250	250	if (arc != INVALID) return direct(arc, false);
251	251	} else {
252	252	Edge arc = Parent::findArc(t, s, p);
253	253	if (arc != INVALID) return direct(arc, false);
254	254	}
255	255	return INVALID;
256	256	}
257	257
258	258	Edge findEdge(Node s, Node t, Edge p = INVALID) const {
259	259	if (s != t) {
260	260	if (p == INVALID) {
261	261	Edge arc = Parent::findArc(s, t);
262	262	if (arc != INVALID) return arc;
263	263	arc = Parent::findArc(t, s);
264	264	if (arc != INVALID) return arc;
265	265	} else if (Parent::s(p) == s) {
266	266	Edge arc = Parent::findArc(s, t, p);
267	267	if (arc != INVALID) return arc;
268	268	arc = Parent::findArc(t, s);
269	269	if (arc != INVALID) return arc;
270	270	} else {
271	271	Edge arc = Parent::findArc(t, s, p);
272	272	if (arc != INVALID) return arc;
273	273	}
274	274	} else {
275	275	return Parent::findArc(s, t, p);
276	276	}
277	277	return INVALID;
278	278	}
279	279	};
280	280
281	281	template <typename Base>
282	282	class BidirBpGraphExtender : public Base {
	283	typedef Base Parent;
	284
283	285	public:
284		typedef Base Parent;
285	286	typedef BidirBpGraphExtender Digraph;
286	287
287	288	typedef typename Parent::Node Node;
288	289	typedef typename Parent::Edge Edge;
289	290
290	291
291	292	using Parent::first;
292	293	using Parent::next;
293	294
294	295	using Parent::id;
295	296
296	297	class Red : public Node {
297	298	friend class BidirBpGraphExtender;
298	299	public:
299	300	Red() {}
300	301	Red(const Node& node) : Node(node) {
301	302	LEMON_DEBUG(Parent::red(node) \|\| node == INVALID,
302	303	typename Parent::NodeSetError());
303	304	}
304	305	Red& operator=(const Node& node) {
305	306	LEMON_DEBUG(Parent::red(node) \|\| node == INVALID,
306	307	typename Parent::NodeSetError());
307	308	Node::operator=(node);
308	309	return *this;
309	310	}
310	311	Red(Invalid) : Node(INVALID) {}
311	312	Red& operator=(Invalid) {
312	313	Node::operator=(INVALID);
313	314	return *this;
314	315	}
315	316	};
316	317
317	318	void first(Red& node) const {
318	319	Parent::firstRed(static_cast<Node&>(node));
319	320	}
320	321	void next(Red& node) const {
321	322	Parent::nextRed(static_cast<Node&>(node));
322	323	}
323	324
324	325	int id(const Red& node) const {
325	326	return Parent::redId(node);
326	327	}
327	328
328	329	class Blue : public Node {
329	330	friend class BidirBpGraphExtender;
330	331	public:
331	332	Blue() {}
332	333	Blue(const Node& node) : Node(node) {
333	334	LEMON_DEBUG(Parent::blue(node) \|\| node == INVALID,
334	335	typename Parent::NodeSetError());
335	336	}
336	337	Blue& operator=(const Node& node) {
337	338	LEMON_DEBUG(Parent::blue(node) \|\| node == INVALID,
338	339	typename Parent::NodeSetError());
339	340	Node::operator=(node);
340	341	return *this;
341	342	}
342	343	Blue(Invalid) : Node(INVALID) {}
343	344	Blue& operator=(Invalid) {
344	345	Node::operator=(INVALID);
345	346	return *this;
346	347	}
347	348	};
348	349
349	350	void first(Blue& node) const {
350	351	Parent::firstBlue(static_cast<Node&>(node));
351	352	}
352	353	void next(Blue& node) const {
353	354	Parent::nextBlue(static_cast<Node&>(node));
354	355	}
355	356
356	357	int id(const Blue& node) const {
357	358	return Parent::redId(node);
358	359	}
359	360
360	361	Node source(const Edge& arc) const {
361	362	return red(arc);
362	363	}
363	364	Node target(const Edge& arc) const {
364	365	return blue(arc);
365	366	}
366	367
367	368	void firstInc(Edge& arc, bool& dir, const Node& node) const {
368	369	if (Parent::red(node)) {
369	370	Parent::firstFromRed(arc, node);
370	371	dir = true;
371	372	} else {
372	373	Parent::firstFromBlue(arc, node);
373	374	dir = static_cast<Edge&>(arc) == INVALID;
374	375	}
375	376	}
376	377	void nextInc(Edge& arc, bool& dir) const {
377	378	if (dir) {
378	379	Parent::nextFromRed(arc);
379	380	} else {
380	381	Parent::nextFromBlue(arc);
381	382	if (arc == INVALID) dir = true;
382	383	}
383	384	}
384	385
385	386	class Arc : public Edge {
386	387	friend class BidirBpGraphExtender;
387	388	protected:
388	389	bool forward;
389	390
390	391	Arc(const Edge& arc, bool _forward)
391	392	: Edge(arc), forward(_forward) {}
392	393
393	394	public:
394	395	Arc() {}
395	396	Arc (Invalid) : Edge(INVALID), forward(true) {}
396	397	bool operator==(const Arc& i) const {
397	398	return Edge::operator==(i) && forward == i.forward;
398	399	}
399	400	bool operator!=(const Arc& i) const {
400	401	return Edge::operator!=(i) \|\| forward != i.forward;
401	402	}
402	403	bool operator<(const Arc& i) const {
403	404	return Edge::operator<(i) \|\|
404	405	(!(i.forward<forward) && Edge(*this)<Edge(i));
405	406	}
406	407	};
407	408
408	409	void first(Arc& arc) const {
409	410	Parent::first(static_cast<Edge&>(arc));
410	411	arc.forward = true;
411	412	}
412	413
413	414	void next(Arc& arc) const {
414	415	if (!arc.forward) {
415	416	Parent::next(static_cast<Edge&>(arc));
416	417	}
417	418	arc.forward = !arc.forward;
418	419	}
419	420
420	421	void firstOut(Arc& arc, const Node& node) const {
421	422	if (Parent::red(node)) {
422	423	Parent::firstFromRed(arc, node);
423	424	arc.forward = true;
424	425	} else {
425	426	Parent::firstFromBlue(arc, node);
426	427	arc.forward = static_cast<Edge&>(arc) == INVALID;
427	428	}
428	429	}
429	430	void nextOut(Arc& arc) const {
430	431	if (arc.forward) {
431	432	Parent::nextFromRed(arc);
432	433	} else {
433	434	Parent::nextFromBlue(arc);
434	435	arc.forward = static_cast<Edge&>(arc) == INVALID;
435	436	}
436	437	}
437	438
438	439	void firstIn(Arc& arc, const Node& node) const {
439	440	if (Parent::blue(node)) {
440	441	Parent::firstFromBlue(arc, node);
441	442	arc.forward = true;
442	443	} else {
443	444	Parent::firstFromRed(arc, node);
444	445	arc.forward = static_cast<Edge&>(arc) == INVALID;
445	446	}
446	447	}
447	448	void nextIn(Arc& arc) const {
448	449	if (arc.forward) {
449	450	Parent::nextFromBlue(arc);
450	451	} else {
451	452	Parent::nextFromRed(arc);
452	453	arc.forward = static_cast<Edge&>(arc) == INVALID;
453	454	}
454	455	}
455	456
456	457	Node source(const Arc& arc) const {
457	458	return arc.forward ? Parent::red(arc) : Parent::blue(arc);
458	459	}
459	460	Node target(const Arc& arc) const {
460	461	return arc.forward ? Parent::blue(arc) : Parent::red(arc);
461	462	}
462	463
463	464	int id(const Arc& arc) const {
464	465	return (Parent::id(static_cast<const Edge&>(arc)) << 1) +
465	466	(arc.forward ? 0 : 1);
466	467	}
467	468	Arc arcFromId(int ix) const {
468	469	return Arc(Parent::fromEdgeId(ix >> 1), (ix & 1) == 0);
469	470	}
470	471	int maxArcId() const {
471	472	return (Parent::maxEdgeId() << 1) + 1;
472	473	}
473	474
474	475	bool direction(const Arc& arc) const {
475	476	return arc.forward;
476	477	}
477	478
478	479	Arc direct(const Edge& arc, bool dir) const {
479	480	return Arc(arc, dir);
480	481	}
481	482
482	483	int arcNum() const {
483	484	return 2 * Parent::edgeNum();
484	485	}
485	486
486	487	int edgeNum() const {
487	488	return Parent::edgeNum();
488	489	}
489	490
490	491
491	492	};
492	493	}
493	494
494	495	#endif