LEMON/LEMON-official Changeset - r664:4137ef9aacc6

Repositories » LEMON » LEMON-official

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

Changeset - r664:4137ef9aacc6

« 663:f2d6d3

665:b95898 »

r664:4137ef9aacc6

Fri, 24 Apr 2009 11:54:48

[Not Reviewed]

0 comments (0 inline)

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

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

0 19 0

default

19 files changed with 298 insertions and 277 deletions:

lemon/adaptors.h

lemon/bits/array_map.h

lemon/bits/base_extender.h

lemon/bits/default_map.h

lemon/bits/edge_set_extender.h

lemon/bits/graph_adaptor_extender.h

lemon/bits/graph_extender.h

lemon/bits/map_extender.h

lemon/bits/vector_map.h

lemon/concepts/graph_components.h

lemon/core.h

lemon/edge_set.h

lemon/full_graph.h

lemon/graph_to_eps.h

lemon/grid_graph.h

lemon/hypercube_graph.h

lemon/list_graph.h

lemon/maps.h

lemon/smart_graph.h

↑ Collapse diff ↑

lemon/adaptors.h

Show inline comments

@@ -80,96 +80,92 @@
 		    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) {}
@@ -226,219 +222,222 @@
 		    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);
@@ -480,124 +479,126 @@
 		                              || !(*_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);
+		    }
@@ -621,94 +622,96 @@
 		    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.
 		  ///
@@ -834,71 +837,71 @@
 		             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);
+		    }
@@ -987,151 +990,154 @@
 		    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);
+		    }
@@ -1182,120 +1188,123 @@
 		    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.
@@ -1456,135 +1465,138 @@
 		  /// 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>
@@ -1600,74 +1612,75 @@
 		  /// 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
@@ -1709,74 +1722,75 @@
 		  /// 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); }
@@ -2082,120 +2096,120 @@
 		          _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) {}
@@ -2209,68 +2223,68 @@
 		  };
 		  /// \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;
@@ -2420,93 +2434,93 @@
 		    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
@@ -2517,75 +2531,77 @@
 		  /// 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>
@@ -2837,68 +2853,69 @@
 		        : _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;
+		      }
@@ -3199,95 +3216,95 @@
 		        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
@@ -3295,67 +3312,68 @@
 		  /// \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.

lemon/bits/array_map.h

Show inline comments

@@ -18,109 +18,113 @@
 		#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

lemon/bits/base_extender.h

Show inline comments

@@ -9,68 +9,68 @@
 		 * 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));
+		      }
 		    };
@@ -251,66 +251,67 @@
 		      } 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;
+		      }
 		    };

lemon/bits/default_map.h

Show inline comments

@@ -124,58 +124,59 @@
 		  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

@@ -5,67 +5,68 @@
 		 * 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;
+		    }
@@ -189,131 +190,129 @@
 		    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;
+		    }
@@ -321,282 +320,280 @@
 		    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();
+		    }

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;
    }
@@ -144,67 +145,68 @@
        : _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);
    }

lemon/bits/graph_extender.h

Show inline comments

@@ -8,67 +8,68 @@
+		 *
 		 * 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;
+		    }
@@ -189,93 +190,91 @@
 		    // \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();
@@ -301,67 +300,68 @@
 		      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);
@@ -572,118 +572,115 @@
 		    // \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));

lemon/bits/map_extender.h

Show inline comments

@@ -7,323 +7,322 @@
 		 * (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

@@ -27,103 +27,107 @@
 		#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

lemon/concepts/graph_components.h

Show inline comments

@@ -151,76 +151,79 @@
+		      }
 		      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.
@@ -962,199 +965,197 @@
 		      /// 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 {
@@ -1192,67 +1193,67 @@
 		          } { // 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 {

lemon/core.h

Show inline comments

@@ -1007,95 +1007,94 @@
 		  /// 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;
@@ -1130,178 +1129,182 @@
 		  /// 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) {
@@ -1601,66 +1604,69 @@
 		            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;
@@ -1717,85 +1723,88 @@
 		      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]);
+		    }

lemon/edge_set.h

Show inline comments

@@ -4,65 +4,64 @@
+		 *
 		 * 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;
@@ -179,211 +178,206 @@
 		    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;
+		    }
@@ -608,209 +602,204 @@
+		    }
 		    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>;
@@ -871,150 +860,147 @@
 		    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() {
@@ -1033,65 +1019,64 @@
 		    /// \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:
@@ -1220,149 +1205,146 @@
+		    }
 		    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() {

lemon/full_graph.h

Show inline comments

@@ -2,65 +2,65 @@
+		 *
 		 * 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; }
@@ -140,133 +140,134 @@
 		    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);
+		      }
+		    }
@@ -508,68 +509,68 @@
 		        _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); }

lemon/graph_to_eps.h

Show inline comments

@@ -40,64 +40,65 @@
 		#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;
@@ -212,64 +213,65 @@
 		  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,

lemon/grid_graph.h

Show inline comments

@@ -470,68 +470,68 @@
 		  ///
 		  /// \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

lemon/hypercube_graph.h

Show inline comments

@@ -265,68 +265,68 @@
 		    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 {

lemon/list_graph.h

Show inline comments

@@ -294,80 +294,80 @@
 		        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); }
@@ -764,65 +764,65 @@
 		    };
 		  };
 		  ///@}
 		  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;}
@@ -1147,85 +1147,85 @@
 		      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.

lemon/maps.h

Show inline comments

@@ -1809,64 +1809,65 @@
 		  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 {
@@ -1900,64 +1901,65 @@
 		  /// \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;
@@ -2103,64 +2105,65 @@
 		  /// \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.
@@ -2465,65 +2468,66 @@
 		  /// 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);
+		        }
+		      }
@@ -2594,65 +2598,66 @@
+		      }
+		    }
 		  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();

lemon/smart_graph.h

Show inline comments

@@ -26,65 +26,65 @@
 		#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;
@@ -166,66 +166,64 @@
 		    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.
@@ -391,65 +389,65 @@
 		      ///
 		      ///\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;}
@@ -602,83 +600,83 @@
 		      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
 		    ///

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_GRAPH_ADAPTOR_EXTENDER_H
20	20	#define LEMON_BITS_GRAPH_ADAPTOR_EXTENDER_H
21	21
22	22	#include <lemon/core.h>
23	23	#include <lemon/error.h>
24	24
25	25	namespace lemon {
26	26
27	27	template <typename _Digraph>
28	28	class DigraphAdaptorExtender : public _Digraph {
	29	typedef _Digraph Parent;
	30
29	31	public:
30	32
31		typedef _Digraph Parent;
32	33	typedef _Digraph Digraph;
33	34	typedef DigraphAdaptorExtender Adaptor;
34	35
35	36	// Base extensions
36	37
37	38	typedef typename Parent::Node Node;
38	39	typedef typename Parent::Arc Arc;
39	40
40	41	int maxId(Node) const {
41	42	return Parent::maxNodeId();
42	43	}
43	44
44	45	int maxId(Arc) const {
45	46	return Parent::maxArcId();
46	47	}
47	48
48	49	Node fromId(int id, Node) const {
49	50	return Parent::nodeFromId(id);
50	51	}
51	52
52	53	Arc fromId(int id, Arc) const {
53	54	return Parent::arcFromId(id);
54	55	}
55	56
56	57	Node oppositeNode(const Node &n, const Arc &e) const {
57	58	if (n == Parent::source(e))
58	59	return Parent::target(e);
59	60	else if(n==Parent::target(e))
60	61	return Parent::source(e);
61	62	else
62	63	return INVALID;
63	64	}
...	...	@@ -144,67 +145,68 @@
144	145	: _adaptor(&adaptor) {
145	146	_adaptor->firstIn(*this, node);
146	147	}
147	148
148	149	InArcIt(const Adaptor& adaptor, const Arc& arc) :
149	150	Arc(arc), _adaptor(&adaptor) {}
150	151
151	152	InArcIt& operator++() {
152	153	_adaptor->nextIn(*this);
153	154	return *this;
154	155	}
155	156
156	157	};
157	158
158	159	Node baseNode(const OutArcIt &e) const {
159	160	return Parent::source(e);
160	161	}
161	162	Node runningNode(const OutArcIt &e) const {
162	163	return Parent::target(e);
163	164	}
164	165
165	166	Node baseNode(const InArcIt &e) const {
166	167	return Parent::target(e);
167	168	}
168	169	Node runningNode(const InArcIt &e) const {
169	170	return Parent::source(e);
170	171	}
171	172
172	173	};
173	174
174	175	template <typename _Graph>
175	176	class GraphAdaptorExtender : public _Graph {
	177	typedef _Graph Parent;
	178
176	179	public:
177	180
178		typedef _Graph Parent;
179	181	typedef _Graph Graph;
180	182	typedef GraphAdaptorExtender Adaptor;
181	183
182	184	typedef typename Parent::Node Node;
183	185	typedef typename Parent::Arc Arc;
184	186	typedef typename Parent::Edge Edge;
185	187
186	188	// Graph extension
187	189
188	190	int maxId(Node) const {
189	191	return Parent::maxNodeId();
190	192	}
191	193
192	194	int maxId(Arc) const {
193	195	return Parent::maxArcId();
194	196	}
195	197
196	198	int maxId(Edge) const {
197	199	return Parent::maxEdgeId();
198	200	}
199	201
200	202	Node fromId(int id, Node) const {
201	203	return Parent::nodeFromId(id);
202	204	}
203	205
204	206	Arc fromId(int id, Arc) const {
205	207	return Parent::arcFromId(id);
206	208	}
207	209
208	210	Edge fromId(int id, Edge) const {
209	211	return Parent::edgeFromId(id);
210	212	}