LEMON/LEMON-main Changeset - r778:a143f19f465b

Repositories » LEMON » LEMON-main

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

Changeset - r778:a143f19f465b

« 776:eff1ca

779:c160bf »

r778:a143f19f465b

Tue, 29 Sep 2009 13:03:34

[Not Reviewed]

0 comments (0 inline)

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

Make some graph member functions static (#311, #68)

0 6 0

default

6 files changed with 25 insertions and 25 deletions:

lemon/bits/graph_extender.h

lemon/edge_set.h

lemon/full_graph.h

lemon/hypercube_graph.h

lemon/smart_graph.h

lemon/static_graph.h

↑ Collapse diff ↑

lemon/bits/graph_extender.h

Show inline comments

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

lemon/edge_set.h

Show inline comments

@@ -102,1315 +102,1315 @@
 		      arcs[n].next_in = (*_nodes)[v].first_in;
 		      if ((*_nodes)[v].first_in != -1) {
 		        arcs[(*_nodes)[v].first_in].prev_in = n;
+		      }
 		      (*_nodes)[v].first_in = n;
 		      arcs[n].next_out = (*_nodes)[u].first_out;
 		      if ((*_nodes)[u].first_out != -1) {
 		        arcs[(*_nodes)[u].first_out].prev_out = n;
+		      }
 		      (*_nodes)[u].first_out = n;
 		      arcs[n].source = u;
 		      arcs[n].target = v;
 		      return Arc(n);
+		    }
 		    void erase(const Arc& arc) {
 		      int n = arc.id;
 		      if (arcs[n].prev_in != -1) {
 		        arcs[arcs[n].prev_in].next_in = arcs[n].next_in;
 		      } else {
 		        (*_nodes)[arcs[n].target].first_in = arcs[n].next_in;
+		      }
 		      if (arcs[n].next_in != -1) {
 		        arcs[arcs[n].next_in].prev_in = arcs[n].prev_in;
+		      }
 		      if (arcs[n].prev_out != -1) {
 		        arcs[arcs[n].prev_out].next_out = arcs[n].next_out;
 		      } else {
 		        (*_nodes)[arcs[n].source].first_out = arcs[n].next_out;
+		      }
 		      if (arcs[n].next_out != -1) {
 		        arcs[arcs[n].next_out].prev_out = arcs[n].prev_out;
+		      }
+		    }
 		    void clear() {
 		      Node node;
 		      for (first(node); node != INVALID; next(node)) {
 		        (*_nodes)[node].first_in = -1;
 		        (*_nodes)[node].first_out = -1;
+		      }
 		      arcs.clear();
 		      first_arc = -1;
 		      first_free_arc = -1;
+		    }
 		    void first(Node& node) const {
 		      _graph->first(node);
+		    }
 		    void next(Node& node) const {
 		      _graph->next(node);
+		    }
 		    void first(Arc& arc) const {
 		      Node node;
 		      first(node);
 		      while (node != INVALID && (*_nodes)[node].first_in == -1) {
 		        next(node);
+		      }
 		      arc.id = (node == INVALID) ? -1 : (*_nodes)[node].first_in;
+		    }
 		    void next(Arc& arc) const {
 		      if (arcs[arc.id].next_in != -1) {
 		        arc.id = arcs[arc.id].next_in;
 		      } else {
 		        Node node = arcs[arc.id].target;
 		        next(node);
 		        while (node != INVALID && (*_nodes)[node].first_in == -1) {
 		          next(node);
+		        }
 		        arc.id = (node == INVALID) ? -1 : (*_nodes)[node].first_in;
+		      }
+		    }
 		    void firstOut(Arc& arc, const Node& node) const {
 		      arc.id = (*_nodes)[node].first_out;
+		    }
 		    void nextOut(Arc& arc) const {
 		      arc.id = arcs[arc.id].next_out;
+		    }
 		    void firstIn(Arc& arc, const Node& node) const {
 		      arc.id = (*_nodes)[node].first_in;
+		    }
 		    void nextIn(Arc& arc) const {
 		      arc.id = arcs[arc.id].next_in;
+		    }
 		    int id(const Node& node) const { return _graph->id(node); }
 		    int id(const Arc& arc) const { return arc.id; }
 		    Node nodeFromId(int ix) const { return _graph->nodeFromId(ix); }
 		    Arc arcFromId(int ix) const { return Arc(ix); }
 		    int maxNodeId() const { return _graph->maxNodeId(); };
 		    int maxArcId() const { return arcs.size() - 1; }
 		    Node source(const Arc& arc) const { return arcs[arc.id].source;}
 		    Node target(const Arc& arc) const { return arcs[arc.id].target;}
 		    typedef typename ItemSetTraits<GR, Node>::ItemNotifier NodeNotifier;
 		    NodeNotifier& notifier(Node) const {
 		      return _graph->notifier(Node());
+		    }
 		    template <typename V>
 		    class NodeMap : public GR::template NodeMap<V> {
 		      typedef typename GR::template NodeMap<V> Parent;
 		    public:
 		      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 graphs
 		  ///
 		  /// \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 typename Parent::Node Node;
 		    typedef typename Parent::Arc Arc;
 		    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 {
 		      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 typename GR::Node Node;
 		    typedef typename GR::NodeIt NodeIt;
 		  protected:
 		    struct NodeT {
 		      int first_out;
 		      NodeT() : first_out(-1) {}
 		    };
 		    typedef typename ItemSetTraits<GR, Node>::
 		    template Map<NodeT>::Type NodesImplBase;
 		    NodesImplBase* _nodes;
 		    struct ArcT {
 		      Node target;
 		      int prev_out, next_out;
 		      ArcT() : prev_out(-1), next_out(-1) {}
 		    };
 		    std::vector<ArcT> arcs;
 		    int first_arc;
 		    int first_free_arc;
 		    const GR* _graph;
 		    void initalize(const GR& graph, NodesImplBase& nodes) {
 		      _graph = &graph;
 		      _nodes = &nodes;
+		    }
 		  public:
 		    class Edge {
 		      friend class ListEdgeSetBase;
 		    protected:
 		      int id;
 		      explicit Edge(int _id) { id = _id;}
 		    public:
 		      Edge() {}
 		      Edge (Invalid) { id = -1; }
 		      bool operator==(const Edge& arc) const {return id == arc.id;}
 		      bool operator!=(const Edge& arc) const {return id != arc.id;}
 		      bool operator<(const Edge& arc) const {return id < arc.id;}
 		    };
 		    class Arc {
 		      friend class ListEdgeSetBase;
 		    protected:
 		      Arc(int _id) : id(_id) {}
 		      int id;
 		    public:
 		      operator Edge() const { return edgeFromId(id / 2); }
 		      Arc() {}
 		      Arc(Invalid) : id(-1) {}
 		      bool operator==(const Arc& arc) const { return id == arc.id; }
 		      bool operator!=(const Arc& arc) const { return id != arc.id; }
 		      bool operator<(const Arc& arc) const { return id < arc.id; }
 		    };
 		    ListEdgeSetBase() : first_arc(-1), first_free_arc(-1) {}
 		    Node addNode() {
 		      LEMON_ASSERT(false,
 		        "This graph structure does not support node insertion");
 		      return INVALID; // avoid warning
+		    }
 		    Edge addEdge(const Node& u, const Node& v) {
 		      int n;
 		      if (first_free_arc == -1) {
 		        n = arcs.size();
 		        arcs.push_back(ArcT());
 		        arcs.push_back(ArcT());
 		      } else {
 		        n = first_free_arc;
 		        first_free_arc = arcs[n].next_out;
+		      }
 		      arcs[n].target = u;
 		      arcs[n | 1].target = v;
 		      arcs[n].next_out = (*_nodes)[v].first_out;
 		      if ((*_nodes)[v].first_out != -1) {
 		        arcs[(*_nodes)[v].first_out].prev_out = n;
+		      }
 		      (*_nodes)[v].first_out = n;
 		      arcs[n].prev_out = -1;
 		      if ((*_nodes)[u].first_out != -1) {
 		        arcs[(*_nodes)[u].first_out].prev_out = (n | 1);
+		      }
 		      arcs[n | 1].next_out = (*_nodes)[u].first_out;
 		      (*_nodes)[u].first_out = (n | 1);
 		      arcs[n | 1].prev_out = -1;
 		      return Edge(n / 2);
+		    }
 		    void erase(const Edge& arc) {
 		      int n = arc.id * 2;
 		      if (arcs[n].next_out != -1) {
 		        arcs[arcs[n].next_out].prev_out = arcs[n].prev_out;
+		      }
 		      if (arcs[n].prev_out != -1) {
 		        arcs[arcs[n].prev_out].next_out = arcs[n].next_out;
 		      } else {
 		        (*_nodes)[arcs[n | 1].target].first_out = arcs[n].next_out;
+		      }
 		      if (arcs[n | 1].next_out != -1) {
 		        arcs[arcs[n | 1].next_out].prev_out = arcs[n | 1].prev_out;
+		      }
 		      if (arcs[n | 1].prev_out != -1) {
 		        arcs[arcs[n | 1].prev_out].next_out = arcs[n | 1].next_out;
 		      } else {
 		        (*_nodes)[arcs[n].target].first_out = arcs[n | 1].next_out;
+		      }
 		      arcs[n].next_out = first_free_arc;
 		      first_free_arc = n;
+		    }
 		    void clear() {
 		      Node node;
 		      for (first(node); node != INVALID; next(node)) {
 		        (*_nodes)[node].first_out = -1;
+		      }
 		      arcs.clear();
 		      first_arc = -1;
 		      first_free_arc = -1;
+		    }
 		    void first(Node& node) const {
 		      _graph->first(node);
+		    }
 		    void next(Node& node) const {
 		      _graph->next(node);
+		    }
 		    void first(Arc& arc) const {
 		      Node node;
 		      first(node);
 		      while (node != INVALID && (*_nodes)[node].first_out == -1) {
 		        next(node);
+		      }
 		      arc.id = (node == INVALID) ? -1 : (*_nodes)[node].first_out;
+		    }
 		    void next(Arc& arc) const {
 		      if (arcs[arc.id].next_out != -1) {
 		        arc.id = arcs[arc.id].next_out;
 		      } else {
 		        Node node = arcs[arc.id ^ 1].target;
 		        next(node);
 		        while(node != INVALID && (*_nodes)[node].first_out == -1) {
 		          next(node);
+		        }
 		        arc.id = (node == INVALID) ? -1 : (*_nodes)[node].first_out;
+		      }
+		    }
 		    void first(Edge& edge) const {
 		      Node node;
 		      first(node);
 		      while (node != INVALID) {
 		        edge.id = (*_nodes)[node].first_out;
 		        while ((edge.id & 1) != 1) {
 		          edge.id = arcs[edge.id].next_out;
+		        }
 		        if (edge.id != -1) {
 		          edge.id /= 2;
 		          return;
+		        }
 		        next(node);
+		      }
 		      edge.id = -1;
+		    }
 		    void next(Edge& edge) const {
 		      Node node = arcs[edge.id * 2].target;
 		      edge.id = arcs[(edge.id * 2) | 1].next_out;
 		      while ((edge.id & 1) != 1) {
 		        edge.id = arcs[edge.id].next_out;
+		      }
 		      if (edge.id != -1) {
 		        edge.id /= 2;
 		        return;
+		      }
 		      next(node);
 		      while (node != INVALID) {
 		        edge.id = (*_nodes)[node].first_out;
 		        while ((edge.id & 1) != 1) {
 		          edge.id = arcs[edge.id].next_out;
+		        }
 		        if (edge.id != -1) {
 		          edge.id /= 2;
 		          return;
+		        }
 		        next(node);
+		      }
 		      edge.id = -1;
+		    }
 		    void firstOut(Arc& arc, const Node& node) const {
 		      arc.id = (*_nodes)[node].first_out;
+		    }
 		    void nextOut(Arc& arc) const {
 		      arc.id = arcs[arc.id].next_out;
+		    }
 		    void firstIn(Arc& arc, const Node& node) const {
 		      arc.id = (((*_nodes)[node].first_out) ^ 1);
 		      if (arc.id == -2) arc.id = -1;
+		    }
 		    void nextIn(Arc& arc) const {
 		      arc.id = ((arcs[arc.id ^ 1].next_out) ^ 1);
 		      if (arc.id == -2) arc.id = -1;
+		    }
 		    void firstInc(Edge &arc, bool& dir, const Node& node) const {
 		      int de = (*_nodes)[node].first_out;
 		      if (de != -1 ) {
 		        arc.id = de / 2;
 		        dir = ((de & 1) == 1);
 		      } else {
 		        arc.id = -1;
 		        dir = true;
+		      }
+		    }
 		    void nextInc(Edge &arc, bool& dir) const {
 		      int de = (arcs[(arc.id * 2) | (dir ? 1 : 0)].next_out);
 		      if (de != -1 ) {
 		        arc.id = de / 2;
 		        dir = ((de & 1) == 1);
 		      } else {
 		        arc.id = -1;
 		        dir = true;
+		      }
+		    }
 		    static bool direction(Arc arc) {
 		      return (arc.id & 1) == 1;
+		    }
 		    static Arc direct(Edge edge, bool dir) {
 		      return Arc(edge.id * 2 + (dir ? 1 : 0));
+		    }
 		    int id(const Node& node) const { return _graph->id(node); }
 		    static int id(Arc e) { return e.id; }
 		    static int id(Edge e) { return e.id; }
 		    Node nodeFromId(int id) const { return _graph->nodeFromId(id); }
 		    static Arc arcFromId(int id) { return Arc(id);}
 		    static Edge edgeFromId(int id) { return Edge(id);}
 		    int maxNodeId() const { return _graph->maxNodeId(); };
 		    int maxEdgeId() const { return arcs.size() / 2 - 1; }
 		    int maxArcId() const { return arcs.size()-1; }
 		    Node source(Arc e) const { return arcs[e.id ^ 1].target; }
 		    Node target(Arc e) const { return arcs[e.id].target; }
 		    Node u(Edge e) const { return arcs[2 * e.id].target; }
 		    Node v(Edge e) const { return arcs[2 * e.id + 1].target; }
 		    typedef typename ItemSetTraits<GR, Node>::ItemNotifier NodeNotifier;
 		    NodeNotifier& notifier(Node) const {
 		      return _graph->notifier(Node());
+		    }
 		    template <typename V>
 		    class NodeMap : public GR::template NodeMap<V> {
 		      typedef typename GR::template NodeMap<V> Parent;
 		    public:
 		      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 graphs
 		  ///
 		  /// \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 typename Parent::Node Node;
 		    typedef typename Parent::Arc Arc;
 		    typedef typename Parent::Edge Edge;
 		    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 {
 		      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 typename GR::Node Node;
 		    typedef typename GR::NodeIt NodeIt;
 		  protected:
 		    struct NodeT {
 		      int first_out, first_in;
 		      NodeT() : first_out(-1), first_in(-1) {}
 		    };
 		    typedef typename ItemSetTraits<GR, Node>::
 		    template Map<NodeT>::Type NodesImplBase;
 		    NodesImplBase* _nodes;
 		    struct ArcT {
 		      Node source, target;
 		      int next_out, next_in;
 		      ArcT() {}
 		    };
 		    std::vector<ArcT> arcs;
 		    const GR* _graph;
 		    void initalize(const GR& graph, NodesImplBase& nodes) {
 		      _graph = &graph;
 		      _nodes = &nodes;
+		    }
 		  public:
 		    class Arc {
 		      friend class SmartArcSetBase<GR>;
 		    protected:
 		      Arc(int _id) : id(_id) {}
 		      int id;
 		    public:
 		      Arc() {}
 		      Arc(Invalid) : id(-1) {}
 		      bool operator==(const Arc& arc) const { return id == arc.id; }
 		      bool operator!=(const Arc& arc) const { return id != arc.id; }
 		      bool operator<(const Arc& arc) const { return id < arc.id; }
 		    };
 		    SmartArcSetBase() {}
 		    Node addNode() {
 		      LEMON_ASSERT(false,
 		        "This graph structure does not support node insertion");
 		      return INVALID; // avoid warning
+		    }
 		    Arc addArc(const Node& u, const Node& v) {
 		      int n = arcs.size();
 		      arcs.push_back(ArcT());
 		      arcs[n].next_in = (*_nodes)[v].first_in;
 		      (*_nodes)[v].first_in = n;
 		      arcs[n].next_out = (*_nodes)[u].first_out;
 		      (*_nodes)[u].first_out = n;
 		      arcs[n].source = u;
 		      arcs[n].target = v;
 		      return Arc(n);
+		    }
 		    void clear() {
 		      Node node;
 		      for (first(node); node != INVALID; next(node)) {
 		        (*_nodes)[node].first_in = -1;
 		        (*_nodes)[node].first_out = -1;
+		      }
 		      arcs.clear();
+		    }
 		    void first(Node& node) const {
 		      _graph->first(node);
+		    }
 		    void next(Node& node) const {
 		      _graph->next(node);
+		    }
 		    void first(Arc& arc) const {
 		      arc.id = arcs.size() - 1;
+		    }
-		    void next(Arc& arc) const {
+		    static void next(Arc& arc) {
 		      --arc.id;
+		    }
 		    void firstOut(Arc& arc, const Node& node) const {
 		      arc.id = (*_nodes)[node].first_out;
+		    }
 		    void nextOut(Arc& arc) const {
 		      arc.id = arcs[arc.id].next_out;
+		    }
 		    void firstIn(Arc& arc, const Node& node) const {
 		      arc.id = (*_nodes)[node].first_in;
+		    }
 		    void nextIn(Arc& arc) const {
 		      arc.id = arcs[arc.id].next_in;
+		    }
 		    int id(const Node& node) const { return _graph->id(node); }
 		    int id(const Arc& arc) const { return arc.id; }
 		    Node nodeFromId(int ix) const { return _graph->nodeFromId(ix); }
 		    Arc arcFromId(int ix) const { return Arc(ix); }
 		    int maxNodeId() const { return _graph->maxNodeId(); };
 		    int maxArcId() const { return arcs.size() - 1; }
 		    Node source(const Arc& arc) const { return arcs[arc.id].source;}
 		    Node target(const Arc& arc) const { return arcs[arc.id].target;}
 		    typedef typename ItemSetTraits<GR, Node>::ItemNotifier NodeNotifier;
 		    NodeNotifier& notifier(Node) const {
 		      return _graph->notifier(Node());
+		    }
 		    template <typename V>
 		    class NodeMap : public GR::template NodeMap<V> {
 		      typedef typename GR::template NodeMap<V> Parent;
 		    public:
 		      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 graphs
 		  ///
 		  /// \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 typename Parent::Node Node;
 		    typedef typename Parent::Arc Arc;
 		  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 {
 		      typedef NodesImplBase Parent;
 		    public:
 		      NodesImpl(const GR& graph, SmartArcSet& arcset)
 		        : Parent(graph), _arcset(arcset) {}
 		      virtual ~NodesImpl() {}
 		      bool attached() const {
 		        return Parent::attached();
+		      }
 		    protected:
 		      virtual void erase(const Node& node) {
 		        try {
 		          _arcset.eraseNode(node);
 		          Parent::erase(node);
 		        } catch (const typename NodesImplBase::Notifier::ImmediateDetach&) {
 		          Parent::clear();
 		          throw;
+		        }
+		      }
 		      virtual void erase(const std::vector<Node>& nodes) {
 		        try {
 		          for (int i = 0; i < int(nodes.size()); ++i) {
 		            _arcset.eraseNode(nodes[i]);
+		          }
 		          Parent::erase(nodes);
 		        } catch (const typename NodesImplBase::Notifier::ImmediateDetach&) {
 		          Parent::clear();
 		          throw;
+		        }
+		      }
 		      virtual void clear() {
 		        _arcset.clearNodes();
 		        Parent::clear();
+		      }
 		    private:
 		      SmartArcSet& _arcset;
 		    };
 		    NodesImpl _nodes;
 		  public:
 		    /// \brief Constructor of the ArcSet.
 		    ///
 		    /// Constructor of the ArcSet.
 		    SmartArcSet(const GR& graph) : _nodes(graph, *this) {
 		      Parent::initalize(graph, _nodes);
+		    }
 		    /// \brief Add a new arc to the digraph.
 		    ///
 		    /// Add a new arc to the digraph with source node \c s
 		    /// and target node \c t.
 		    /// \return The new arc.
 		    Arc addArc(const Node& s, const Node& t) {
 		      return Parent::addArc(s, t);
+		    }
 		    /// \brief Validity check
 		    ///
 		    /// This functions gives back false if the ArcSet is
 		    /// invalidated. It occurs when a node in the underlying graph is
 		    /// erased and it is not isolated in the ArcSet.
 		    bool valid() const {
 		      return _nodes.attached();
+		    }
 		  };
 		  template <typename GR>
 		  class SmartEdgeSetBase {
 		  public:
 		    typedef typename GR::Node Node;
 		    typedef typename GR::NodeIt NodeIt;
 		  protected:
 		    struct NodeT {
 		      int first_out;
 		      NodeT() : first_out(-1) {}
 		    };
 		    typedef typename ItemSetTraits<GR, Node>::
 		    template Map<NodeT>::Type NodesImplBase;
 		    NodesImplBase* _nodes;
 		    struct ArcT {
 		      Node target;
 		      int next_out;
 		      ArcT() {}
 		    };
 		    std::vector<ArcT> arcs;
 		    const GR* _graph;
 		    void initalize(const GR& graph, NodesImplBase& nodes) {
 		      _graph = &graph;
 		      _nodes = &nodes;
+		    }
 		  public:
 		    class Edge {
 		      friend class SmartEdgeSetBase;
 		    protected:
 		      int id;
 		      explicit Edge(int _id) { id = _id;}
 		    public:
 		      Edge() {}
 		      Edge (Invalid) { id = -1; }
 		      bool operator==(const Edge& arc) const {return id == arc.id;}
 		      bool operator!=(const Edge& arc) const {return id != arc.id;}
 		      bool operator<(const Edge& arc) const {return id < arc.id;}
 		    };
 		    class Arc {
 		      friend class SmartEdgeSetBase;
 		    protected:
 		      Arc(int _id) : id(_id) {}
 		      int id;
 		    public:
 		      operator Edge() const { return edgeFromId(id / 2); }
 		      Arc() {}
 		      Arc(Invalid) : id(-1) {}
 		      bool operator==(const Arc& arc) const { return id == arc.id; }
 		      bool operator!=(const Arc& arc) const { return id != arc.id; }
 		      bool operator<(const Arc& arc) const { return id < arc.id; }
 		    };
 		    SmartEdgeSetBase() {}
 		    Node addNode() {
 		      LEMON_ASSERT(false,
 		        "This graph structure does not support node insertion");
 		      return INVALID; // avoid warning
+		    }
 		    Edge addEdge(const Node& u, const Node& v) {
 		      int n = arcs.size();
 		      arcs.push_back(ArcT());
 		      arcs.push_back(ArcT());
 		      arcs[n].target = u;
 		      arcs[n | 1].target = v;
 		      arcs[n].next_out = (*_nodes)[v].first_out;
 		      (*_nodes)[v].first_out = n;
 		      arcs[n | 1].next_out = (*_nodes)[u].first_out;
 		      (*_nodes)[u].first_out = (n | 1);
 		      return Edge(n / 2);
+		    }
 		    void clear() {
 		      Node node;
 		      for (first(node); node != INVALID; next(node)) {
 		        (*_nodes)[node].first_out = -1;
+		      }
 		      arcs.clear();
+		    }
 		    void first(Node& node) const {
 		      _graph->first(node);
+		    }
 		    void next(Node& node) const {
 		      _graph->next(node);
+		    }
 		    void first(Arc& arc) const {
 		      arc.id = arcs.size() - 1;
+		    }
-		    void next(Arc& arc) const {
+		    static void next(Arc& arc) {
 		      --arc.id;
+		    }
 		    void first(Edge& arc) const {
 		      arc.id = arcs.size() / 2 - 1;
+		    }
-		    void next(Edge& arc) const {
+		    static void next(Edge& arc) {
 		      --arc.id;
+		    }
 		    void firstOut(Arc& arc, const Node& node) const {
 		      arc.id = (*_nodes)[node].first_out;
+		    }
 		    void nextOut(Arc& arc) const {
 		      arc.id = arcs[arc.id].next_out;
+		    }
 		    void firstIn(Arc& arc, const Node& node) const {
 		      arc.id = (((*_nodes)[node].first_out) ^ 1);
 		      if (arc.id == -2) arc.id = -1;
+		    }
 		    void nextIn(Arc& arc) const {
 		      arc.id = ((arcs[arc.id ^ 1].next_out) ^ 1);
 		      if (arc.id == -2) arc.id = -1;
+		    }
 		    void firstInc(Edge &arc, bool& dir, const Node& node) const {
 		      int de = (*_nodes)[node].first_out;
 		      if (de != -1 ) {
 		        arc.id = de / 2;
 		        dir = ((de & 1) == 1);
 		      } else {
 		        arc.id = -1;
 		        dir = true;
+		      }
+		    }
 		    void nextInc(Edge &arc, bool& dir) const {
 		      int de = (arcs[(arc.id * 2) | (dir ? 1 : 0)].next_out);
 		      if (de != -1 ) {
 		        arc.id = de / 2;
 		        dir = ((de & 1) == 1);
 		      } else {
 		        arc.id = -1;
 		        dir = true;
+		      }
+		    }
 		    static bool direction(Arc arc) {
 		      return (arc.id & 1) == 1;
+		    }
 		    static Arc direct(Edge edge, bool dir) {
 		      return Arc(edge.id * 2 + (dir ? 1 : 0));
+		    }
 		    int id(Node node) const { return _graph->id(node); }
 		    static int id(Arc arc) { return arc.id; }
 		    static int id(Edge arc) { return arc.id; }
 		    Node nodeFromId(int id) const { return _graph->nodeFromId(id); }
 		    static Arc arcFromId(int id) { return Arc(id); }
 		    static Edge edgeFromId(int id) { return Edge(id);}
 		    int maxNodeId() const { return _graph->maxNodeId(); };
 		    int maxArcId() const { return arcs.size() - 1; }
 		    int maxEdgeId() const { return arcs.size() / 2 - 1; }
 		    Node source(Arc e) const { return arcs[e.id ^ 1].target; }
 		    Node target(Arc e) const { return arcs[e.id].target; }
 		    Node u(Edge e) const { return arcs[2 * e.id].target; }
 		    Node v(Edge e) const { return arcs[2 * e.id + 1].target; }
 		    typedef typename ItemSetTraits<GR, Node>::ItemNotifier NodeNotifier;
 		    NodeNotifier& notifier(Node) const {
 		      return _graph->notifier(Node());
+		    }
 		    template <typename V>
 		    class NodeMap : public GR::template NodeMap<V> {
 		      typedef typename GR::template NodeMap<V> Parent;
 		    public:
 		      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 graphs
 		  ///
 		  /// \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 typename Parent::Node Node;
 		    typedef typename Parent::Arc Arc;
 		    typedef typename Parent::Edge Edge;
 		  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 {
 		      typedef NodesImplBase Parent;
 		    public:
 		      NodesImpl(const GR& graph, SmartEdgeSet& arcset)
 		        : Parent(graph), _arcset(arcset) {}
 		      virtual ~NodesImpl() {}
 		      bool attached() const {
 		        return Parent::attached();
+		      }
 		    protected:
 		      virtual void erase(const Node& node) {
 		        try {
 		          _arcset.eraseNode(node);
 		          Parent::erase(node);
 		        } catch (const typename NodesImplBase::Notifier::ImmediateDetach&) {
 		          Parent::clear();
 		          throw;
+		        }
+		      }
 		      virtual void erase(const std::vector<Node>& nodes) {
 		        try {
 		          for (int i = 0; i < int(nodes.size()); ++i) {
 		            _arcset.eraseNode(nodes[i]);
+		          }
 		          Parent::erase(nodes);
 		        } catch (const typename NodesImplBase::Notifier::ImmediateDetach&) {
 		          Parent::clear();
 		          throw;
+		        }
+		      }
 		      virtual void clear() {
 		        _arcset.clearNodes();
 		        Parent::clear();
+		      }
 		    private:
 		      SmartEdgeSet& _arcset;
 		    };
 		    NodesImpl _nodes;
 		  public:
 		    /// \brief Constructor of the EdgeSet.
 		    ///
 		    /// Constructor of the EdgeSet.
 		    SmartEdgeSet(const GR& graph) : _nodes(graph, *this) {
 		      Parent::initalize(graph, _nodes);
+		    }
 		    /// \brief Add a new edge to the graph.
 		    ///
 		    /// Add a new edge to the graph with node \c u
 		    /// and node \c v endpoints.
 		    /// \return The new edge.
 		    Edge addEdge(const Node& u, const Node& v) {
 		      return Parent::addEdge(u, v);
+		    }
 		    /// \brief Validity check
 		    ///
 		    /// This functions gives back false if the EdgeSet is
 		    /// invalidated. It occurs when a node in the underlying graph is
 		    /// erased and it is not isolated in the EdgeSet.
 		    bool valid() const {
 		      return _nodes.attached();
+		    }
 		  };
+		}
 		#endif

lemon/full_graph.h

Show inline comments

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

lemon/hypercube_graph.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2009
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef HYPERCUBE_GRAPH_H
 		#define HYPERCUBE_GRAPH_H
 		#include <vector>
 		#include <lemon/core.h>
 		#include <lemon/assert.h>
 		#include <lemon/bits/graph_extender.h>
 		///\ingroup graphs
 		///\file
 		///\brief HypercubeGraph class.
 		namespace lemon {
 		  class HypercubeGraphBase {
 		  public:
 		    typedef HypercubeGraphBase Graph;
 		    class Node;
 		    class Edge;
 		    class Arc;
 		  public:
 		    HypercubeGraphBase() {}
 		  protected:
 		    void construct(int dim) {
 		      LEMON_ASSERT(dim >= 1, "The number of dimensions must be at least 1.");
 		      _dim = dim;
 		      _node_num = 1 << dim;
 		      _edge_num = dim * (1 << (dim-1));
+		    }
 		  public:
 		    typedef True NodeNumTag;
 		    typedef True EdgeNumTag;
 		    typedef True ArcNumTag;
 		    int nodeNum() const { return _node_num; }
 		    int edgeNum() const { return _edge_num; }
 		    int arcNum() const { return 2 * _edge_num; }
 		    int maxNodeId() const { return _node_num - 1; }
 		    int maxEdgeId() const { return _edge_num - 1; }
 		    int maxArcId() const { return 2 * _edge_num - 1; }
 		    static Node nodeFromId(int id) { return Node(id); }
 		    static Edge edgeFromId(int id) { return Edge(id); }
 		    static Arc arcFromId(int id) { return Arc(id); }
 		    static int id(Node node) { return node._id; }
 		    static int id(Edge edge) { return edge._id; }
 		    static int id(Arc arc) { return arc._id; }
 		    Node u(Edge edge) const {
 		      int base = edge._id & ((1 << (_dim-1)) - 1);
 		      int k = edge._id >> (_dim-1);
 		      return ((base >> k) << (k+1)) | (base & ((1 << k) - 1));
+		    }
 		    Node v(Edge edge) const {
 		      int base = edge._id & ((1 << (_dim-1)) - 1);
 		      int k = edge._id >> (_dim-1);
 		      return ((base >> k) << (k+1)) | (base & ((1 << k) - 1)) | (1 << k);
+		    }
 		    Node source(Arc arc) const {
 		      return (arc._id & 1) == 1 ? u(arc) : v(arc);
+		    }
 		    Node target(Arc arc) const {
 		      return (arc._id & 1) == 1 ? v(arc) : u(arc);
+		    }
 		    typedef True FindEdgeTag;
 		    typedef True FindArcTag;
 		    Edge findEdge(Node u, Node v, Edge prev = INVALID) const {
 		      if (prev != INVALID) return INVALID;
 		      int d = u._id ^ v._id;
 		      int k = 0;
 		      if (d == 0) return INVALID;
 		      for ( ; (d & 1) == 0; d >>= 1) ++k;
 		      if (d >> 1 != 0) return INVALID;
 		      return (k << (_dim-1)) | ((u._id >> (k+1)) << k) |
 		        (u._id & ((1 << k) - 1));
+		    }
 		    Arc findArc(Node u, Node v, Arc prev = INVALID) const {
 		      Edge edge = findEdge(u, v, prev);
 		      if (edge == INVALID) return INVALID;
 		      int k = edge._id >> (_dim-1);
 		      return ((u._id >> k) & 1) == 1 ? edge._id << 1 : (edge._id << 1) | 1;
+		    }
 		    class Node {
 		      friend class HypercubeGraphBase;
 		    protected:
 		      int _id;
 		      Node(int id) : _id(id) {}
 		    public:
 		      Node() {}
 		      Node (Invalid) : _id(-1) {}
 		      bool operator==(const Node node) const {return _id == node._id;}
 		      bool operator!=(const Node node) const {return _id != node._id;}
 		      bool operator<(const Node node) const {return _id < node._id;}
 		    };
 		    class Edge {
 		      friend class HypercubeGraphBase;
 		      friend class Arc;
 		    protected:
 		      int _id;
 		      Edge(int id) : _id(id) {}
 		    public:
 		      Edge() {}
 		      Edge (Invalid) : _id(-1) {}
 		      bool operator==(const Edge edge) const {return _id == edge._id;}
 		      bool operator!=(const Edge edge) const {return _id != edge._id;}
 		      bool operator<(const Edge edge) const {return _id < edge._id;}
 		    };
 		    class Arc {
 		      friend class HypercubeGraphBase;
 		    protected:
 		      int _id;
 		      Arc(int id) : _id(id) {}
 		    public:
 		      Arc() {}
 		      Arc (Invalid) : _id(-1) {}
 		      operator Edge() const { return _id != -1 ? Edge(_id >> 1) : INVALID; }
 		      bool operator==(const Arc arc) const {return _id == arc._id;}
 		      bool operator!=(const Arc arc) const {return _id != arc._id;}
 		      bool operator<(const Arc arc) const {return _id < arc._id;}
 		    };
 		    void first(Node& node) const {
 		      node._id = _node_num - 1;
+		    }
 		    static void next(Node& node) {
 		      --node._id;
+		    }
 		    void first(Edge& edge) const {
 		      edge._id = _edge_num - 1;
+		    }
 		    static void next(Edge& edge) {
 		      --edge._id;
+		    }
 		    void first(Arc& arc) const {
 		      arc._id = 2 * _edge_num - 1;
+		    }
 		    static void next(Arc& arc) {
 		      --arc._id;
+		    }
 		    void firstInc(Edge& edge, bool& dir, const Node& node) const {
 		      edge._id = node._id >> 1;
 		      dir = (node._id & 1) == 0;
+		    }
 		    void nextInc(Edge& edge, bool& dir) const {
 		      Node n = dir ? u(edge) : v(edge);
 		      int k = (edge._id >> (_dim-1)) + 1;
 		      if (k < _dim) {
 		        edge._id = (k << (_dim-1)) |
 		          ((n._id >> (k+1)) << k) | (n._id & ((1 << k) - 1));
 		        dir = ((n._id >> k) & 1) == 0;
 		      } else {
 		        edge._id = -1;
 		        dir = true;
+		      }
+		    }
 		    void firstOut(Arc& arc, const Node& node) const {
 		      arc._id = ((node._id >> 1) << 1) | (~node._id & 1);
+		    }
 		    void nextOut(Arc& arc) const {
 		      Node n = (arc._id & 1) == 1 ? u(arc) : v(arc);
 		      int k = (arc._id >> _dim) + 1;
 		      if (k < _dim) {
 		        arc._id = (k << (_dim-1)) |
 		          ((n._id >> (k+1)) << k) | (n._id & ((1 << k) - 1));
 		        arc._id = (arc._id << 1) | (~(n._id >> k) & 1);
 		      } else {
 		        arc._id = -1;
+		      }
+		    }
 		    void firstIn(Arc& arc, const Node& node) const {
 		      arc._id = ((node._id >> 1) << 1) | (node._id & 1);
+		    }
 		    void nextIn(Arc& arc) const {
 		      Node n = (arc._id & 1) == 1 ? v(arc) : u(arc);
 		      int k = (arc._id >> _dim) + 1;
 		      if (k < _dim) {
 		        arc._id = (k << (_dim-1)) |
 		          ((n._id >> (k+1)) << k) | (n._id & ((1 << k) - 1));
 		        arc._id = (arc._id << 1) | ((n._id >> k) & 1);
 		      } else {
 		        arc._id = -1;
+		      }
+		    }
 		    static bool direction(Arc arc) {
 		      return (arc._id & 1) == 1;
+		    }
 		    static Arc direct(Edge edge, bool dir) {
 		      return Arc((edge._id << 1) | (dir ? 1 : 0));
+		    }
 		    int dimension() const {
 		      return _dim;
+		    }
 		    bool projection(Node node, int n) const {
 		      return static_cast<bool>(node._id & (1 << n));
+		    }
 		    int dimension(Edge edge) const {
 		      return edge._id >> (_dim-1);
+		    }
 		    int dimension(Arc arc) const {
 		      return arc._id >> _dim;
+		    }
-		    int index(Node node) const {
+		    static int index(Node node) {
 		      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:
 		    /// \brief Constructs a hypercube graph with \c dim dimensions.
 		    ///
 		    /// Constructs a hypercube graph with \c dim dimensions.
 		    HypercubeGraph(int dim) { construct(dim); }
 		    /// \brief The number of dimensions.
 		    ///
 		    /// Gives back the number of dimensions.
 		    int dimension() const {
 		      return Parent::dimension();
+		    }
 		    /// \brief Returns \c true if the n'th bit of the node is one.
 		    ///
 		    /// Returns \c true if the n'th bit of the node is one.
 		    bool projection(Node node, int n) const {
 		      return Parent::projection(node, n);
+		    }
 		    /// \brief The dimension id of an edge.
 		    ///
 		    /// Gives back the dimension id of the given edge.
 		    /// It is in the [0..dim-1] range.
 		    int dimension(Edge edge) const {
 		      return Parent::dimension(edge);
+		    }
 		    /// \brief The dimension id of an arc.
 		    ///
 		    /// Gives back the dimension id of the given arc.
 		    /// It is in the [0..dim-1] range.
 		    int dimension(Arc arc) const {
 		      return Parent::dimension(arc);
+		    }
 		    /// \brief The index of a node.
 		    ///
 		    /// Gives back the index of the given node.
 		    /// The lower bits of the integer describes the node.
-		    int index(Node node) const {
+		    static int index(Node node) {
 		      return Parent::index(node);
+		    }
 		    /// \brief Gives back a node by its index.
 		    ///
 		    /// Gives back a node by its index.
 		    Node operator()(int ix) const {
 		      return Parent::operator()(ix);
+		    }
 		    /// \brief Number of nodes.
 		    int nodeNum() const { return Parent::nodeNum(); }
 		    /// \brief Number of edges.
 		    int edgeNum() const { return Parent::edgeNum(); }
 		    /// \brief Number of arcs.
 		    int arcNum() const { return Parent::arcNum(); }
 		    /// \brief Linear combination map.
 		    ///
 		    /// This map makes possible to give back a linear combination
 		    /// for each node. It works like the \c std::accumulate function,
 		    /// so it accumulates the \c bf binary function with the \c fv first
 		    /// value. The map accumulates only on that positions (dimensions)
 		    /// where the index of the node is one. The values that have to be
 		    /// accumulated should be given by the \c begin and \c end iterators
 		    /// and the length of this range should be equal to the dimension
 		    /// number of the graph.
 		    ///
 		    ///\code
 		    /// const int DIM = 3;
 		    /// HypercubeGraph graph(DIM);
 		    /// dim2::Point<double> base[DIM];
 		    /// for (int k = 0; k < DIM; ++k) {
 		    ///   base[k].x = rnd();
 		    ///   base[k].y = rnd();
 		    /// }
 		    /// HypercubeGraph::HyperMap<dim2::Point<double> >
 		    ///   pos(graph, base, base + DIM, dim2::Point<double>(0.0, 0.0));
 		    ///\endcode
 		    ///
 		    /// \see HypercubeGraph
 		    template <typename T, typename BF = std::plus<T> >
 		    class HyperMap {
 		    public:
 		      /// \brief The key type of the map
 		      typedef Node Key;
 		      /// \brief The value type of the map
 		      typedef T Value;
 		      /// \brief Constructor for HyperMap.
 		      ///
 		      /// Construct a HyperMap for the given graph. The values that have
 		      /// to be accumulated should be given by the \c begin and \c end
 		      /// iterators and the length of this range should be equal to the
 		      /// dimension number of the graph.
 		      ///
 		      /// This map accumulates the \c bf binary function with the \c fv
 		      /// first value on that positions (dimensions) where the index of
 		      /// the node is one.
 		      template <typename It>
 		      HyperMap(const Graph& graph, It begin, It end,
 		               T fv = 0, const BF& bf = BF())
 		        : _graph(graph), _values(begin, end), _first_value(fv), _bin_func(bf)
+		      {
 		        LEMON_ASSERT(_values.size() == graph.dimension(),
 		                     "Wrong size of range");
+		      }
 		      /// \brief The partial accumulated value.
 		      ///
 		      /// Gives back the partial accumulated value.
 		      Value operator[](const Key& k) const {
 		        Value val = _first_value;
 		        int id = _graph.index(k);
 		        int n = 0;
 		        while (id != 0) {
 		          if (id & 1) {
 		            val = _bin_func(val, _values[n]);
+		          }
 		          id >>= 1;
 		          ++n;
+		        }
 		        return val;
+		      }
 		    private:
 		      const Graph& _graph;
 		      std::vector<T> _values;
 		      T _first_value;
 		      BF _bin_func;
 		    };
 		  };
+		}
 		#endif

lemon/smart_graph.h

Show inline comments

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

lemon/static_graph.h

Show inline comments

 		/* -*- C++ -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 *
 		 * Copyright (C) 2003-2008
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_STATIC_GRAPH_H
 		#define LEMON_STATIC_GRAPH_H
 		///\ingroup graphs
 		///\file
 		///\brief StaticDigraph class.
 		#include <lemon/core.h>
 		#include <lemon/bits/graph_extender.h>
 		namespace lemon {
 		  class StaticDigraphBase {
 		  public:
 		    StaticDigraphBase()
 		      : built(false), node_num(0), arc_num(0),
 		        node_first_out(NULL), node_first_in(NULL),
 		        arc_source(NULL), arc_target(NULL),
 		        arc_next_in(NULL), arc_next_out(NULL) {}
 		    ~StaticDigraphBase() {
 		      if (built) {
 		        delete[] node_first_out;
 		        delete[] node_first_in;
 		        delete[] arc_source;
 		        delete[] arc_target;
 		        delete[] arc_next_out;
 		        delete[] arc_next_in;
+		      }
+		    }
 		    class Node {
 		      friend class StaticDigraphBase;
 		    protected:
 		      int id;
 		      Node(int _id) : id(_id) {}
 		    public:
 		      Node() {}
 		      Node (Invalid) : id(-1) {}
 		      bool operator==(const Node& node) const { return id == node.id; }
 		      bool operator!=(const Node& node) const { return id != node.id; }
 		      bool operator<(const Node& node) const { return id < node.id; }
 		    };
 		    class Arc {
 		      friend class StaticDigraphBase;
 		    protected:
 		      int id;
 		      Arc(int _id) : id(_id) {}
 		    public:
 		      Arc() { }
 		      Arc (Invalid) : id(-1) {}
 		      bool operator==(const Arc& arc) const { return id == arc.id; }
 		      bool operator!=(const Arc& arc) const { return id != arc.id; }
 		      bool operator<(const Arc& arc) const { return id < arc.id; }
 		    };
 		    Node source(const Arc& e) const { return Node(arc_source[e.id]); }
 		    Node target(const Arc& e) const { return Node(arc_target[e.id]); }
 		    void first(Node& n) const { n.id = node_num - 1; }
 		    static void next(Node& n) { --n.id; }
 		    void first(Arc& e) const { e.id = arc_num - 1; }
 		    static void next(Arc& e) { --e.id; }
 		    void firstOut(Arc& e, const Node& n) const {
 		      e.id = node_first_out[n.id] != node_first_out[n.id + 1] ?
 		        node_first_out[n.id] : -1;
+		    }
 		    void nextOut(Arc& e) const { e.id = arc_next_out[e.id]; }
 		    void firstIn(Arc& e, const Node& n) const { e.id = node_first_in[n.id]; }
 		    void nextIn(Arc& e) const { e.id = arc_next_in[e.id]; }
 		    int id(const Node& n) const { return n.id; }
 		    Node nodeFromId(int id) const { return Node(id); }
 		    static int id(const Node& n) { return n.id; }
 		    static Node nodeFromId(int id) { return Node(id); }
 		    int maxNodeId() const { return node_num - 1; }
 		    int id(const Arc& e) const { return e.id; }
 		    Arc arcFromId(int id) const { return Arc(id); }
 		    static int id(const Arc& e) { return e.id; }
 		    static Arc arcFromId(int id) { return Arc(id); }
 		    int maxArcId() const { return arc_num - 1; }
 		    typedef True NodeNumTag;
 		    typedef True ArcNumTag;
 		    int nodeNum() const { return node_num; }
 		    int arcNum() const { return arc_num; }
 		  private:
 		    template <typename Digraph, typename NodeRefMap>
 		    class ArcLess {
 		    public:
 		      typedef typename Digraph::Arc Arc;
 		      ArcLess(const Digraph &_graph, const NodeRefMap& _nodeRef)
 		        : digraph(_graph), nodeRef(_nodeRef) {}
 		      bool operator()(const Arc& left, const Arc& right) const {
 			return nodeRef[digraph.target(left)] < nodeRef[digraph.target(right)];
+		      }
 		    private:
 		      const Digraph& digraph;
 		      const NodeRefMap& nodeRef;
 		    };
 		  public:
 		    typedef True BuildTag;
 		    void clear() {
 		      if (built) {
 		        delete[] node_first_out;
 		        delete[] node_first_in;
 		        delete[] arc_source;
 		        delete[] arc_target;
 		        delete[] arc_next_out;
 		        delete[] arc_next_in;
+		      }
 		      built = false;
 		      node_num = 0;
 		      arc_num = 0;
+		    }
 		    template <typename Digraph, typename NodeRefMap, typename ArcRefMap>
 		    void build(const Digraph& digraph, NodeRefMap& nodeRef, ArcRefMap& arcRef) {
 		      typedef typename Digraph::Node GNode;
 		      typedef typename Digraph::Arc GArc;
 		      built = true;
 		      node_num = countNodes(digraph);
 		      arc_num = countArcs(digraph);
 		      node_first_out = new int[node_num + 1];
 		      node_first_in = new int[node_num];
 		      arc_source = new int[arc_num];
 		      arc_target = new int[arc_num];
 		      arc_next_out = new int[arc_num];
 		      arc_next_in = new int[arc_num];
 		      int node_index = 0;
 		      for (typename Digraph::NodeIt n(digraph); n != INVALID; ++n) {
 		        nodeRef[n] = Node(node_index);
 		        node_first_in[node_index] = -1;
 		        ++node_index;
+		      }
 		      ArcLess<Digraph, NodeRefMap> arcLess(digraph, nodeRef);
 		      int arc_index = 0;
 		      for (typename Digraph::NodeIt n(digraph); n != INVALID; ++n) {
 		        int source = nodeRef[n].id;
 		        std::vector<GArc> arcs;
 		        for (typename Digraph::OutArcIt e(digraph, n); e != INVALID; ++e) {
 		          arcs.push_back(e);
+		        }
 		        if (!arcs.empty()) {
 		          node_first_out[source] = arc_index;
 		          std::sort(arcs.begin(), arcs.end(), arcLess);
 		          for (typename std::vector<GArc>::iterator it = arcs.begin();
 		               it != arcs.end(); ++it) {
 		            int target = nodeRef[digraph.target(*it)].id;
 		            arcRef[*it] = Arc(arc_index);
 		            arc_source[arc_index] = source;
 		            arc_target[arc_index] = target;
 		            arc_next_in[arc_index] = node_first_in[target];
 		            node_first_in[target] = arc_index;
 		            arc_next_out[arc_index] = arc_index + 1;
 		            ++arc_index;
+		          }
 		          arc_next_out[arc_index - 1] = -1;
 		        } else {
 		          node_first_out[source] = arc_index;
+		        }
+		      }
 		      node_first_out[node_num] = arc_num;
+		    }
 		  protected:
 		    void fastFirstOut(Arc& e, const Node& n) const {
 		      e.id = node_first_out[n.id];
+		    }
 		    static void fastNextOut(Arc& e) {
 		      ++e.id;
+		    }
 		    void fastLastOut(Arc& e, const Node& n) const {
 		      e.id = node_first_out[n.id + 1];
+		    }
 		  protected:
 		    bool built;
 		    int node_num;
 		    int arc_num;
 		    int *node_first_out;
 		    int *node_first_in;
 		    int *arc_source;
 		    int *arc_target;
 		    int *arc_next_in;
 		    int *arc_next_out;
 		  };
 		  typedef DigraphExtender<StaticDigraphBase> ExtendedStaticDigraphBase;
 		  /// \ingroup graphs
 		  ///
 		  /// \brief A static directed graph class.
 		  ///
 		  /// \ref StaticDigraph is a highly efficient digraph implementation,
 		  /// but it is fully static.
 		  /// It stores only two \c int values for each node and only four \c int
 		  /// values for each arc. Moreover it provides faster item iteration than
 		  /// \ref ListDigraph and \ref SmartDigraph, especially using \c OutArcIt
 		  /// iterators, since its arcs are stored in an appropriate order.
 		  /// However it only provides build() and clear() functions and does not
 		  /// support any other modification of the digraph.
 		  ///
 		  /// Since this digraph structure is completely static, its nodes and arcs
 		  /// can be indexed with integers from the ranges <tt>[0..nodeNum()-1]</tt>
 		  /// and <tt>[0..arcNum()-1]</tt>, respectively.
 		  /// The index of an item is the same as its ID, it can be obtained
 		  /// using the corresponding \ref index() or \ref concepts::Digraph::id()
 		  /// "id()" function. A node or arc with a certain index can be obtained
 		  /// using node() or arc().
 		  ///
 		  /// This type fully conforms to the \ref concepts::Digraph "Digraph concept".
 		  /// Most of its member functions and nested classes are documented
 		  /// only in the concept class.
 		  ///
 		  /// \sa concepts::Digraph
 		  class StaticDigraph : public ExtendedStaticDigraphBase {
 		  public:
 		    typedef ExtendedStaticDigraphBase Parent;
 		  public:
 		    /// \brief Constructor
 		    ///
 		    /// Default constructor.
 		    StaticDigraph() : Parent() {}
 		    /// \brief The node with the given index.
 		    ///
 		    /// This function returns the node with the given index.
 		    /// \sa index()
-		    Node node(int ix) const { return Parent::nodeFromId(ix); }
+		    static Node node(int ix) { return Parent::nodeFromId(ix); }
 		    /// \brief The arc with the given index.
 		    ///
 		    /// This function returns the arc with the given index.
 		    /// \sa index()
-		    Arc arc(int ix) const { return Parent::arcFromId(ix); }
+		    static Arc arc(int ix) { return Parent::arcFromId(ix); }
 		    /// \brief The index of the given node.
 		    ///
 		    /// This function returns the index of the the given node.
 		    /// \sa node()
-		    int index(Node node) const { return Parent::id(node); }
+		    static int index(Node node) { return Parent::id(node); }
 		    /// \brief The index of the given arc.
 		    ///
 		    /// This function returns the index of the the given arc.
 		    /// \sa arc()
-		    int index(Arc arc) const { return Parent::id(arc); }
+		    static int index(Arc arc) { return Parent::id(arc); }
 		    /// \brief Number of nodes.
 		    ///
 		    /// This function returns the number of nodes.
 		    int nodeNum() const { return node_num; }
 		    /// \brief Number of arcs.
 		    ///
 		    /// This function returns the number of arcs.
 		    int arcNum() const { return arc_num; }
 		    /// \brief Build the digraph copying another digraph.
 		    ///
 		    /// This function builds the digraph copying another digraph of any
 		    /// kind. It can be called more than once, but in such case, the whole
 		    /// structure and all maps will be cleared and rebuilt.
 		    ///
 		    /// This method also makes possible to copy a digraph to a StaticDigraph
 		    /// structure using \ref DigraphCopy.
 		    ///
 		    /// \param digraph An existing digraph to be copied.
 		    /// \param nodeRef The node references will be copied into this map.
 		    /// Its key type must be \c Digraph::Node and its value type must be
 		    /// \c StaticDigraph::Node.
 		    /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap"
 		    /// concept.
 		    /// \param arcRef The arc references will be copied into this map.
 		    /// Its key type must be \c Digraph::Arc and its value type must be
 		    /// \c StaticDigraph::Arc.
 		    /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
 		    ///
 		    /// \note If you do not need the arc references, then you could use
 		    /// \ref NullMap for the last parameter. However the node references
 		    /// are required by the function itself, thus they must be readable
 		    /// from the map.
 		    template <typename Digraph, typename NodeRefMap, typename ArcRefMap>
 		    void build(const Digraph& digraph, NodeRefMap& nodeRef, ArcRefMap& arcRef) {
 		      if (built) Parent::clear();
 		      Parent::build(digraph, nodeRef, arcRef);
+		    }
 		    /// \brief Clear the digraph.
 		    ///
 		    /// This function erases all nodes and arcs from the digraph.
 		    void clear() {
 		      Parent::clear();
+		    }
 		  protected:
 		    using Parent::fastFirstOut;
 		    using Parent::fastNextOut;
 		    using Parent::fastLastOut;
 		  public:
 		    class OutArcIt : public Arc {
 		    public:
 		      OutArcIt() { }
 		      OutArcIt(Invalid i) : Arc(i) { }
 		      OutArcIt(const StaticDigraph& digraph, const Node& node) {
 			digraph.fastFirstOut(*this, node);
 			digraph.fastLastOut(last, node);
 		        if (last == *this) *this = INVALID;
+		      }
 		      OutArcIt(const StaticDigraph& digraph, const Arc& arc) : Arc(arc) {
 		        if (arc != INVALID) {
 		          digraph.fastLastOut(last, digraph.source(arc));
+		        }
+		      }
 		      OutArcIt& operator++() {
 		        StaticDigraph::fastNextOut(*this);
 		        if (last == *this) *this = INVALID;
 		        return *this;
+		      }
 		    private:
 		      Arc last;
 		    };
 		    Node baseNode(const OutArcIt &arc) const {
 		      return Parent::source(static_cast<const Arc&>(arc));
+		    }
 		    Node runningNode(const OutArcIt &arc) const {
 		      return Parent::target(static_cast<const Arc&>(arc));
+		    }
 		    Node baseNode(const InArcIt &arc) const {
 		      return Parent::target(static_cast<const Arc&>(arc));
+		    }
 		    Node runningNode(const InArcIt &arc) const {
 		      return Parent::source(static_cast<const Arc&>(arc));
+		    }
 		  };
+		}
 		#endif

0 comments (0 inline)

RhodeCode

Login to your account