LEMON/LEMON-main Changeset - r220:a5d8c039f218

Repositories » LEMON » LEMON-main

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

Changeset - r220:a5d8c039f218

« 217:b67149

221:64613d »

r220:a5d8c039f218

Tue, 15 Jul 2008 13:15:39

[Not Reviewed]

0 comments (0 inline)

deba@inf.elte.hu
deba@inf.elte.hu

Reorganize header files (Ticket #97) In addition on some places the DefaultMap<G, K, V> is replaced with ItemSetTraits<G, K>::template Map<V>::Type, to decrease the dependencies of different tools. It is obviously better solution.

3 31 2

default

36 files changed:

lemon/bits/enable_if.h

131

lemon/core.h

1851

demo/graph_to_eps_demo.cc

lemon/Makefile.am

lemon/base.cc

lemon/bfs.h

lemon/bits/alteration_notifier.h

lemon/bits/base_extender.h

lemon/bits/graph_extender.h

lemon/bits/traits.h

lemon/bits/vector_map.h

lemon/concepts/digraph.h

lemon/concepts/graph.h

lemon/concepts/graph_components.h

lemon/concepts/heap.h

lemon/concepts/maps.h

lemon/concepts/path.h

lemon/dfs.h

lemon/dijkstra.h

lemon/dim2.h

lemon/bits/invalid.h

lemon/bits/utility.h

140

Changeset was too big and was cut off... Show full diff

↑ Collapse diff ↑

lemon/bits/enable_if.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		// This file contains a modified version of the enable_if library from BOOST.
 		// See the appropriate copyright notice below.
 		// Boost enable_if library
 		// Copyright 2003 (c) The Trustees of Indiana University.
 		// Use, modification, and distribution is subject to the Boost Software
 		// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 		// http://www.boost.org/LICENSE_1_0.txt)
 		//    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
 		//             Jeremiah Willcock (jewillco at osl.iu.edu)
 		//             Andrew Lumsdaine (lums at osl.iu.edu)
 		#ifndef LEMON_BITS_ENABLE_IF_H
 		#define LEMON_BITS_ENABLE_IF_H
 		///\file
 		///\brief Miscellaneous basic utilities
 		namespace lemon
+		{
 		  /// Basic type for defining "tags". A "YES" condition for \c enable_if.
 		  /// Basic type for defining "tags". A "YES" condition for \c enable_if.
 		  ///
 		  ///\sa False
 		  struct True {
 		    ///\e
 		    static const bool value = true;
 		  };
 		  /// Basic type for defining "tags". A "NO" condition for \c enable_if.
 		  /// Basic type for defining "tags". A "NO" condition for \c enable_if.
 		  ///
 		  ///\sa True
 		  struct False {
 		    ///\e
 		    static const bool value = false;
 		  };
 		  template <typename T>
 		  struct Wrap {
 		    const T &value;
 		    Wrap(const T &t) : value(t) {}
 		  };
 		  /**************** dummy class to avoid ambiguity ****************/
 		  template<int T> struct dummy { dummy(int) {} };
 		  /**************** enable_if from BOOST ****************/
 		  template <typename Type, typename T = void>
 		  struct exists {
 		    typedef T type;
 		  };
 		  template <bool B, class T = void>
 		  struct enable_if_c {
 		    typedef T type;
 		  };
 		  template <class T>
 		  struct enable_if_c<false, T> {};
 		  template <class Cond, class T = void>
 		  struct enable_if : public enable_if_c<Cond::value, T> {};
 		  template <bool B, class T>
 		  struct lazy_enable_if_c {
 		    typedef typename T::type type;
 		  };
 		  template <class T>
 		  struct lazy_enable_if_c<false, T> {};
 		  template <class Cond, class T>
 		  struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {};
 		  template <bool B, class T = void>
 		  struct disable_if_c {
 		    typedef T type;
 		  };
 		  template <class T>
 		  struct disable_if_c<true, T> {};
 		  template <class Cond, class T = void>
 		  struct disable_if : public disable_if_c<Cond::value, T> {};
 		  template <bool B, class T>
 		  struct lazy_disable_if_c {
 		    typedef typename T::type type;
 		  };
 		  template <class T>
 		  struct lazy_disable_if_c<true, T> {};
 		  template <class Cond, class T>
 		  struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {};
 		} // namespace lemon
 		#endif

lemon/core.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_CORE_H
 		#define LEMON_CORE_H
 		#include <vector>
 		#include <algorithm>
 		#include <lemon/bits/enable_if.h>
 		#include <lemon/bits/traits.h>
 		///\file
 		///\brief LEMON core utilities.
 		namespace lemon {
 		  /// \brief Dummy type to make it easier to create invalid iterators.
 		  ///
 		  /// Dummy type to make it easier to create invalid iterators.
 		  /// See \ref INVALID for the usage.
 		  struct Invalid {
 		  public:
 		    bool operator==(Invalid) { return true;  }
 		    bool operator!=(Invalid) { return false; }
 		    bool operator< (Invalid) { return false; }
 		  };
 		  /// \brief Invalid iterators.
 		  ///
 		  /// \ref Invalid is a global type that converts to each iterator
 		  /// in such a way that the value of the target iterator will be invalid.
 		#ifdef LEMON_ONLY_TEMPLATES
 		  const Invalid INVALID = Invalid();
 		#else
 		  extern const Invalid INVALID;
 		#endif
 		  /// \addtogroup gutils
 		  /// @{
 		  ///Creates convenience typedefs for the digraph types and iterators
 		  ///This \c \#define creates convenience typedefs for the following types
 		  ///of \c Digraph: \c Node,  \c NodeIt, \c Arc, \c ArcIt, \c InArcIt,
 		  ///\c OutArcIt, \c BoolNodeMap, \c IntNodeMap, \c DoubleNodeMap,
 		  ///\c BoolArcMap, \c IntArcMap, \c DoubleArcMap.
 		  ///
 		  ///\note If the graph type is a dependent type, ie. the graph type depend
 		  ///on a template parameter, then use \c TEMPLATE_DIGRAPH_TYPEDEFS()
 		  ///macro.
 		#define DIGRAPH_TYPEDEFS(Digraph)                                       \
 		  typedef Digraph::Node Node;                                           \
 		  typedef Digraph::NodeIt NodeIt;                                       \
 		  typedef Digraph::Arc Arc;                                             \
 		  typedef Digraph::ArcIt ArcIt;                                         \
 		  typedef Digraph::InArcIt InArcIt;                                     \
 		  typedef Digraph::OutArcIt OutArcIt;                                   \
 		  typedef Digraph::NodeMap<bool> BoolNodeMap;                           \
 		  typedef Digraph::NodeMap<int> IntNodeMap;                             \
 		  typedef Digraph::NodeMap<double> DoubleNodeMap;                       \
 		  typedef Digraph::ArcMap<bool> BoolArcMap;                             \
 		  typedef Digraph::ArcMap<int> IntArcMap;                               \
 		  typedef Digraph::ArcMap<double> DoubleArcMap
 		  ///Creates convenience typedefs for the digraph types and iterators
 		  ///\see DIGRAPH_TYPEDEFS
 		  ///
 		  ///\note Use this macro, if the graph type is a dependent type,
 		  ///ie. the graph type depend on a template parameter.
 		#define TEMPLATE_DIGRAPH_TYPEDEFS(Digraph)                              \
 		  typedef typename Digraph::Node Node;                                  \
 		  typedef typename Digraph::NodeIt NodeIt;                              \
 		  typedef typename Digraph::Arc Arc;                                    \
 		  typedef typename Digraph::ArcIt ArcIt;                                \
 		  typedef typename Digraph::InArcIt InArcIt;                            \
 		  typedef typename Digraph::OutArcIt OutArcIt;                          \
 		  typedef typename Digraph::template NodeMap<bool> BoolNodeMap;         \
 		  typedef typename Digraph::template NodeMap<int> IntNodeMap;           \
 		  typedef typename Digraph::template NodeMap<double> DoubleNodeMap;     \
 		  typedef typename Digraph::template ArcMap<bool> BoolArcMap;           \
 		  typedef typename Digraph::template ArcMap<int> IntArcMap;             \
 		  typedef typename Digraph::template ArcMap<double> DoubleArcMap
 		  ///Creates convenience typedefs for the graph types and iterators
 		  ///This \c \#define creates the same convenience typedefs as defined
 		  ///by \ref DIGRAPH_TYPEDEFS(Graph) and six more, namely it creates
 		  ///\c Edge, \c EdgeIt, \c IncEdgeIt, \c BoolEdgeMap, \c IntEdgeMap,
 		  ///\c DoubleEdgeMap.
 		  ///
 		  ///\note If the graph type is a dependent type, ie. the graph type depend
 		  ///on a template parameter, then use \c TEMPLATE_DIGRAPH_TYPEDEFS()
 		  ///macro.
 		#define GRAPH_TYPEDEFS(Graph)                                           \
 		  DIGRAPH_TYPEDEFS(Graph);                                              \
 		  typedef Graph::Edge Edge;                                             \
 		  typedef Graph::EdgeIt EdgeIt;                                         \
 		  typedef Graph::IncEdgeIt IncEdgeIt;                                   \
 		  typedef Graph::EdgeMap<bool> BoolEdgeMap;                             \
 		  typedef Graph::EdgeMap<int> IntEdgeMap;                               \
 		  typedef Graph::EdgeMap<double> DoubleEdgeMap
 		  ///Creates convenience typedefs for the graph types and iterators
 		  ///\see GRAPH_TYPEDEFS
 		  ///
 		  ///\note Use this macro, if the graph type is a dependent type,
 		  ///ie. the graph type depend on a template parameter.
 		#define TEMPLATE_GRAPH_TYPEDEFS(Graph)                                  \
 		  TEMPLATE_DIGRAPH_TYPEDEFS(Graph);                                     \
 		  typedef typename Graph::Edge Edge;                                    \
 		  typedef typename Graph::EdgeIt EdgeIt;                                \
 		  typedef typename Graph::IncEdgeIt IncEdgeIt;                          \
 		  typedef typename Graph::template EdgeMap<bool> BoolEdgeMap;           \
 		  typedef typename Graph::template EdgeMap<int> IntEdgeMap;             \
 		  typedef typename Graph::template EdgeMap<double> DoubleEdgeMap
 		  /// \brief Function to count the items in the graph.
 		  ///
 		  /// This function counts the items (nodes, arcs etc) in the graph.
 		  /// The complexity of the function is O(n) because
 		  /// it iterates on all of the items.
 		  template <typename Graph, typename Item>
 		  inline int countItems(const Graph& g) {
 		    typedef typename ItemSetTraits<Graph, Item>::ItemIt ItemIt;
 		    int num = 0;
 		    for (ItemIt it(g); it != INVALID; ++it) {
 		      ++num;
+		    }
 		    return num;
+		  }
 		  // Node counting:
 		  namespace _core_bits {
 		    template <typename Graph, typename Enable = void>
 		    struct CountNodesSelector {
 		      static int count(const Graph &g) {
 		        return countItems<Graph, typename Graph::Node>(g);
+		      }
 		    };
 		    template <typename Graph>
 		    struct CountNodesSelector<
 		      Graph, typename
 		      enable_if<typename Graph::NodeNumTag, void>::type>
+		    {
 		      static int count(const Graph &g) {
 		        return g.nodeNum();
+		      }
 		    };
+		  }
 		  /// \brief Function to count the nodes in the graph.
 		  ///
 		  /// This function counts the nodes in the graph.
 		  /// The complexity of the function is O(n) but for some
 		  /// graph structures it is specialized to run in O(1).
 		  ///
 		  /// If the graph contains a \e nodeNum() member function and a
 		  /// \e NodeNumTag tag then this function calls directly the member
 		  /// function to query the cardinality of the node set.
 		  template <typename Graph>
 		  inline int countNodes(const Graph& g) {
 		    return _core_bits::CountNodesSelector<Graph>::count(g);
+		  }
 		  // Arc counting:
 		  namespace _core_bits {
 		    template <typename Graph, typename Enable = void>
 		    struct CountArcsSelector {
 		      static int count(const Graph &g) {
 		        return countItems<Graph, typename Graph::Arc>(g);
+		      }
 		    };
 		    template <typename Graph>
 		    struct CountArcsSelector<
 		      Graph,
 		      typename enable_if<typename Graph::ArcNumTag, void>::type>
+		    {
 		      static int count(const Graph &g) {
 		        return g.arcNum();
+		      }
 		    };
+		  }
 		  /// \brief Function to count the arcs in the graph.
 		  ///
 		  /// This function counts the arcs in the graph.
 		  /// The complexity of the function is O(e) but for some
 		  /// graph structures it is specialized to run in O(1).
 		  ///
 		  /// If the graph contains a \e arcNum() member function and a
 		  /// \e EdgeNumTag tag then this function calls directly the member
 		  /// function to query the cardinality of the arc set.
 		  template <typename Graph>
 		  inline int countArcs(const Graph& g) {
 		    return _core_bits::CountArcsSelector<Graph>::count(g);
+		  }
 		  // Edge counting:
 		  namespace _core_bits {
 		    template <typename Graph, typename Enable = void>
 		    struct CountEdgesSelector {
 		      static int count(const Graph &g) {
 		        return countItems<Graph, typename Graph::Edge>(g);
+		      }
 		    };
 		    template <typename Graph>
 		    struct CountEdgesSelector<
 		      Graph,
 		      typename enable_if<typename Graph::EdgeNumTag, void>::type>
+		    {
 		      static int count(const Graph &g) {
 		        return g.edgeNum();
+		      }
 		    };
+		  }
 		  /// \brief Function to count the edges in the graph.
 		  ///
 		  /// This function counts the edges in the graph.
 		  /// The complexity of the function is O(m) but for some
 		  /// graph structures it is specialized to run in O(1).
 		  ///
 		  /// If the graph contains a \e edgeNum() member function and a
 		  /// \e EdgeNumTag tag then this function calls directly the member
 		  /// function to query the cardinality of the edge set.
 		  template <typename Graph>
 		  inline int countEdges(const Graph& g) {
 		    return _core_bits::CountEdgesSelector<Graph>::count(g);
+		  }
 		  template <typename Graph, typename DegIt>
 		  inline int countNodeDegree(const Graph& _g, const typename Graph::Node& _n) {
 		    int num = 0;
 		    for (DegIt it(_g, _n); it != INVALID; ++it) {
 		      ++num;
+		    }
 		    return num;
+		  }
 		  /// \brief Function to count the number of the out-arcs from node \c n.
 		  ///
 		  /// This function counts the number of the out-arcs from node \c n
 		  /// in the graph.
 		  template <typename Graph>
 		  inline int countOutArcs(const Graph& _g,  const typename Graph::Node& _n) {
 		    return countNodeDegree<Graph, typename Graph::OutArcIt>(_g, _n);
+		  }
 		  /// \brief Function to count the number of the in-arcs to node \c n.
 		  ///
 		  /// This function counts the number of the in-arcs to node \c n
 		  /// in the graph.
 		  template <typename Graph>
 		  inline int countInArcs(const Graph& _g,  const typename Graph::Node& _n) {
 		    return countNodeDegree<Graph, typename Graph::InArcIt>(_g, _n);
+		  }
 		  /// \brief Function to count the number of the inc-edges to node \c n.
 		  ///
 		  /// This function counts the number of the inc-edges to node \c n
 		  /// in the graph.
 		  template <typename Graph>
 		  inline int countIncEdges(const Graph& _g,  const typename Graph::Node& _n) {
 		    return countNodeDegree<Graph, typename Graph::IncEdgeIt>(_g, _n);
+		  }
 		  namespace _core_bits {
 		    template <typename Digraph, typename Item, typename RefMap>
 		    class MapCopyBase {
 		    public:
 		      virtual void copy(const Digraph& from, const RefMap& refMap) = 0;
 		      virtual ~MapCopyBase() {}
 		    };
 		    template <typename Digraph, typename Item, typename RefMap,
 		              typename ToMap, typename FromMap>
 		    class MapCopy : public MapCopyBase<Digraph, Item, RefMap> {
 		    public:
 		      MapCopy(ToMap& tmap, const FromMap& map)
 		        : _tmap(tmap), _map(map) {}
 		      virtual void copy(const Digraph& digraph, const RefMap& refMap) {
 		        typedef typename ItemSetTraits<Digraph, Item>::ItemIt ItemIt;
 		        for (ItemIt it(digraph); it != INVALID; ++it) {
 		          _tmap.set(refMap[it], _map[it]);
+		        }
+		      }
 		    private:
 		      ToMap& _tmap;
 		      const FromMap& _map;
 		    };
 		    template <typename Digraph, typename Item, typename RefMap, typename It>
 		    class ItemCopy : public MapCopyBase<Digraph, Item, RefMap> {
 		    public:
 		      ItemCopy(It& it, const Item& item) : _it(it), _item(item) {}
 		      virtual void copy(const Digraph&, const RefMap& refMap) {
 		        _it = refMap[_item];
+		      }
 		    private:
 		      It& _it;
 		      Item _item;
 		    };
 		    template <typename Digraph, typename Item, typename RefMap, typename Ref>
 		    class RefCopy : public MapCopyBase<Digraph, Item, RefMap> {
 		    public:
 		      RefCopy(Ref& map) : _map(map) {}
 		      virtual void copy(const Digraph& digraph, const RefMap& refMap) {
 		        typedef typename ItemSetTraits<Digraph, Item>::ItemIt ItemIt;
 		        for (ItemIt it(digraph); it != INVALID; ++it) {
 		          _map.set(it, refMap[it]);
+		        }
+		      }
 		    private:
 		      Ref& _map;
 		    };
 		    template <typename Digraph, typename Item, typename RefMap,
 		              typename CrossRef>
 		    class CrossRefCopy : public MapCopyBase<Digraph, Item, RefMap> {
 		    public:
 		      CrossRefCopy(CrossRef& cmap) : _cmap(cmap) {}
 		      virtual void copy(const Digraph& digraph, const RefMap& refMap) {
 		        typedef typename ItemSetTraits<Digraph, Item>::ItemIt ItemIt;
 		        for (ItemIt it(digraph); it != INVALID; ++it) {
 		          _cmap.set(refMap[it], it);
+		        }
+		      }
 		    private:
 		      CrossRef& _cmap;
 		    };
 		    template <typename Digraph, typename Enable = void>
 		    struct DigraphCopySelector {
 		      template <typename From, typename NodeRefMap, typename ArcRefMap>
 		      static void copy(Digraph &to, const From& from,
 		                       NodeRefMap& nodeRefMap, ArcRefMap& arcRefMap) {
 		        for (typename From::NodeIt it(from); it != INVALID; ++it) {
 		          nodeRefMap[it] = to.addNode();
+		        }
 		        for (typename From::ArcIt it(from); it != INVALID; ++it) {
 		          arcRefMap[it] = to.addArc(nodeRefMap[from.source(it)],
 		                                    nodeRefMap[from.target(it)]);
+		        }
+		      }
 		    };
 		    template <typename Digraph>
 		    struct DigraphCopySelector<
 		      Digraph,
 		      typename enable_if<typename Digraph::BuildTag, void>::type>
+		    {
 		      template <typename From, typename NodeRefMap, typename ArcRefMap>
 		      static void copy(Digraph &to, const From& from,
 		                       NodeRefMap& nodeRefMap, ArcRefMap& arcRefMap) {
 		        to.build(from, nodeRefMap, arcRefMap);
+		      }
 		    };
 		    template <typename Graph, typename Enable = void>
 		    struct GraphCopySelector {
 		      template <typename From, typename NodeRefMap, typename EdgeRefMap>
 		      static void copy(Graph &to, const From& from,
 		                       NodeRefMap& nodeRefMap, EdgeRefMap& edgeRefMap) {
 		        for (typename From::NodeIt it(from); it != INVALID; ++it) {
 		          nodeRefMap[it] = to.addNode();
+		        }
 		        for (typename From::EdgeIt it(from); it != INVALID; ++it) {
 		          edgeRefMap[it] = to.addEdge(nodeRefMap[from.u(it)],
 		                                      nodeRefMap[from.v(it)]);
+		        }
+		      }
 		    };
 		    template <typename Graph>
 		    struct GraphCopySelector<
 		      Graph,
 		      typename enable_if<typename Graph::BuildTag, void>::type>
+		    {
 		      template <typename From, typename NodeRefMap, typename EdgeRefMap>
 		      static void copy(Graph &to, const From& from,
 		                       NodeRefMap& nodeRefMap, EdgeRefMap& edgeRefMap) {
 		        to.build(from, nodeRefMap, edgeRefMap);
+		      }
 		    };
+		  }
 		  /// \brief Class to copy a digraph.
 		  ///
 		  /// Class to copy a digraph to another digraph (duplicate a digraph). The
 		  /// simplest way of using it is through the \c copyDigraph() function.
 		  ///
 		  /// This class not just make a copy of a graph, but it can create
 		  /// references and cross references between the nodes and arcs of
 		  /// the two graphs, it can copy maps for use with the newly created
 		  /// graph and copy nodes and arcs.
 		  ///
 		  /// To make a copy from a graph, first an instance of DigraphCopy
 		  /// should be created, then the data belongs to the graph should
 		  /// assigned to copy. In the end, the \c run() member should be
 		  /// called.
 		  ///
 		  /// The next code copies a graph with several data:
 		  ///\code
 		  ///  DigraphCopy<NewGraph, OrigGraph> dc(new_graph, orig_graph);
 		  ///  // create a reference for the nodes
 		  ///  OrigGraph::NodeMap<NewGraph::Node> nr(orig_graph);
 		  ///  dc.nodeRef(nr);
 		  ///  // create a cross reference (inverse) for the arcs
 		  ///  NewGraph::ArcMap<OrigGraph::Arc> acr(new_graph);
 		  ///  dc.arcCrossRef(acr);
 		  ///  // copy an arc map
 		  ///  OrigGraph::ArcMap<double> oamap(orig_graph);
 		  ///  NewGraph::ArcMap<double> namap(new_graph);
 		  ///  dc.arcMap(namap, oamap);
 		  ///  // copy a node
 		  ///  OrigGraph::Node on;
 		  ///  NewGraph::Node nn;
 		  ///  dc.node(nn, on);
 		  ///  // Executions of copy
 		  ///  dc.run();
 		  ///\endcode
 		  template <typename To, typename From>
 		  class DigraphCopy {
 		  private:
 		    typedef typename From::Node Node;
 		    typedef typename From::NodeIt NodeIt;
 		    typedef typename From::Arc Arc;
 		    typedef typename From::ArcIt ArcIt;
 		    typedef typename To::Node TNode;
 		    typedef typename To::Arc TArc;
 		    typedef typename From::template NodeMap<TNode> NodeRefMap;
 		    typedef typename From::template ArcMap<TArc> ArcRefMap;
 		  public:
 		    /// \brief Constructor for the DigraphCopy.
 		    ///
 		    /// It copies the content of the \c _from digraph into the
 		    /// \c _to digraph.
 		    DigraphCopy(To& to, const From& from)
 		      : _from(from), _to(to) {}
 		    /// \brief Destructor of the DigraphCopy
 		    ///
 		    /// Destructor of the DigraphCopy
 		    ~DigraphCopy() {
 		      for (int i = 0; i < int(_node_maps.size()); ++i) {
 		        delete _node_maps[i];
+		      }
 		      for (int i = 0; i < int(_arc_maps.size()); ++i) {
 		        delete _arc_maps[i];
+		      }
+		    }
 		    /// \brief Copies the node references into the given map.
 		    ///
 		    /// Copies the node references into the given map. The parameter
 		    /// should be a map, which key type is the Node type of the source
 		    /// graph, while the value type is the Node type of the
 		    /// destination graph.
 		    template <typename NodeRef>
 		    DigraphCopy& nodeRef(NodeRef& map) {
 		      _node_maps.push_back(new _core_bits::RefCopy<From, Node,
 		                           NodeRefMap, NodeRef>(map));
 		      return *this;
+		    }
 		    /// \brief Copies the node cross references into the given map.
 		    ///
 		    ///  Copies the node cross references (reverse references) into
 		    ///  the given map. The parameter should be a map, which key type
 		    ///  is the Node type of the destination graph, while the value type is
 		    ///  the Node type of the source graph.
 		    template <typename NodeCrossRef>
 		    DigraphCopy& nodeCrossRef(NodeCrossRef& map) {
 		      _node_maps.push_back(new _core_bits::CrossRefCopy<From, Node,
 		                           NodeRefMap, NodeCrossRef>(map));
 		      return *this;
+		    }
 		    /// \brief Make copy of the given map.
 		    ///
 		    /// Makes copy of the given map for the newly created digraph.
 		    /// The new map's key type is the destination graph's node type,
 		    /// and the copied map's key type is the source graph's node type.
 		    template <typename ToMap, typename FromMap>
 		    DigraphCopy& nodeMap(ToMap& tmap, const FromMap& map) {
 		      _node_maps.push_back(new _core_bits::MapCopy<From, Node,
 		                           NodeRefMap, ToMap, FromMap>(tmap, map));
 		      return *this;
+		    }
 		    /// \brief Make a copy of the given node.
 		    ///
 		    /// Make a copy of the given node.
 		    DigraphCopy& node(TNode& tnode, const Node& snode) {
 		      _node_maps.push_back(new _core_bits::ItemCopy<From, Node,
 		                           NodeRefMap, TNode>(tnode, snode));
 		      return *this;
+		    }
 		    /// \brief Copies the arc references into the given map.
 		    ///
 		    /// Copies the arc references into the given map.
 		    template <typename ArcRef>
 		    DigraphCopy& arcRef(ArcRef& map) {
 		      _arc_maps.push_back(new _core_bits::RefCopy<From, Arc,
 		                          ArcRefMap, ArcRef>(map));
 		      return *this;
+		    }
 		    /// \brief Copies the arc cross references into the given map.
 		    ///
 		    ///  Copies the arc cross references (reverse references) into
 		    ///  the given map.
 		    template <typename ArcCrossRef>
 		    DigraphCopy& arcCrossRef(ArcCrossRef& map) {
 		      _arc_maps.push_back(new _core_bits::CrossRefCopy<From, Arc,
 		                          ArcRefMap, ArcCrossRef>(map));
 		      return *this;
+		    }
 		    /// \brief Make copy of the given map.
 		    ///
 		    /// Makes copy of the given map for the newly created digraph.
 		    /// The new map's key type is the to digraph's arc type,
 		    /// and the copied map's key type is the from digraph's arc
 		    /// type.
 		    template <typename ToMap, typename FromMap>
 		    DigraphCopy& arcMap(ToMap& tmap, const FromMap& map) {
 		      _arc_maps.push_back(new _core_bits::MapCopy<From, Arc,
 		                          ArcRefMap, ToMap, FromMap>(tmap, map));
 		      return *this;
+		    }
 		    /// \brief Make a copy of the given arc.
 		    ///
 		    /// Make a copy of the given arc.
 		    DigraphCopy& arc(TArc& tarc, const Arc& sarc) {
 		      _arc_maps.push_back(new _core_bits::ItemCopy<From, Arc,
 		                          ArcRefMap, TArc>(tarc, sarc));
 		      return *this;
+		    }
 		    /// \brief Executes the copies.
 		    ///
 		    /// Executes the copies.
 		    void run() {
 		      NodeRefMap nodeRefMap(_from);
 		      ArcRefMap arcRefMap(_from);
 		      _core_bits::DigraphCopySelector<To>::
 		        copy(_to, _from, nodeRefMap, arcRefMap);
 		      for (int i = 0; i < int(_node_maps.size()); ++i) {
 		        _node_maps[i]->copy(_from, nodeRefMap);
+		      }
 		      for (int i = 0; i < int(_arc_maps.size()); ++i) {
 		        _arc_maps[i]->copy(_from, arcRefMap);
+		      }
+		    }
 		  protected:
 		    const From& _from;
 		    To& _to;
 		    std::vector<_core_bits::MapCopyBase<From, Node, NodeRefMap>* >
 		    _node_maps;
 		    std::vector<_core_bits::MapCopyBase<From, Arc, ArcRefMap>* >
 		    _arc_maps;
 		  };
 		  /// \brief Copy a digraph to another digraph.
 		  ///
 		  /// Copy a digraph to another digraph. The complete usage of the
 		  /// function is detailed in the DigraphCopy class, but a short
 		  /// example shows a basic work:
 		  ///\code
 		  /// copyDigraph(trg, src).nodeRef(nr).arcCrossRef(ecr).run();
 		  ///\endcode
 		  ///
 		  /// After the copy the \c nr map will contain the mapping from the
 		  /// nodes of the \c from digraph to the nodes of the \c to digraph and
 		  /// \c ecr will contain the mapping from the arcs of the \c to digraph
 		  /// to the arcs of the \c from digraph.
 		  ///
 		  /// \see DigraphCopy
 		  template <typename To, typename From>
 		  DigraphCopy<To, From> copyDigraph(To& to, const From& from) {
 		    return DigraphCopy<To, From>(to, from);
+		  }
 		  /// \brief Class to copy a graph.
 		  ///
 		  /// Class to copy a graph to another graph (duplicate a graph). The
 		  /// simplest way of using it is through the \c copyGraph() function.
 		  ///
 		  /// This class not just make a copy of a graph, but it can create
 		  /// references and cross references between the nodes, edges and arcs of
 		  /// the two graphs, it can copy maps for use with the newly created
 		  /// graph and copy nodes, edges and arcs.
 		  ///
 		  /// To make a copy from a graph, first an instance of GraphCopy
 		  /// should be created, then the data belongs to the graph should
 		  /// assigned to copy. In the end, the \c run() member should be
 		  /// called.
 		  ///
 		  /// The next code copies a graph with several data:
 		  ///\code
 		  ///  GraphCopy<NewGraph, OrigGraph> dc(new_graph, orig_graph);
 		  ///  // create a reference for the nodes
 		  ///  OrigGraph::NodeMap<NewGraph::Node> nr(orig_graph);
 		  ///  dc.nodeRef(nr);
 		  ///  // create a cross reference (inverse) for the edges
 		  ///  NewGraph::EdgeMap<OrigGraph::Arc> ecr(new_graph);
 		  ///  dc.edgeCrossRef(ecr);
 		  ///  // copy an arc map
 		  ///  OrigGraph::ArcMap<double> oamap(orig_graph);
 		  ///  NewGraph::ArcMap<double> namap(new_graph);
 		  ///  dc.arcMap(namap, oamap);
 		  ///  // copy a node
 		  ///  OrigGraph::Node on;
 		  ///  NewGraph::Node nn;
 		  ///  dc.node(nn, on);
 		  ///  // Executions of copy
 		  ///  dc.run();
 		  ///\endcode
 		  template <typename To, typename From>
 		  class GraphCopy {
 		  private:
 		    typedef typename From::Node Node;
 		    typedef typename From::NodeIt NodeIt;
 		    typedef typename From::Arc Arc;
 		    typedef typename From::ArcIt ArcIt;
 		    typedef typename From::Edge Edge;
 		    typedef typename From::EdgeIt EdgeIt;
 		    typedef typename To::Node TNode;
 		    typedef typename To::Arc TArc;
 		    typedef typename To::Edge TEdge;
 		    typedef typename From::template NodeMap<TNode> NodeRefMap;
 		    typedef typename From::template EdgeMap<TEdge> EdgeRefMap;
 		    struct ArcRefMap {
 		      ArcRefMap(const To& to, const From& from,
 		                const EdgeRefMap& edge_ref, const NodeRefMap& node_ref)
 		        : _to(to), _from(from),
 		          _edge_ref(edge_ref), _node_ref(node_ref) {}
 		      typedef typename From::Arc Key;
 		      typedef typename To::Arc Value;
 		      Value operator[](const Key& key) const {
 		        bool forward = _from.u(key) != _from.v(key) ?
 		          _node_ref[_from.source(key)] ==
 		          _to.source(_to.direct(_edge_ref[key], true)) :
 		          _from.direction(key);
 		        return _to.direct(_edge_ref[key], forward);
+		      }
 		      const To& _to;
 		      const From& _from;
 		      const EdgeRefMap& _edge_ref;
 		      const NodeRefMap& _node_ref;
 		    };
 		  public:
 		    /// \brief Constructor for the GraphCopy.
 		    ///
 		    /// It copies the content of the \c _from graph into the
 		    /// \c _to graph.
 		    GraphCopy(To& to, const From& from)
 		      : _from(from), _to(to) {}
 		    /// \brief Destructor of the GraphCopy
 		    ///
 		    /// Destructor of the GraphCopy
 		    ~GraphCopy() {
 		      for (int i = 0; i < int(_node_maps.size()); ++i) {
 		        delete _node_maps[i];
+		      }
 		      for (int i = 0; i < int(_arc_maps.size()); ++i) {
 		        delete _arc_maps[i];
+		      }
 		      for (int i = 0; i < int(_edge_maps.size()); ++i) {
 		        delete _edge_maps[i];
+		      }
+		    }
 		    /// \brief Copies the node references into the given map.
 		    ///
 		    /// Copies the node references into the given map.
 		    template <typename NodeRef>
 		    GraphCopy& nodeRef(NodeRef& map) {
 		      _node_maps.push_back(new _core_bits::RefCopy<From, Node,
 		                           NodeRefMap, NodeRef>(map));
 		      return *this;
+		    }
 		    /// \brief Copies the node cross references into the given map.
 		    ///
 		    ///  Copies the node cross references (reverse references) into
 		    ///  the given map.
 		    template <typename NodeCrossRef>
 		    GraphCopy& nodeCrossRef(NodeCrossRef& map) {
 		      _node_maps.push_back(new _core_bits::CrossRefCopy<From, Node,
 		                           NodeRefMap, NodeCrossRef>(map));
 		      return *this;
+		    }
 		    /// \brief Make copy of the given map.
 		    ///
 		    /// Makes copy of the given map for the newly created graph.
 		    /// The new map's key type is the to graph's node type,
 		    /// and the copied map's key type is the from graph's node
 		    /// type.
 		    template <typename ToMap, typename FromMap>
 		    GraphCopy& nodeMap(ToMap& tmap, const FromMap& map) {
 		      _node_maps.push_back(new _core_bits::MapCopy<From, Node,
 		                           NodeRefMap, ToMap, FromMap>(tmap, map));
 		      return *this;
+		    }
 		    /// \brief Make a copy of the given node.
 		    ///
 		    /// Make a copy of the given node.
 		    GraphCopy& node(TNode& tnode, const Node& snode) {
 		      _node_maps.push_back(new _core_bits::ItemCopy<From, Node,
 		                           NodeRefMap, TNode>(tnode, snode));
 		      return *this;
+		    }
 		    /// \brief Copies the arc references into the given map.
 		    ///
 		    /// Copies the arc references into the given map.
 		    template <typename ArcRef>
 		    GraphCopy& arcRef(ArcRef& map) {
 		      _arc_maps.push_back(new _core_bits::RefCopy<From, Arc,
 		                          ArcRefMap, ArcRef>(map));
 		      return *this;
+		    }
 		    /// \brief Copies the arc cross references into the given map.
 		    ///
 		    ///  Copies the arc cross references (reverse references) into
 		    ///  the given map.
 		    template <typename ArcCrossRef>
 		    GraphCopy& arcCrossRef(ArcCrossRef& map) {
 		      _arc_maps.push_back(new _core_bits::CrossRefCopy<From, Arc,
 		                          ArcRefMap, ArcCrossRef>(map));
 		      return *this;
+		    }
 		    /// \brief Make copy of the given map.
 		    ///
 		    /// Makes copy of the given map for the newly created graph.
 		    /// The new map's key type is the to graph's arc type,
 		    /// and the copied map's key type is the from graph's arc
 		    /// type.
 		    template <typename ToMap, typename FromMap>
 		    GraphCopy& arcMap(ToMap& tmap, const FromMap& map) {
 		      _arc_maps.push_back(new _core_bits::MapCopy<From, Arc,
 		                          ArcRefMap, ToMap, FromMap>(tmap, map));
 		      return *this;
+		    }
 		    /// \brief Make a copy of the given arc.
 		    ///
 		    /// Make a copy of the given arc.
 		    GraphCopy& arc(TArc& tarc, const Arc& sarc) {
 		      _arc_maps.push_back(new _core_bits::ItemCopy<From, Arc,
 		                          ArcRefMap, TArc>(tarc, sarc));
 		      return *this;
+		    }
 		    /// \brief Copies the edge references into the given map.
 		    ///
 		    /// Copies the edge references into the given map.
 		    template <typename EdgeRef>
 		    GraphCopy& edgeRef(EdgeRef& map) {
 		      _edge_maps.push_back(new _core_bits::RefCopy<From, Edge,
 		                           EdgeRefMap, EdgeRef>(map));
 		      return *this;
+		    }
 		    /// \brief Copies the edge cross references into the given map.
 		    ///
 		    /// Copies the edge cross references (reverse
 		    /// references) into the given map.
 		    template <typename EdgeCrossRef>
 		    GraphCopy& edgeCrossRef(EdgeCrossRef& map) {
 		      _edge_maps.push_back(new _core_bits::CrossRefCopy<From,
 		                           Edge, EdgeRefMap, EdgeCrossRef>(map));
 		      return *this;
+		    }
 		    /// \brief Make copy of the given map.
 		    ///
 		    /// Makes copy of the given map for the newly created graph.
 		    /// The new map's key type is the to graph's edge type,
 		    /// and the copied map's key type is the from graph's edge
 		    /// type.
 		    template <typename ToMap, typename FromMap>
 		    GraphCopy& edgeMap(ToMap& tmap, const FromMap& map) {
 		      _edge_maps.push_back(new _core_bits::MapCopy<From, Edge,
 		                           EdgeRefMap, ToMap, FromMap>(tmap, map));
 		      return *this;
+		    }
 		    /// \brief Make a copy of the given edge.
 		    ///
 		    /// Make a copy of the given edge.
 		    GraphCopy& edge(TEdge& tedge, const Edge& sedge) {
 		      _edge_maps.push_back(new _core_bits::ItemCopy<From, Edge,
 		                           EdgeRefMap, TEdge>(tedge, sedge));
 		      return *this;
+		    }
 		    /// \brief Executes the copies.
 		    ///
 		    /// Executes the copies.
 		    void run() {
 		      NodeRefMap nodeRefMap(_from);
 		      EdgeRefMap edgeRefMap(_from);
 		      ArcRefMap arcRefMap(_to, _from, edgeRefMap, nodeRefMap);
 		      _core_bits::GraphCopySelector<To>::
 		        copy(_to, _from, nodeRefMap, edgeRefMap);
 		      for (int i = 0; i < int(_node_maps.size()); ++i) {
 		        _node_maps[i]->copy(_from, nodeRefMap);
+		      }
 		      for (int i = 0; i < int(_edge_maps.size()); ++i) {
 		        _edge_maps[i]->copy(_from, edgeRefMap);
+		      }
 		      for (int i = 0; i < int(_arc_maps.size()); ++i) {
 		        _arc_maps[i]->copy(_from, arcRefMap);
+		      }
+		    }
 		  private:
 		    const From& _from;
 		    To& _to;
 		    std::vector<_core_bits::MapCopyBase<From, Node, NodeRefMap>* >
 		    _node_maps;
 		    std::vector<_core_bits::MapCopyBase<From, Arc, ArcRefMap>* >
 		    _arc_maps;
 		    std::vector<_core_bits::MapCopyBase<From, Edge, EdgeRefMap>* >
 		    _edge_maps;
 		  };
 		  /// \brief Copy a graph to another graph.
 		  ///
 		  /// Copy a graph to another graph. The complete usage of the
 		  /// function is detailed in the GraphCopy class, but a short
 		  /// example shows a basic work:
 		  ///\code
 		  /// copyGraph(trg, src).nodeRef(nr).arcCrossRef(ecr).run();
 		  ///\endcode
 		  ///
 		  /// After the copy the \c nr map will contain the mapping from the
 		  /// nodes of the \c from graph to the nodes of the \c to graph and
 		  /// \c ecr will contain the mapping from the arcs of the \c to graph
 		  /// to the arcs of the \c from graph.
 		  ///
 		  /// \see GraphCopy
 		  template <typename To, typename From>
 		  GraphCopy<To, From>
 		  copyGraph(To& to, const From& from) {
 		    return GraphCopy<To, From>(to, from);
+		  }
 		  namespace _core_bits {
 		    template <typename Graph, typename Enable = void>
 		    struct FindArcSelector {
 		      typedef typename Graph::Node Node;
 		      typedef typename Graph::Arc Arc;
 		      static Arc find(const Graph &g, Node u, Node v, Arc e) {
 		        if (e == INVALID) {
 		          g.firstOut(e, u);
 		        } else {
 		          g.nextOut(e);
+		        }
 		        while (e != INVALID && g.target(e) != v) {
 		          g.nextOut(e);
+		        }
 		        return e;
+		      }
 		    };
 		    template <typename Graph>
 		    struct FindArcSelector<
 		      Graph,
 		      typename enable_if<typename Graph::FindEdgeTag, void>::type>
+		    {
 		      typedef typename Graph::Node Node;
 		      typedef typename Graph::Arc Arc;
 		      static Arc find(const Graph &g, Node u, Node v, Arc prev) {
 		        return g.findArc(u, v, prev);
+		      }
 		    };
+		  }
 		  /// \brief Finds an arc between two nodes of a graph.
 		  ///
 		  /// Finds an arc from node \c u to node \c v in graph \c g.
 		  ///
 		  /// If \c prev is \ref INVALID (this is the default value), then
 		  /// it finds the first arc from \c u to \c v. Otherwise it looks for
 		  /// the next arc from \c u to \c v after \c prev.
 		  /// \return The found arc or \ref INVALID if there is no such an arc.
 		  ///
 		  /// Thus you can iterate through each arc from \c u to \c v as it follows.
 		  ///\code
 		  /// for(Arc e=findArc(g,u,v);e!=INVALID;e=findArc(g,u,v,e)) {
 		  ///   ...
 		  /// }
 		  ///\endcode
 		  ///
 		  ///\sa ArcLookUp
 		  ///\sa AllArcLookUp
 		  ///\sa DynArcLookUp
 		  ///\sa ConArcIt
 		  template <typename Graph>
 		  inline typename Graph::Arc
 		  findArc(const Graph &g, typename Graph::Node u, typename Graph::Node v,
 		          typename Graph::Arc prev = INVALID) {
 		    return _core_bits::FindArcSelector<Graph>::find(g, u, v, prev);
+		  }
 		  /// \brief Iterator for iterating on arcs connected the same nodes.
 		  ///
 		  /// Iterator for iterating on arcs connected the same nodes. It is
 		  /// higher level interface for the findArc() function. You can
 		  /// use it the following way:
 		  ///\code
 		  /// for (ConArcIt<Graph> it(g, src, trg); it != INVALID; ++it) {
 		  ///   ...
 		  /// }
 		  ///\endcode
 		  ///
 		  ///\sa findArc()
 		  ///\sa ArcLookUp
 		  ///\sa AllArcLookUp
 		  ///\sa DynArcLookUp
 		  template <typename _Graph>
 		  class ConArcIt : public _Graph::Arc {
 		  public:
 		    typedef _Graph Graph;
 		    typedef typename Graph::Arc Parent;
 		    typedef typename Graph::Arc Arc;
 		    typedef typename Graph::Node Node;
 		    /// \brief Constructor.
 		    ///
 		    /// Construct a new ConArcIt iterating on the arcs which
 		    /// connects the \c u and \c v node.
 		    ConArcIt(const Graph& g, Node u, Node v) : _graph(g) {
 		      Parent::operator=(findArc(_graph, u, v));
+		    }
 		    /// \brief Constructor.
 		    ///
 		    /// Construct a new ConArcIt which continues the iterating from
 		    /// the \c e arc.
 		    ConArcIt(const Graph& g, Arc a) : Parent(a), _graph(g) {}
 		    /// \brief Increment operator.
 		    ///
 		    /// It increments the iterator and gives back the next arc.
 		    ConArcIt& operator++() {
 		      Parent::operator=(findArc(_graph, _graph.source(*this),
 		                                _graph.target(*this), *this));
 		      return *this;
+		    }
 		  private:
 		    const Graph& _graph;
 		  };
 		  namespace _core_bits {
 		    template <typename Graph, typename Enable = void>
 		    struct FindEdgeSelector {
 		      typedef typename Graph::Node Node;
 		      typedef typename Graph::Edge Edge;
 		      static Edge find(const Graph &g, Node u, Node v, Edge e) {
 		        bool b;
 		        if (u != v) {
 		          if (e == INVALID) {
 		            g.firstInc(e, b, u);
 		          } else {
 		            b = g.u(e) == u;
 		            g.nextInc(e, b);
+		          }
 		          while (e != INVALID && (b ? g.v(e) : g.u(e)) != v) {
 		            g.nextInc(e, b);
+		          }
 		        } else {
 		          if (e == INVALID) {
 		            g.firstInc(e, b, u);
 		          } else {
 		            b = true;
 		            g.nextInc(e, b);
+		          }
 		          while (e != INVALID && (!b || g.v(e) != v)) {
 		            g.nextInc(e, b);
+		          }
+		        }
 		        return e;
+		      }
 		    };
 		    template <typename Graph>
 		    struct FindEdgeSelector<
 		      Graph,
 		      typename enable_if<typename Graph::FindEdgeTag, void>::type>
+		    {
 		      typedef typename Graph::Node Node;
 		      typedef typename Graph::Edge Edge;
 		      static Edge find(const Graph &g, Node u, Node v, Edge prev) {
 		        return g.findEdge(u, v, prev);
+		      }
 		    };
+		  }
 		  /// \brief Finds an edge between two nodes of a graph.
 		  ///
 		  /// Finds an edge from node \c u to node \c v in graph \c g.
 		  /// If the node \c u and node \c v is equal then each loop edge
 		  /// will be enumerated once.
 		  ///
 		  /// If \c prev is \ref INVALID (this is the default value), then
 		  /// it finds the first arc from \c u to \c v. Otherwise it looks for
 		  /// the next arc from \c u to \c v after \c prev.
 		  /// \return The found arc or \ref INVALID if there is no such an arc.
 		  ///
 		  /// Thus you can iterate through each arc from \c u to \c v as it follows.
 		  ///\code
 		  /// for(Edge e = findEdge(g,u,v); e != INVALID;
 		  ///     e = findEdge(g,u,v,e)) {
 		  ///   ...
 		  /// }
 		  ///\endcode
 		  ///
 		  ///\sa ConEdgeIt
 		  template <typename Graph>
 		  inline typename Graph::Edge
 		  findEdge(const Graph &g, typename Graph::Node u, typename Graph::Node v,
 		            typename Graph::Edge p = INVALID) {
 		    return _core_bits::FindEdgeSelector<Graph>::find(g, u, v, p);
+		  }
 		  /// \brief Iterator for iterating on edges connected the same nodes.
 		  ///
 		  /// Iterator for iterating on edges connected the same nodes. It is
 		  /// higher level interface for the findEdge() function. You can
 		  /// use it the following way:
 		  ///\code
 		  /// for (ConEdgeIt<Graph> it(g, src, trg); it != INVALID; ++it) {
 		  ///   ...
 		  /// }
 		  ///\endcode
 		  ///
 		  ///\sa findEdge()
 		  template <typename _Graph>
 		  class ConEdgeIt : public _Graph::Edge {
 		  public:
 		    typedef _Graph Graph;
 		    typedef typename Graph::Edge Parent;
 		    typedef typename Graph::Edge Edge;
 		    typedef typename Graph::Node Node;
 		    /// \brief Constructor.
 		    ///
 		    /// Construct a new ConEdgeIt iterating on the edges which
 		    /// connects the \c u and \c v node.
 		    ConEdgeIt(const Graph& g, Node u, Node v) : _graph(g) {
 		      Parent::operator=(findEdge(_graph, u, v));
+		    }
 		    /// \brief Constructor.
 		    ///
 		    /// Construct a new ConEdgeIt which continues the iterating from
 		    /// the \c e edge.
 		    ConEdgeIt(const Graph& g, Edge e) : Parent(e), _graph(g) {}
 		    /// \brief Increment operator.
 		    ///
 		    /// It increments the iterator and gives back the next edge.
 		    ConEdgeIt& operator++() {
 		      Parent::operator=(findEdge(_graph, _graph.u(*this),
 		                                 _graph.v(*this), *this));
 		      return *this;
+		    }
 		  private:
 		    const Graph& _graph;
 		  };
 		  ///Dynamic arc look up between given endpoints.
 		  ///Using this class, you can find an arc in a digraph from a given
 		  ///source to a given target in amortized time <em>O(log d)</em>,
 		  ///where <em>d</em> is the out-degree of the source node.
 		  ///
 		  ///It is possible to find \e all parallel arcs between two nodes with
 		  ///the \c findFirst() and \c findNext() members.
 		  ///
 		  ///See the \ref ArcLookUp and \ref AllArcLookUp classes if your
 		  ///digraph is not changed so frequently.
 		  ///
 		  ///This class uses a self-adjusting binary search tree, Sleator's
 		  ///and Tarjan's Splay tree for guarantee the logarithmic amortized
 		  ///time bound for arc lookups. This class also guarantees the
 		  ///optimal time bound in a constant factor for any distribution of
 		  ///queries.
 		  ///
 		  ///\tparam G The type of the underlying digraph.
 		  ///
 		  ///\sa ArcLookUp
 		  ///\sa AllArcLookUp
 		  template<class G>
 		  class DynArcLookUp
 		    : protected ItemSetTraits<G, typename G::Arc>::ItemNotifier::ObserverBase
+		  {
 		  public:
 		    typedef typename ItemSetTraits<G, typename G::Arc>
 		    ::ItemNotifier::ObserverBase Parent;
 		    TEMPLATE_DIGRAPH_TYPEDEFS(G);
 		    typedef G Digraph;
 		  protected:
 		    class AutoNodeMap : public ItemSetTraits<G, Node>::template Map<Arc>::Type {
 		    public:
 		      typedef typename ItemSetTraits<G, Node>::template Map<Arc>::Type Parent;
 		      AutoNodeMap(const G& digraph) : Parent(digraph, INVALID) {}
 		      virtual void add(const Node& node) {
 		        Parent::add(node);
 		        Parent::set(node, INVALID);
+		      }
 		      virtual void add(const std::vector<Node>& nodes) {
 		        Parent::add(nodes);
 		        for (int i = 0; i < int(nodes.size()); ++i) {
 		          Parent::set(nodes[i], INVALID);
+		        }
+		      }
 		      virtual void build() {
 		        Parent::build();
 		        Node it;
 		        typename Parent::Notifier* nf = Parent::notifier();
 		        for (nf->first(it); it != INVALID; nf->next(it)) {
 		          Parent::set(it, INVALID);
+		        }
+		      }
 		    };
 		    const Digraph &_g;
 		    AutoNodeMap _head;
 		    typename Digraph::template ArcMap<Arc> _parent;
 		    typename Digraph::template ArcMap<Arc> _left;
 		    typename Digraph::template ArcMap<Arc> _right;
 		    class ArcLess {
 		      const Digraph &g;
 		    public:
 		      ArcLess(const Digraph &_g) : g(_g) {}
 		      bool operator()(Arc a,Arc b) const
+		      {
 		        return g.target(a)<g.target(b);
+		      }
 		    };
 		  public:
 		    ///Constructor
 		    ///Constructor.
 		    ///
 		    ///It builds up the search database.
 		    DynArcLookUp(const Digraph &g)
 		      : _g(g),_head(g),_parent(g),_left(g),_right(g)
+		    {
 		      Parent::attach(_g.notifier(typename Digraph::Arc()));
 		      refresh();
+		    }
 		  protected:
 		    virtual void add(const Arc& arc) {
 		      insert(arc);
+		    }
 		    virtual void add(const std::vector<Arc>& arcs) {
 		      for (int i = 0; i < int(arcs.size()); ++i) {
 		        insert(arcs[i]);
+		      }
+		    }
 		    virtual void erase(const Arc& arc) {
 		      remove(arc);
+		    }
 		    virtual void erase(const std::vector<Arc>& arcs) {
 		      for (int i = 0; i < int(arcs.size()); ++i) {
 		        remove(arcs[i]);
+		      }
+		    }
 		    virtual void build() {
 		      refresh();
+		    }
 		    virtual void clear() {
 		      for(NodeIt n(_g);n!=INVALID;++n) {
 		        _head.set(n, INVALID);
+		      }
+		    }
 		    void insert(Arc arc) {
 		      Node s = _g.source(arc);
 		      Node t = _g.target(arc);
 		      _left.set(arc, INVALID);
 		      _right.set(arc, INVALID);
 		      Arc e = _head[s];
 		      if (e == INVALID) {
 		        _head.set(s, arc);
 		        _parent.set(arc, INVALID);
 		        return;
+		      }
 		      while (true) {
 		        if (t < _g.target(e)) {
 		          if (_left[e] == INVALID) {
 		            _left.set(e, arc);
 		            _parent.set(arc, e);
 		            splay(arc);
 		            return;
 		          } else {
 		            e = _left[e];
+		          }
 		        } else {
 		          if (_right[e] == INVALID) {
 		            _right.set(e, arc);
 		            _parent.set(arc, e);
 		            splay(arc);
 		            return;
 		          } else {
 		            e = _right[e];
+		          }
+		        }
+		      }
+		    }
 		    void remove(Arc arc) {
 		      if (_left[arc] == INVALID) {
 		        if (_right[arc] != INVALID) {
 		          _parent.set(_right[arc], _parent[arc]);
+		        }
 		        if (_parent[arc] != INVALID) {
 		          if (_left[_parent[arc]] == arc) {
 		            _left.set(_parent[arc], _right[arc]);
 		          } else {
 		            _right.set(_parent[arc], _right[arc]);
+		          }
 		        } else {
 		          _head.set(_g.source(arc), _right[arc]);
+		        }
 		      } else if (_right[arc] == INVALID) {
 		        _parent.set(_left[arc], _parent[arc]);
 		        if (_parent[arc] != INVALID) {
 		          if (_left[_parent[arc]] == arc) {
 		            _left.set(_parent[arc], _left[arc]);
 		          } else {
 		            _right.set(_parent[arc], _left[arc]);
+		          }
 		        } else {
 		          _head.set(_g.source(arc), _left[arc]);
+		        }
 		      } else {
 		        Arc e = _left[arc];
 		        if (_right[e] != INVALID) {
 		          e = _right[e];
 		          while (_right[e] != INVALID) {
 		            e = _right[e];
+		          }
 		          Arc s = _parent[e];
 		          _right.set(_parent[e], _left[e]);
 		          if (_left[e] != INVALID) {
 		            _parent.set(_left[e], _parent[e]);
+		          }
 		          _left.set(e, _left[arc]);
 		          _parent.set(_left[arc], e);
 		          _right.set(e, _right[arc]);
 		          _parent.set(_right[arc], e);
 		          _parent.set(e, _parent[arc]);
 		          if (_parent[arc] != INVALID) {
 		            if (_left[_parent[arc]] == arc) {
 		              _left.set(_parent[arc], e);
 		            } else {
 		              _right.set(_parent[arc], e);
+		            }
+		          }
 		          splay(s);
 		        } else {
 		          _right.set(e, _right[arc]);
 		          _parent.set(_right[arc], e);
 		          if (_parent[arc] != INVALID) {
 		            if (_left[_parent[arc]] == arc) {
 		              _left.set(_parent[arc], e);
 		            } else {
 		              _right.set(_parent[arc], e);
+		            }
 		          } else {
 		            _head.set(_g.source(arc), e);
+		          }
+		        }
+		      }
+		    }
 		    Arc refreshRec(std::vector<Arc> &v,int a,int b)
+		    {
 		      int m=(a+b)/2;
 		      Arc me=v[m];
 		      if (a < m) {
 		        Arc left = refreshRec(v,a,m-1);
 		        _left.set(me, left);
 		        _parent.set(left, me);
 		      } else {
 		        _left.set(me, INVALID);
+		      }
 		      if (m < b) {
 		        Arc right = refreshRec(v,m+1,b);
 		        _right.set(me, right);
 		        _parent.set(right, me);
 		      } else {
 		        _right.set(me, INVALID);
+		      }
 		      return me;
+		    }
 		    void refresh() {
 		      for(NodeIt n(_g);n!=INVALID;++n) {
 		        std::vector<Arc> v;
 		        for(OutArcIt e(_g,n);e!=INVALID;++e) v.push_back(e);
 		        if(v.size()) {
 		          std::sort(v.begin(),v.end(),ArcLess(_g));
 		          Arc head = refreshRec(v,0,v.size()-1);
 		          _head.set(n, head);
 		          _parent.set(head, INVALID);
+		        }
 		        else _head.set(n, INVALID);
+		      }
+		    }
 		    void zig(Arc v) {
 		      Arc w = _parent[v];
 		      _parent.set(v, _parent[w]);
 		      _parent.set(w, v);
 		      _left.set(w, _right[v]);
 		      _right.set(v, w);
 		      if (_parent[v] != INVALID) {
 		        if (_right[_parent[v]] == w) {
 		          _right.set(_parent[v], v);
 		        } else {
 		          _left.set(_parent[v], v);
+		        }
+		      }
 		      if (_left[w] != INVALID){
 		        _parent.set(_left[w], w);
+		      }
+		    }
 		    void zag(Arc v) {
 		      Arc w = _parent[v];
 		      _parent.set(v, _parent[w]);
 		      _parent.set(w, v);
 		      _right.set(w, _left[v]);
 		      _left.set(v, w);
 		      if (_parent[v] != INVALID){
 		        if (_left[_parent[v]] == w) {
 		          _left.set(_parent[v], v);
 		        } else {
 		          _right.set(_parent[v], v);
+		        }
+		      }
 		      if (_right[w] != INVALID){
 		        _parent.set(_right[w], w);
+		      }
+		    }
 		    void splay(Arc v) {
 		      while (_parent[v] != INVALID) {
 		        if (v == _left[_parent[v]]) {
 		          if (_parent[_parent[v]] == INVALID) {
 		            zig(v);
 		          } else {
 		            if (_parent[v] == _left[_parent[_parent[v]]]) {
 		              zig(_parent[v]);
 		              zig(v);
 		            } else {
 		              zig(v);
 		              zag(v);
+		            }
+		          }
 		        } else {
 		          if (_parent[_parent[v]] == INVALID) {
 		            zag(v);
 		          } else {
 		            if (_parent[v] == _left[_parent[_parent[v]]]) {
 		              zag(v);
 		              zig(v);
 		            } else {
 		              zag(_parent[v]);
 		              zag(v);
+		            }
+		          }
+		        }
+		      }
 		      _head[_g.source(v)] = v;
+		    }
 		  public:
 		    ///Find an arc between two nodes.
 		    ///Find an arc between two nodes in time <em>O(</em>log<em>d)</em>, where
 		    /// <em>d</em> is the number of outgoing arcs of \c s.
 		    ///\param s The source node
 		    ///\param t The target node
 		    ///\return An arc from \c s to \c t if there exists,
 		    ///\ref INVALID otherwise.
 		    Arc operator()(Node s, Node t) const
+		    {
 		      Arc a = _head[s];
 		      while (true) {
 		        if (_g.target(a) == t) {
 		          const_cast<DynArcLookUp&>(*this).splay(a);
 		          return a;
 		        } else if (t < _g.target(a)) {
 		          if (_left[a] == INVALID) {
 		            const_cast<DynArcLookUp&>(*this).splay(a);
 		            return INVALID;
 		          } else {
 		            a = _left[a];
+		          }
 		        } else  {
 		          if (_right[a] == INVALID) {
 		            const_cast<DynArcLookUp&>(*this).splay(a);
 		            return INVALID;
 		          } else {
 		            a = _right[a];
+		          }
+		        }
+		      }
+		    }
 		    ///Find the first arc between two nodes.
 		    ///Find the first arc between two nodes in time
 		    /// <em>O(</em>log<em>d)</em>, where <em>d</em> is the number of
 		    /// outgoing arcs of \c s.
 		    ///\param s The source node
 		    ///\param t The target node
 		    ///\return An arc from \c s to \c t if there exists, \ref INVALID
 		    /// otherwise.
 		    Arc findFirst(Node s, Node t) const
+		    {
 		      Arc a = _head[s];
 		      Arc r = INVALID;
 		      while (true) {
 		        if (_g.target(a) < t) {
 		          if (_right[a] == INVALID) {
 		            const_cast<DynArcLookUp&>(*this).splay(a);
 		            return r;
 		          } else {
 		            a = _right[a];
+		          }
 		        } else {
 		          if (_g.target(a) == t) {
 		            r = a;
+		          }
 		          if (_left[a] == INVALID) {
 		            const_cast<DynArcLookUp&>(*this).splay(a);
 		            return r;
 		          } else {
 		            a = _left[a];
+		          }
+		        }
+		      }
+		    }
 		    ///Find the next arc between two nodes.
 		    ///Find the next arc between two nodes in time
 		    /// <em>O(</em>log<em>d)</em>, where <em>d</em> is the number of
 		    /// outgoing arcs of \c s.
 		    ///\param s The source node
 		    ///\param t The target node
 		    ///\return An arc from \c s to \c t if there exists, \ref INVALID
 		    /// otherwise.
 		    ///\note If \c e is not the result of the previous \c findFirst()
 		    ///operation then the amorized time bound can not be guaranteed.
 		#ifdef DOXYGEN
 		    Arc findNext(Node s, Node t, Arc a) const
 		#else
 		    Arc findNext(Node, Node t, Arc a) const
 		#endif
+		    {
 		      if (_right[a] != INVALID) {
 		        a = _right[a];
 		        while (_left[a] != INVALID) {
 		          a = _left[a];
+		        }
 		        const_cast<DynArcLookUp&>(*this).splay(a);
 		      } else {
 		        while (_parent[a] != INVALID && _right[_parent[a]] ==  a) {
 		          a = _parent[a];
+		        }
 		        if (_parent[a] == INVALID) {
 		          return INVALID;
 		        } else {
 		          a = _parent[a];
 		          const_cast<DynArcLookUp&>(*this).splay(a);
+		        }
+		      }
 		      if (_g.target(a) == t) return a;
 		      else return INVALID;
+		    }
 		  };
 		  ///Fast arc look up between given endpoints.
 		  ///Using this class, you can find an arc in a digraph from a given
 		  ///source to a given target in time <em>O(log d)</em>,
 		  ///where <em>d</em> is the out-degree of the source node.
 		  ///
 		  ///It is not possible to find \e all parallel arcs between two nodes.
 		  ///Use \ref AllArcLookUp for this purpose.
 		  ///
 		  ///\warning This class is static, so you should refresh() (or at least
 		  ///refresh(Node)) this data structure
 		  ///whenever the digraph changes. This is a time consuming (superlinearly
 		  ///proportional (<em>O(m</em>log<em>m)</em>) to the number of arcs).
 		  ///
 		  ///\tparam G The type of the underlying digraph.
 		  ///
 		  ///\sa DynArcLookUp
 		  ///\sa AllArcLookUp
 		  template<class G>
 		  class ArcLookUp
+		  {
 		  public:
 		    TEMPLATE_DIGRAPH_TYPEDEFS(G);
 		    typedef G Digraph;
 		  protected:
 		    const Digraph &_g;
 		    typename Digraph::template NodeMap<Arc> _head;
 		    typename Digraph::template ArcMap<Arc> _left;
 		    typename Digraph::template ArcMap<Arc> _right;
 		    class ArcLess {
 		      const Digraph &g;
 		    public:
 		      ArcLess(const Digraph &_g) : g(_g) {}
 		      bool operator()(Arc a,Arc b) const
+		      {
 		        return g.target(a)<g.target(b);
+		      }
 		    };
 		  public:
 		    ///Constructor
 		    ///Constructor.
 		    ///
 		    ///It builds up the search database, which remains valid until the digraph
 		    ///changes.
 		    ArcLookUp(const Digraph &g) :_g(g),_head(g),_left(g),_right(g) {refresh();}
 		  private:
 		    Arc refreshRec(std::vector<Arc> &v,int a,int b)
+		    {
 		      int m=(a+b)/2;
 		      Arc me=v[m];
 		      _left[me] = a<m?refreshRec(v,a,m-1):INVALID;
 		      _right[me] = m<b?refreshRec(v,m+1,b):INVALID;
 		      return me;
+		    }
 		  public:
 		    ///Refresh the data structure at a node.
 		    ///Build up the search database of node \c n.
 		    ///
 		    ///It runs in time <em>O(d</em>log<em>d)</em>, where <em>d</em> is
 		    ///the number of the outgoing arcs of \c n.
 		    void refresh(Node n)
+		    {
 		      std::vector<Arc> v;
 		      for(OutArcIt e(_g,n);e!=INVALID;++e) v.push_back(e);
 		      if(v.size()) {
 		        std::sort(v.begin(),v.end(),ArcLess(_g));
 		        _head[n]=refreshRec(v,0,v.size()-1);
+		      }
 		      else _head[n]=INVALID;
+		    }
 		    ///Refresh the full data structure.
 		    ///Build up the full search database. In fact, it simply calls
 		    ///\ref refresh(Node) "refresh(n)" for each node \c n.
 		    ///
 		    ///It runs in time <em>O(m</em>log<em>D)</em>, where <em>m</em> is
 		    ///the number of the arcs of \c n and <em>D</em> is the maximum
 		    ///out-degree of the digraph.
 		    void refresh()
+		    {
 		      for(NodeIt n(_g);n!=INVALID;++n) refresh(n);
+		    }
 		    ///Find an arc between two nodes.
 		    ///Find an arc between two nodes in time <em>O(</em>log<em>d)</em>, where
 		    /// <em>d</em> is the number of outgoing arcs of \c s.
 		    ///\param s The source node
 		    ///\param t The target node
 		    ///\return An arc from \c s to \c t if there exists,
 		    ///\ref INVALID otherwise.
 		    ///
 		    ///\warning If you change the digraph, refresh() must be called before using
 		    ///this operator. If you change the outgoing arcs of
 		    ///a single node \c n, then
 		    ///\ref refresh(Node) "refresh(n)" is enough.
 		    ///
 		    Arc operator()(Node s, Node t) const
+		    {
 		      Arc e;
 		      for(e=_head[s];
 		          e!=INVALID&&_g.target(e)!=t;
 		          e = t < _g.target(e)?_left[e]:_right[e]) ;
 		      return e;
+		    }
 		  };
 		  ///Fast look up of all arcs between given endpoints.
 		  ///This class is the same as \ref ArcLookUp, with the addition
 		  ///that it makes it possible to find all arcs between given endpoints.
 		  ///
 		  ///\warning This class is static, so you should refresh() (or at least
 		  ///refresh(Node)) this data structure
 		  ///whenever the digraph changes. This is a time consuming (superlinearly
 		  ///proportional (<em>O(m</em>log<em>m)</em>) to the number of arcs).
 		  ///
 		  ///\tparam G The type of the underlying digraph.
 		  ///
 		  ///\sa DynArcLookUp
 		  ///\sa ArcLookUp
 		  template<class G>
 		  class AllArcLookUp : public ArcLookUp<G>
+		  {
 		    using ArcLookUp<G>::_g;
 		    using ArcLookUp<G>::_right;
 		    using ArcLookUp<G>::_left;
 		    using ArcLookUp<G>::_head;
 		    TEMPLATE_DIGRAPH_TYPEDEFS(G);
 		    typedef G Digraph;
 		    typename Digraph::template ArcMap<Arc> _next;
 		    Arc refreshNext(Arc head,Arc next=INVALID)
+		    {
 		      if(head==INVALID) return next;
 		      else {
 		        next=refreshNext(_right[head],next);
 		//         _next[head]=next;
 		        _next[head]=( next!=INVALID && _g.target(next)==_g.target(head))
 		          ? next : INVALID;
 		        return refreshNext(_left[head],head);
+		      }
+		    }
 		    void refreshNext()
+		    {
 		      for(NodeIt n(_g);n!=INVALID;++n) refreshNext(_head[n]);
+		    }
 		  public:
 		    ///Constructor
 		    ///Constructor.
 		    ///
 		    ///It builds up the search database, which remains valid until the digraph
 		    ///changes.
 		    AllArcLookUp(const Digraph &g) : ArcLookUp<G>(g), _next(g) {refreshNext();}
 		    ///Refresh the data structure at a node.
 		    ///Build up the search database of node \c n.
 		    ///
 		    ///It runs in time <em>O(d</em>log<em>d)</em>, where <em>d</em> is
 		    ///the number of the outgoing arcs of \c n.
 		    void refresh(Node n)
+		    {
 		      ArcLookUp<G>::refresh(n);
 		      refreshNext(_head[n]);
+		    }
 		    ///Refresh the full data structure.
 		    ///Build up the full search database. In fact, it simply calls
 		    ///\ref refresh(Node) "refresh(n)" for each node \c n.
 		    ///
 		    ///It runs in time <em>O(m</em>log<em>D)</em>, where <em>m</em> is
 		    ///the number of the arcs of \c n and <em>D</em> is the maximum
 		    ///out-degree of the digraph.
 		    void refresh()
+		    {
 		      for(NodeIt n(_g);n!=INVALID;++n) refresh(_head[n]);
+		    }
 		    ///Find an arc between two nodes.
 		    ///Find an arc between two nodes.
 		    ///\param s The source node
 		    ///\param t The target node
 		    ///\param prev The previous arc between \c s and \c t. It it is INVALID or
 		    ///not given, the operator finds the first appropriate arc.
 		    ///\return An arc from \c s to \c t after \c prev or
 		    ///\ref INVALID if there is no more.
 		    ///
 		    ///For example, you can count the number of arcs from \c u to \c v in the
 		    ///following way.
 		    ///\code
 		    ///AllArcLookUp<ListDigraph> ae(g);
 		    ///...
 		    ///int n=0;
 		    ///for(Arc e=ae(u,v);e!=INVALID;e=ae(u,v,e)) n++;
 		    ///\endcode
 		    ///
 		    ///Finding the first arc take <em>O(</em>log<em>d)</em> time, where
 		    /// <em>d</em> is the number of outgoing arcs of \c s. Then, the
 		    ///consecutive arcs are found in constant time.
 		    ///
 		    ///\warning If you change the digraph, refresh() must be called before using
 		    ///this operator. If you change the outgoing arcs of
 		    ///a single node \c n, then
 		    ///\ref refresh(Node) "refresh(n)" is enough.
 		    ///
 		#ifdef DOXYGEN
 		    Arc operator()(Node s, Node t, Arc prev=INVALID) const {}
 		#else
 		    using ArcLookUp<G>::operator() ;
 		    Arc operator()(Node s, Node t, Arc prev) const
+		    {
 		      return prev==INVALID?(*this)(s,t):_next[prev];
+		    }
 		#endif
 		  };
 		  /// @}
 		} //namespace lemon
 		#endif

demo/graph_to_eps_demo.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		/// \ingroup demos
 		/// \file
 		/// \brief Demo of the graph drawing function \ref graphToEps()
 		///
 		/// This demo program shows examples how to use the function \ref
 		/// graphToEps(). It takes no input but simply creates seven
 		/// <tt>.eps</tt> files demonstrating the capability of \ref
 		/// graphToEps(), and showing how to draw directed graphs,
 		/// how to handle parallel egdes, how to change the properties (like
 		/// color, shape, size, title etc.) of nodes and arcs individually
 		/// using appropriate \ref maps-page "graph maps".
 		///
 		/// \include graph_to_eps_demo.cc
 		#include<lemon/list_graph.h>
 		#include<lemon/graph_utils.h>
 		#include<lemon/graph_to_eps.h>
 		#include<lemon/math.h>
 		using namespace std;
 		using namespace lemon;
 		int main()
+		{
 		  Palette palette;
 		  Palette paletteW(true);
 		  // Create a small digraph
 		  ListDigraph g;
 		  typedef ListDigraph::Node Node;
 		  typedef ListDigraph::NodeIt NodeIt;
 		  typedef ListDigraph::Arc Arc;
 		  typedef dim2::Point<int> Point;
 		  Node n1=g.addNode();
 		  Node n2=g.addNode();
 		  Node n3=g.addNode();
 		  Node n4=g.addNode();
 		  Node n5=g.addNode();
 		  ListDigraph::NodeMap<Point> coords(g);
 		  ListDigraph::NodeMap<double> sizes(g);
 		  ListDigraph::NodeMap<int> colors(g);
 		  ListDigraph::NodeMap<int> shapes(g);
 		  ListDigraph::ArcMap<int> acolors(g);
 		  ListDigraph::ArcMap<int> widths(g);
 		  coords[n1]=Point(50,50);  sizes[n1]=1; colors[n1]=1; shapes[n1]=0;
 		  coords[n2]=Point(50,70);  sizes[n2]=2; colors[n2]=2; shapes[n2]=2;
 		  coords[n3]=Point(70,70);  sizes[n3]=1; colors[n3]=3; shapes[n3]=0;
 		  coords[n4]=Point(70,50);  sizes[n4]=2; colors[n4]=4; shapes[n4]=1;
 		  coords[n5]=Point(85,60);  sizes[n5]=3; colors[n5]=5; shapes[n5]=2;
 		  Arc a;
 		  a=g.addArc(n1,n2); acolors[a]=0; widths[a]=1;
 		  a=g.addArc(n2,n3); acolors[a]=0; widths[a]=1;
 		  a=g.addArc(n3,n5); acolors[a]=0; widths[a]=3;
 		  a=g.addArc(n5,n4); acolors[a]=0; widths[a]=1;
 		  a=g.addArc(n4,n1); acolors[a]=0; widths[a]=1;
 		  a=g.addArc(n2,n4); acolors[a]=1; widths[a]=2;
 		  a=g.addArc(n3,n4); acolors[a]=2; widths[a]=1;
 		  IdMap<ListDigraph,Node> id(g);
 		  // Create .eps files showing the digraph with different options
 		  cout << "Create 'graph_to_eps_demo_out_1_pure.eps'" << endl;
 		  graphToEps(g,"graph_to_eps_demo_out_1_pure.eps").
 		    coords(coords).
 		    title("Sample .eps figure").
 		    copyright("(C) 2003-2008 LEMON Project").
 		    run();
 		  cout << "Create 'graph_to_eps_demo_out_2.eps'" << endl;
 		  graphToEps(g,"graph_to_eps_demo_out_2.eps").
 		    coords(coords).
 		    title("Sample .eps figure").
 		    copyright("(C) 2003-2008 LEMON Project").
 		    absoluteNodeSizes().absoluteArcWidths().
 		    nodeScale(2).nodeSizes(sizes).
 		    nodeShapes(shapes).
 		    nodeColors(composeMap(palette,colors)).
 		    arcColors(composeMap(palette,acolors)).
 		    arcWidthScale(.4).arcWidths(widths).
 		    nodeTexts(id).nodeTextSize(3).
 		    run();
 		  cout << "Create 'graph_to_eps_demo_out_3_arr.eps'" << endl;
 		  graphToEps(g,"graph_to_eps_demo_out_3_arr.eps").
 		    title("Sample .eps figure (with arrowheads)").
 		    copyright("(C) 2003-2008 LEMON Project").
 		    absoluteNodeSizes().absoluteArcWidths().
 		    nodeColors(composeMap(palette,colors)).
 		    coords(coords).
 		    nodeScale(2).nodeSizes(sizes).
 		    nodeShapes(shapes).
 		    arcColors(composeMap(palette,acolors)).
 		    arcWidthScale(.4).arcWidths(widths).
 		    nodeTexts(id).nodeTextSize(3).
 		    drawArrows().arrowWidth(2).arrowLength(2).
 		    run();
 		  // Add more arcs to the digraph
 		  a=g.addArc(n1,n4); acolors[a]=2; widths[a]=1;
 		  a=g.addArc(n4,n1); acolors[a]=1; widths[a]=2;
 		  a=g.addArc(n1,n2); acolors[a]=1; widths[a]=1;
 		  a=g.addArc(n1,n2); acolors[a]=2; widths[a]=1;
 		  a=g.addArc(n1,n2); acolors[a]=3; widths[a]=1;
 		  a=g.addArc(n1,n2); acolors[a]=4; widths[a]=1;
 		  a=g.addArc(n1,n2); acolors[a]=5; widths[a]=1;
 		  a=g.addArc(n1,n2); acolors[a]=6; widths[a]=1;
 		  a=g.addArc(n1,n2); acolors[a]=7; widths[a]=1;
 		  cout << "Create 'graph_to_eps_demo_out_4_par.eps'" << endl;
 		  graphToEps(g,"graph_to_eps_demo_out_4_par.eps").
 		    title("Sample .eps figure (parallel arcs)").
 		    copyright("(C) 2003-2008 LEMON Project").
 		    absoluteNodeSizes().absoluteArcWidths().
 		    nodeShapes(shapes).
 		    coords(coords).
 		    nodeScale(2).nodeSizes(sizes).
 		    nodeColors(composeMap(palette,colors)).
 		    arcColors(composeMap(palette,acolors)).
 		    arcWidthScale(.4).arcWidths(widths).
 		    nodeTexts(id).nodeTextSize(3).
 		    enableParallel().parArcDist(1.5).
 		    run();
 		  cout << "Create 'graph_to_eps_demo_out_5_par_arr.eps'" << endl;
 		  graphToEps(g,"graph_to_eps_demo_out_5_par_arr.eps").
 		    title("Sample .eps figure (parallel arcs and arrowheads)").
 		    copyright("(C) 2003-2008 LEMON Project").
 		    absoluteNodeSizes().absoluteArcWidths().
 		    nodeScale(2).nodeSizes(sizes).
 		    coords(coords).
 		    nodeShapes(shapes).
 		    nodeColors(composeMap(palette,colors)).
 		    arcColors(composeMap(palette,acolors)).
 		    arcWidthScale(.3).arcWidths(widths).
 		    nodeTexts(id).nodeTextSize(3).
 		    enableParallel().parArcDist(1).
 		    drawArrows().arrowWidth(1).arrowLength(1).
 		    run();
 		  cout << "Create 'graph_to_eps_demo_out_6_par_arr_a4.eps'" << endl;
 		  graphToEps(g,"graph_to_eps_demo_out_6_par_arr_a4.eps").
 		    title("Sample .eps figure (fits to A4)").
 		    copyright("(C) 2003-2008 LEMON Project").
 		    scaleToA4().
 		    absoluteNodeSizes().absoluteArcWidths().
 		    nodeScale(2).nodeSizes(sizes).
 		    coords(coords).
 		    nodeShapes(shapes).
 		    nodeColors(composeMap(palette,colors)).
 		    arcColors(composeMap(palette,acolors)).
 		    arcWidthScale(.3).arcWidths(widths).
 		    nodeTexts(id).nodeTextSize(3).
 		    enableParallel().parArcDist(1).
 		    drawArrows().arrowWidth(1).arrowLength(1).
 		    run();
 		  // Create an .eps file showing the colors of a default Palette
 		  ListDigraph h;
 		  ListDigraph::NodeMap<int> hcolors(h);
 		  ListDigraph::NodeMap<Point> hcoords(h);
 		  int cols=int(sqrt(double(palette.size())));
 		  for(int i=0;i<int(paletteW.size());i++) {
 		    Node n=h.addNode();
 		    hcoords[n]=Point(1+i%cols,1+i/cols);
 		    hcolors[n]=i;
+		  }
 		  cout << "Create 'graph_to_eps_demo_out_7_colors.eps'" << endl;
 		  graphToEps(h,"graph_to_eps_demo_out_7_colors.eps").
 		    scale(60).
 		    title("Sample .eps figure (Palette demo)").
 		    copyright("(C) 2003-2008 LEMON Project").
 		    coords(hcoords).
 		    absoluteNodeSizes().absoluteArcWidths().
 		    nodeScale(.45).
 		    distantColorNodeTexts().
 		    nodeTexts(hcolors).nodeTextSize(.6).
 		    nodeColors(composeMap(paletteW,hcolors)).
 		    run();
 		  return 0;
+		}

lemon/Makefile.am

Show inline comments

 		EXTRA_DIST += \
 			lemon/lemon.pc.in \
 			lemon/CMakeLists.txt
 		pkgconfig_DATA += lemon/lemon.pc
 		lib_LTLIBRARIES += lemon/libemon.la
 		lemon_libemon_la_SOURCES = \
 		        lemon/arg_parser.cc \
 		        lemon/base.cc \
 		        lemon/color.cc \
 		        lemon/random.cc
 		lemon_libemon_la_CXXFLAGS = $(GLPK_CFLAGS) $(CPLEX_CFLAGS) $(SOPLEX_CXXFLAGS)
 		lemon_libemon_la_LDFLAGS = $(GLPK_LIBS) $(CPLEX_LIBS) $(SOPLEX_LIBS)
 		lemon_HEADERS += \
 		        lemon/arg_parser.h \
 			lemon/assert.h \
 		        lemon/bfs.h \
 		        lemon/bin_heap.h \
 		        lemon/color.h \
 			lemon/concept_check.h \
 		        lemon/counter.h \
 			lemon/core.h \
 		        lemon/dfs.h \
 		        lemon/dijkstra.h \
 		        lemon/dim2.h \
 			lemon/error.h \
 		        lemon/graph_to_eps.h \
 			lemon/graph_utils.h \
 			lemon/kruskal.h \
 			lemon/lgf_reader.h \
 			lemon/lgf_writer.h \
 			lemon/list_graph.h \
 			lemon/maps.h \
 			lemon/math.h \
 			lemon/path.h \
 		        lemon/random.h \
 			lemon/smart_graph.h \
 		        lemon/time_measure.h \
 		        lemon/tolerance.h \
 			lemon/unionfind.h
 		bits_HEADERS += \
 			lemon/bits/alteration_notifier.h \
 			lemon/bits/array_map.h \
 			lemon/bits/base_extender.h \
 		        lemon/bits/bezier.h \
 			lemon/bits/default_map.h \
 		        lemon/bits/enable_if.h \
 			lemon/bits/graph_extender.h \
 		        lemon/bits/invalid.h \
 			lemon/bits/map_extender.h \
 			lemon/bits/path_dump.h \
 			lemon/bits/traits.h \
 		        lemon/bits/utility.h \
 			lemon/bits/vector_map.h
 		concept_HEADERS += \
 			lemon/concepts/digraph.h \
 			lemon/concepts/graph.h \
 			lemon/concepts/graph_components.h \
 			lemon/concepts/heap.h \
 			lemon/concepts/maps.h \
 			lemon/concepts/path.h

lemon/base.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		///\file
 		///\brief Some basic non-inline functions and static global data.
 		#include<lemon/tolerance.h>
-		#include<lemon/bits/invalid.h>
+		#include<lemon/core.h>
 		namespace lemon {
 		  float Tolerance<float>::def_epsilon = 1e-4;
 		  double Tolerance<double>::def_epsilon = 1e-10;
 		  long double Tolerance<long double>::def_epsilon = 1e-14;
 		#ifndef LEMON_ONLY_TEMPLATES
 		  const Invalid INVALID = Invalid();
 		#endif
 		} //namespace lemon

lemon/bfs.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_BFS_H
 		#define LEMON_BFS_H
 		///\ingroup search
 		///\file
 		///\brief Bfs algorithm.
 		#include <lemon/list_graph.h>
 		#include <lemon/graph_utils.h>
 		#include <lemon/bits/path_dump.h>
-		#include <lemon/bits/invalid.h>
+		#include <lemon/core.h>
 		#include <lemon/error.h>
 		#include <lemon/maps.h>
 		namespace lemon {
 		  ///Default traits class of Bfs class.
 		  ///Default traits class of Bfs class.
 		  ///\tparam GR Digraph type.
 		  template<class GR>
 		  struct BfsDefaultTraits
+		  {
 		    ///The digraph type the algorithm runs on.
 		    typedef GR Digraph;
 		    ///\brief The type of the map that stores the last
 		    ///arcs of the shortest paths.
 		    ///
 		    ///The type of the map that stores the last
 		    ///arcs of the shortest paths.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    ///
 		    typedef typename Digraph::template NodeMap<typename GR::Arc> PredMap;
 		    ///Instantiates a PredMap.
 		    ///This function instantiates a \ref PredMap.
 		    ///\param G is the digraph, to which we would like to define the PredMap.
 		    ///\todo The digraph alone may be insufficient to initialize
 		    static PredMap *createPredMap(const GR &G)
+		    {
 		      return new PredMap(G);
+		    }
 		    ///The type of the map that indicates which nodes are processed.
 		    ///The type of the map that indicates which nodes are processed.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    ///\todo named parameter to set this type, function to read and write.
 		    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
 		    ///Instantiates a ProcessedMap.
 		    ///This function instantiates a \ref ProcessedMap.
 		    ///\param g is the digraph, to which
 		    ///we would like to define the \ref ProcessedMap
 		#ifdef DOXYGEN
 		    static ProcessedMap *createProcessedMap(const GR &g)
 		#else
 		    static ProcessedMap *createProcessedMap(const GR &)
 		#endif
+		    {
 		      return new ProcessedMap();
+		    }
 		    ///The type of the map that indicates which nodes are reached.
 		    ///The type of the map that indicates which nodes are reached.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    ///\todo named parameter to set this type, function to read and write.
 		    typedef typename Digraph::template NodeMap<bool> ReachedMap;
 		    ///Instantiates a ReachedMap.
 		    ///This function instantiates a \ref ReachedMap.
 		    ///\param G is the digraph, to which
 		    ///we would like to define the \ref ReachedMap.
 		    static ReachedMap *createReachedMap(const GR &G)
+		    {
 		      return new ReachedMap(G);
+		    }
 		    ///The type of the map that stores the dists of the nodes.
 		    ///The type of the map that stores the dists of the nodes.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    ///
 		    typedef typename Digraph::template NodeMap<int> DistMap;
 		    ///Instantiates a DistMap.
 		    ///This function instantiates a \ref DistMap.
 		    ///\param G is the digraph, to which we would like to define
 		    ///the \ref DistMap
 		    static DistMap *createDistMap(const GR &G)
+		    {
 		      return new DistMap(G);
+		    }
 		  };
 		  ///%BFS algorithm class.
 		  ///\ingroup search
 		  ///This class provides an efficient implementation of the %BFS algorithm.
 		  ///
 		  ///\tparam GR The digraph type the algorithm runs on. The default value is
 		  ///\ref ListDigraph. The value of GR is not used directly by Bfs, it
 		  ///is only passed to \ref BfsDefaultTraits.
 		  ///\tparam TR Traits class to set various data types used by the algorithm.
 		  ///The default traits class is
 		  ///\ref BfsDefaultTraits "BfsDefaultTraits<GR>".
 		  ///See \ref BfsDefaultTraits for the documentation of
 		  ///a Bfs traits class.
 		#ifdef DOXYGEN
 		  template <typename GR,
 		            typename TR>
 		#else
 		  template <typename GR=ListDigraph,
 		            typename TR=BfsDefaultTraits<GR> >
 		#endif
 		  class Bfs {
 		  public:
 		    /**
 		     * \brief \ref Exception for uninitialized parameters.
+		     *
 		     * This error represents problems in the initialization
 		     * of the parameters of the algorithms.
 		     */
 		    class UninitializedParameter : public lemon::UninitializedParameter {
 		    public:
 		      virtual const char* what() const throw() {
 		        return "lemon::Bfs::UninitializedParameter";
+		      }
 		    };
 		    typedef TR Traits;
 		    ///The type of the underlying digraph.
 		    typedef typename TR::Digraph Digraph;
 		    ///\brief The type of the map that stores the last
 		    ///arcs of the shortest paths.
 		    typedef typename TR::PredMap PredMap;
 		    ///The type of the map indicating which nodes are reached.
 		    typedef typename TR::ReachedMap ReachedMap;
 		    ///The type of the map indicating which nodes are processed.
 		    typedef typename TR::ProcessedMap ProcessedMap;
 		    ///The type of the map that stores the dists of the nodes.
 		    typedef typename TR::DistMap DistMap;
 		  private:
 		    typedef typename Digraph::Node Node;
 		    typedef typename Digraph::NodeIt NodeIt;
 		    typedef typename Digraph::Arc Arc;
 		    typedef typename Digraph::OutArcIt OutArcIt;
 		    /// Pointer to the underlying digraph.
 		    const Digraph *G;
 		    ///Pointer to the map of predecessors arcs.
 		    PredMap *_pred;
 		    ///Indicates if \ref _pred is locally allocated (\c true) or not.
 		    bool local_pred;
 		    ///Pointer to the map of distances.
 		    DistMap *_dist;
 		    ///Indicates if \ref _dist is locally allocated (\c true) or not.
 		    bool local_dist;
 		    ///Pointer to the map of reached status of the nodes.
 		    ReachedMap *_reached;
 		    ///Indicates if \ref _reached is locally allocated (\c true) or not.
 		    bool local_reached;
 		    ///Pointer to the map of processed status of the nodes.
 		    ProcessedMap *_processed;
 		    ///Indicates if \ref _processed is locally allocated (\c true) or not.
 		    bool local_processed;
 		    std::vector<typename Digraph::Node> _queue;
 		    int _queue_head,_queue_tail,_queue_next_dist;
 		    int _curr_dist;
 		    ///Creates the maps if necessary.
 		    ///\todo Better memory allocation (instead of new).
 		    void create_maps()
+		    {
 		      if(!_pred) {
 		        local_pred = true;
 		        _pred = Traits::createPredMap(*G);
+		      }
 		      if(!_dist) {
 		        local_dist = true;
 		        _dist = Traits::createDistMap(*G);
+		      }
 		      if(!_reached) {
 		        local_reached = true;
 		        _reached = Traits::createReachedMap(*G);
+		      }
 		      if(!_processed) {
 		        local_processed = true;
 		        _processed = Traits::createProcessedMap(*G);
+		      }
+		    }
 		  protected:
 		    Bfs() {}
 		  public:
 		    typedef Bfs Create;
 		    ///\name Named template parameters
 		    ///@{
 		    template <class T>
 		    struct DefPredMapTraits : public Traits {
 		      typedef T PredMap;
 		      static PredMap *createPredMap(const Digraph &)
+		      {
 		        throw UninitializedParameter();
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///PredMap type
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting PredMap type
 		    ///
 		    template <class T>
 		    struct DefPredMap : public Bfs< Digraph, DefPredMapTraits<T> > {
 		      typedef Bfs< Digraph, DefPredMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct DefDistMapTraits : public Traits {
 		      typedef T DistMap;
 		      static DistMap *createDistMap(const Digraph &)
+		      {
 		        throw UninitializedParameter();
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///DistMap type
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting DistMap type
 		    ///
 		    template <class T>
 		    struct DefDistMap : public Bfs< Digraph, DefDistMapTraits<T> > {
 		      typedef Bfs< Digraph, DefDistMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct DefReachedMapTraits : public Traits {
 		      typedef T ReachedMap;
 		      static ReachedMap *createReachedMap(const Digraph &)
+		      {
 		        throw UninitializedParameter();
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///ReachedMap type
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting ReachedMap type
 		    ///
 		    template <class T>
 		    struct DefReachedMap : public Bfs< Digraph, DefReachedMapTraits<T> > {
 		      typedef Bfs< Digraph, DefReachedMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct DefProcessedMapTraits : public Traits {
 		      typedef T ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &)
+		      {
 		        throw UninitializedParameter();
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///ProcessedMap type
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting ProcessedMap type
 		    ///
 		    template <class T>
 		    struct DefProcessedMap : public Bfs< Digraph, DefProcessedMapTraits<T> > {
 		      typedef Bfs< Digraph, DefProcessedMapTraits<T> > Create;
 		    };
 		    struct DefDigraphProcessedMapTraits : public Traits {
 		      typedef typename Digraph::template NodeMap<bool> ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &G)
+		      {
 		        return new ProcessedMap(G);
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter"
 		    ///for setting the ProcessedMap type to be Digraph::NodeMap<bool>.
 		    ///
 		    ///\ref named-templ-param "Named parameter"
 		    ///for setting the ProcessedMap type to be Digraph::NodeMap<bool>.
 		    ///If you don't set it explicitly, it will be automatically allocated.
 		    template <class T>
 		    struct DefProcessedMapToBeDefaultMap :
 		      public Bfs< Digraph, DefDigraphProcessedMapTraits> {
 		      typedef Bfs< Digraph, DefDigraphProcessedMapTraits> Create;
 		    };
 		    ///@}
 		  public:
 		    ///Constructor.
 		    ///\param _G the digraph the algorithm will run on.
 		    ///
 		    Bfs(const Digraph& _G) :
 		      G(&_G),
 		      _pred(NULL), local_pred(false),
 		      _dist(NULL), local_dist(false),
 		      _reached(NULL), local_reached(false),
 		      _processed(NULL), local_processed(false)
 		    { }
 		    ///Destructor.
 		    ~Bfs()
+		    {
 		      if(local_pred) delete _pred;
 		      if(local_dist) delete _dist;
 		      if(local_reached) delete _reached;
 		      if(local_processed) delete _processed;
+		    }
 		    ///Sets the map storing the predecessor arcs.
 		    ///Sets the map storing the predecessor arcs.
 		    ///If you don't use this function before calling \ref run(),
 		    ///it will allocate one. The destructor deallocates this
 		    ///automatically allocated map, of course.
 		    ///\return <tt> (*this) </tt>
 		    Bfs &predMap(PredMap &m)
+		    {
 		      if(local_pred) {
 		        delete _pred;
 		        local_pred=false;
+		      }
 		      _pred = &m;
 		      return *this;
+		    }
 		    ///Sets the map indicating the reached nodes.
 		    ///Sets the map indicating the reached nodes.
 		    ///If you don't use this function before calling \ref run(),
 		    ///it will allocate one. The destructor deallocates this
 		    ///automatically allocated map, of course.
 		    ///\return <tt> (*this) </tt>
 		    Bfs &reachedMap(ReachedMap &m)
+		    {
 		      if(local_reached) {
 		        delete _reached;
 		        local_reached=false;
+		      }
 		      _reached = &m;
 		      return *this;
+		    }
 		    ///Sets the map indicating the processed nodes.
 		    ///Sets the map indicating the processed nodes.
 		    ///If you don't use this function before calling \ref run(),
 		    ///it will allocate one. The destructor deallocates this
 		    ///automatically allocated map, of course.
 		    ///\return <tt> (*this) </tt>
 		    Bfs &processedMap(ProcessedMap &m)
+		    {
 		      if(local_processed) {
 		        delete _processed;
 		        local_processed=false;
+		      }
 		      _processed = &m;
 		      return *this;
+		    }
 		    ///Sets the map storing the distances calculated by the algorithm.
 		    ///Sets the map storing the distances calculated by the algorithm.
 		    ///If you don't use this function before calling \ref run(),
 		    ///it will allocate one. The destructor deallocates this
 		    ///automatically allocated map, of course.
 		    ///\return <tt> (*this) </tt>
 		    Bfs &distMap(DistMap &m)
+		    {
 		      if(local_dist) {
 		        delete _dist;
 		        local_dist=false;
+		      }
 		      _dist = &m;
 		      return *this;
+		    }
 		  public:
 		    ///\name Execution control

lemon/bits/alteration_notifier.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_BITS_ALTERATION_NOTIFIER_H
 		#define LEMON_BITS_ALTERATION_NOTIFIER_H
 		#include <vector>
 		#include <list>
-		#include <lemon/bits/utility.h>
+		#include <lemon/core.h>
 		///\ingroup graphbits
 		///\file
 		///\brief Observer notifier for graph alteration observers.
 		namespace lemon {
 		  /// \ingroup graphbits
 		  ///
 		  /// \brief Notifier class to notify observes about alterations in
 		  /// a container.
 		  ///
 		  /// The simple graph's can be refered as two containers, one node container
 		  /// and one edge container. But they are not standard containers they
 		  /// does not store values directly they are just key continars for more
 		  /// value containers which are the node and edge maps.
 		  ///
 		  /// The graph's node and edge sets can be changed as we add or erase
 		  /// nodes and edges in the graph. Lemon would like to handle easily
 		  /// that the node and edge maps should contain values for all nodes or
 		  /// edges. If we want to check on every indicing if the map contains
 		  /// the current indicing key that cause a drawback in the performance
 		  /// in the library. We use another solution we notify all maps about
 		  /// an alteration in the graph, which cause only drawback on the
 		  /// alteration of the graph.
 		  ///
 		  /// This class provides an interface to the container. The \e first() and \e
 		  /// next() member functions make possible to iterate on the keys of the
 		  /// container. The \e id() function returns an integer id for each key.
 		  /// The \e maxId() function gives back an upper bound of the ids.
 		  ///
 		  /// For the proper functonality of this class, we should notify it
 		  /// about each alteration in the container. The alterations have four type
 		  /// as \e add(), \e erase(), \e build() and \e clear(). The \e add() and
 		  /// \e erase() signals that only one or few items added or erased to or
 		  /// from the graph. If all items are erased from the graph or from an empty
 		  /// graph a new graph is builded then it can be signaled with the
 		  /// clear() and build() members. Important rule that if we erase items
 		  /// from graph we should first signal the alteration and after that erase
 		  /// them from the container, on the other way on item addition we should
 		  /// first extend the container and just after that signal the alteration.
 		  ///
 		  /// The alteration can be observed with a class inherited from the
 		  /// \e ObserverBase nested class. The signals can be handled with
 		  /// overriding the virtual functions defined in the base class.  The
 		  /// observer base can be attached to the notifier with the
 		  /// \e attach() member and can be detached with detach() function. The
 		  /// alteration handlers should not call any function which signals
 		  /// an other alteration in the same notifier and should not
 		  /// detach any observer from the notifier.
 		  ///
 		  /// Alteration observers try to be exception safe. If an \e add() or
 		  /// a \e clear() function throws an exception then the remaining
 		  /// observeres will not be notified and the fulfilled additions will
 		  /// be rolled back by calling the \e erase() or \e clear()
 		  /// functions. Thence the \e erase() and \e clear() should not throw
 		  /// exception. Actullay, it can be throw only
 		  /// \ref AlterationObserver::ImmediateDetach ImmediateDetach
 		  /// exception which detach the observer from the notifier.
 		  ///
 		  /// There are some place when the alteration observing is not completly
 		  /// reliable. If we want to carry out the node degree in the graph
 		  /// as in the \ref InDegMap and we use the reverseEdge that cause
 		  /// unreliable functionality. Because the alteration observing signals
 		  /// only erasing and adding but not the reversing it will stores bad
 		  /// degrees. The sub graph adaptors cannot signal the alterations because
 		  /// just a setting in the filter map can modify the graph and this cannot
 		  /// be watched in any way.
 		  ///
 		  /// \param _Container The container which is observed.
 		  /// \param _Item The item type which is obserbved.
 		  template <typename _Container, typename _Item>
 		  class AlterationNotifier {
 		  public:
 		    typedef True Notifier;
 		    typedef _Container Container;
 		    typedef _Item Item;
 		    /// \brief Exception which can be called from \e clear() and
 		    /// \e erase().
 		    ///
 		    /// From the \e clear() and \e erase() function only this
 		    /// exception is allowed to throw. The exception immediatly
 		    /// detaches the current observer from the notifier. Because the
 		    /// \e clear() and \e erase() should not throw other exceptions
 		    /// it can be used to invalidate the observer.
 		    struct ImmediateDetach {};
 		    /// \brief ObserverBase is the base class for the observers.
 		    ///
 		    /// ObserverBase is the abstract base class for the observers.
 		    /// It will be notified about an item was inserted into or
 		    /// erased from the graph.
 		    ///
 		    /// The observer interface contains some pure virtual functions
 		    /// to override. The add() and erase() functions are
 		    /// to notify the oberver when one item is added or
 		    /// erased.
 		    ///
 		    /// The build() and clear() members are to notify the observer
 		    /// about the container is built from an empty container or
 		    /// is cleared to an empty container.
 		    class ObserverBase {
 		    protected:
 		      typedef AlterationNotifier Notifier;
 		      friend class AlterationNotifier;
 		      /// \brief Default constructor.
 		      ///
 		      /// Default constructor for ObserverBase.
 		      ///
 		      ObserverBase() : _notifier(0) {}
 		      /// \brief Constructor which attach the observer into notifier.
 		      ///
 		      /// Constructor which attach the observer into notifier.
 		      ObserverBase(AlterationNotifier& nf) {
 		        attach(nf);
+		      }
 		      /// \brief Constructor which attach the obserever to the same notifier.
 		      ///
 		      /// Constructor which attach the obserever to the same notifier as
 		      /// the other observer is attached to.
 		      ObserverBase(const ObserverBase& copy) {
 		        if (copy.attached()) {
 		          attach(*copy.notifier());
+		        }
+		      }
 		      /// \brief Destructor
 		      virtual ~ObserverBase() {
 		        if (attached()) {
 		          detach();
+		        }
+		      }
 		      /// \brief Attaches the observer into an AlterationNotifier.
 		      ///
 		      /// This member attaches the observer into an AlterationNotifier.
 		      ///
 		      void attach(AlterationNotifier& nf) {
 		        nf.attach(*this);
+		      }
 		      /// \brief Detaches the observer into an AlterationNotifier.
 		      ///
 		      /// This member detaches the observer from an AlterationNotifier.
 		      ///
 		      void detach() {
 		        _notifier->detach(*this);
+		      }
 		      /// \brief Gives back a pointer to the notifier which the map
 		      /// attached into.
 		      ///
 		      /// This function gives back a pointer to the notifier which the map
 		      /// attached into.
 		      ///
 		      Notifier* notifier() const { return const_cast<Notifier*>(_notifier); }
 		      /// Gives back true when the observer is attached into a notifier.
 		      bool attached() const { return _notifier != 0; }
 		    private:
 		      ObserverBase& operator=(const ObserverBase& copy);
 		    protected:
 		      Notifier* _notifier;
 		      typename std::list<ObserverBase*>::iterator _index;
 		      /// \brief The member function to notificate the observer about an
 		      /// item is added to the container.
 		      ///
 		      /// The add() member function notificates the observer about an item
 		      /// is added to the container. It have to be overrided in the
 		      /// subclasses.
 		      virtual void add(const Item&) = 0;
 		      /// \brief The member function to notificate the observer about
 		      /// more item is added to the container.
 		      ///
 		      /// The add() member function notificates the observer about more item
 		      /// is added to the container. It have to be overrided in the
 		      /// subclasses.
 		      virtual void add(const std::vector<Item>& items) = 0;
 		      /// \brief The member function to notificate the observer about an
 		      /// item is erased from the container.
 		      ///
 		      /// The erase() member function notificates the observer about an
 		      /// item is erased from the container. It have to be overrided in
 		      /// the subclasses.
 		      virtual void erase(const Item&) = 0;
 		      /// \brief The member function to notificate the observer about
 		      /// more item is erased from the container.
 		      ///
 		      /// The erase() member function notificates the observer about more item
 		      /// is erased from the container. It have to be overrided in the
 		      /// subclasses.
 		      virtual void erase(const std::vector<Item>& items) = 0;
 		      /// \brief The member function to notificate the observer about the
 		      /// container is built.
 		      ///
 		      /// The build() member function notificates the observer about the
 		      /// container is built from an empty container. It have to be
 		      /// overrided in the subclasses.
 		      virtual void build() = 0;
 		      /// \brief The member function to notificate the observer about all
 		      /// items are erased from the container.
 		      ///
 		      /// The clear() member function notificates the observer about all
 		      /// items are erased from the container. It have to be overrided in
 		      /// the subclasses.
 		      virtual void clear() = 0;
 		    };
 		  protected:
 		    const Container* container;
 		    typedef std::list<ObserverBase*> Observers;
 		    Observers _observers;
 		  public:
 		    /// \brief Default constructor.
 		    ///
 		    /// The default constructor of the AlterationNotifier.
 		    /// It creates an empty notifier.
 		    AlterationNotifier()
 		      : container(0) {}
 		    /// \brief Constructor.
 		    ///
 		    /// Constructor with the observed container parameter.
 		    AlterationNotifier(const Container& _container)
 		      : container(&_container) {}
 		    /// \brief Copy Constructor of the AlterationNotifier.
 		    ///
 		    /// Copy constructor of the AlterationNotifier.
 		    /// It creates only an empty notifier because the copiable
 		    /// notifier's observers have to be registered still into that notifier.
 		    AlterationNotifier(const AlterationNotifier& _notifier)
 		      : container(_notifier.container) {}
 		    /// \brief Destructor.
 		    ///
 		    /// Destructor of the AlterationNotifier.
 		    ///
 		    ~AlterationNotifier() {
 		      typename Observers::iterator it;
 		      for (it = _observers.begin(); it != _observers.end(); ++it) {
 		        (*it)->_notifier = 0;
+		      }
+		    }
 		    /// \brief Sets the container.
 		    ///
 		    /// Sets the container.
 		    void setContainer(const Container& _container) {
 		      container = &_container;
+		    }
 		  protected:
 		    AlterationNotifier& operator=(const AlterationNotifier&);
 		  public:
 		    /// \brief First item in the container.
 		    ///
 		    /// Returns the first item in the container. It is
 		    /// for start the iteration on the container.
 		    void first(Item& item) const {
 		      container->first(item);
+		    }
 		    /// \brief Next item in the container.
 		    ///
 		    /// Returns the next item in the container. It is
 		    /// for iterate on the container.
 		    void next(Item& item) const {
 		      container->next(item);
+		    }
 		    /// \brief Returns the id of the item.
 		    ///
 		    /// Returns the id of the item provided by the container.
 		    int id(const Item& item) const {
 		      return container->id(item);
+		    }
 		    /// \brief Returns the maximum id of the container.
 		    ///
 		    /// Returns the maximum id of the container.
 		    int maxId() const {
 		      return container->maxId(Item());
+		    }
 		  protected:
 		    void attach(ObserverBase& observer) {
 		      observer._index = _observers.insert(_observers.begin(), &observer);
 		      observer._notifier = this;
+		    }
 		    void detach(ObserverBase& observer) {
 		      _observers.erase(observer._index);
 		      observer._index = _observers.end();
 		      observer._notifier = 0;
+		    }
 		  public:
 		    /// \brief Notifies all the registed observers about an item added to
 		    /// the container.
 		    ///
 		    /// It notifies all the registed observers about an item added to
 		    /// the container.
 		    ///
 		    void add(const Item& item) {
 		      typename Observers::reverse_iterator it;
 		      try {
 		        for (it = _observers.rbegin(); it != _observers.rend(); ++it) {
 		          (*it)->add(item);
+		        }
 		      } catch (...) {
 		        typename Observers::iterator jt;
 		        for (jt = it.base(); jt != _observers.end(); ++jt) {
 		          (*jt)->erase(item);
+		        }
 		        throw;
+		      }
+		    }
 		    /// \brief Notifies all the registed observers about more item added to
 		    /// the container.
 		    ///
 		    /// It notifies all the registed observers about more item added to
 		    /// the container.
 		    ///
 		    void add(const std::vector<Item>& items) {
 		      typename Observers::reverse_iterator it;
 		      try {
 		        for (it = _observers.rbegin(); it != _observers.rend(); ++it) {
 		          (*it)->add(items);
+		        }
 		      } catch (...) {
 		        typename Observers::iterator jt;
 		        for (jt = it.base(); jt != _observers.end(); ++jt) {
 		          (*jt)->erase(items);
+		        }
 		        throw;
+		      }
+		    }
 		    /// \brief Notifies all the registed observers about an item erased from
 		    /// the container.
 		    ///
 		    /// It notifies all the registed observers about an item erased from
 		    /// the container.
 		    ///
 		    void erase(const Item& item) throw() {
 		      typename Observers::iterator it = _observers.begin();
 		      while (it != _observers.end()) {
 		        try {
 		          (*it)->erase(item);

lemon/bits/base_extender.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_BITS_BASE_EXTENDER_H
 		#define LEMON_BITS_BASE_EXTENDER_H
-		#include <lemon/bits/invalid.h>
+		#include <lemon/core.h>
 		#include <lemon/error.h>
 		#include <lemon/bits/map_extender.h>
 		#include <lemon/bits/default_map.h>
 		#include <lemon/concept_check.h>
 		#include <lemon/concepts/maps.h>
 		///\ingroup digraphbits
 		///\file
 		///\brief Extenders for the digraph types
 		namespace lemon {
 		  /// \ingroup digraphbits
 		  ///
 		  /// \brief BaseDigraph to BaseGraph extender
 		  template <typename Base>
 		  class UndirDigraphExtender : public Base {
 		  public:
 		    typedef Base Parent;
 		    typedef typename Parent::Arc Edge;
 		    typedef typename Parent::Node Node;
 		    typedef True UndirectedTag;
 		    class Arc : public Edge {
 		      friend class UndirDigraphExtender;
 		    protected:
 		      bool forward;
 		      Arc(const Edge &ue, bool _forward) :
 		        Edge(ue), forward(_forward) {}
 		    public:
 		      Arc() {}
 		      /// Invalid arc constructor
 		      Arc(Invalid i) : Edge(i), forward(true) {}
 		      bool operator==(const Arc &that) const {
 		        return forward==that.forward && Edge(*this)==Edge(that);
+		      }
 		      bool operator!=(const Arc &that) const {
 		        return forward!=that.forward || Edge(*this)!=Edge(that);
+		      }
 		      bool operator<(const Arc &that) const {
 		        return forward<that.forward ||
 		          (!(that.forward<forward) && Edge(*this)<Edge(that));
+		      }
 		    };
 		    using Parent::source;
 		    /// Source of the given Arc.
 		    Node source(const Arc &e) const {
 		      return e.forward ? Parent::source(e) : Parent::target(e);
+		    }
 		    using Parent::target;
 		    /// Target of the given Arc.
 		    Node target(const Arc &e) const {
 		      return e.forward ? Parent::target(e) : Parent::source(e);
+		    }
 		    /// \brief Directed arc from an edge.
 		    ///
 		    /// Returns a directed arc corresponding to the specified Edge.
 		    /// If the given bool is true the given edge and the
 		    /// returned arc have the same source node.
 		    static Arc direct(const Edge &ue, bool d) {
 		      return Arc(ue, d);
+		    }
 		    /// Returns whether the given directed arc is same orientation as the
 		    /// corresponding edge.
 		    ///
 		    /// \todo reference to the corresponding point of the undirected digraph
 		    /// concept. "What does the direction of an edge mean?"
 		    static bool direction(const Arc &e) { return e.forward; }
 		    using Parent::first;
 		    using Parent::next;
 		    void first(Arc &e) const {
 		      Parent::first(e);
 		      e.forward=true;
+		    }
 		    void next(Arc &e) const {
 		      if( e.forward ) {
 		        e.forward = false;
+		      }
 		      else {
 		        Parent::next(e);
 		        e.forward = true;
+		      }
+		    }
 		    void firstOut(Arc &e, const Node &n) const {
 		      Parent::firstIn(e,n);
 		      if( Edge(e) != INVALID ) {
 		        e.forward = false;
+		      }
 		      else {
 		        Parent::firstOut(e,n);
 		        e.forward = true;
+		      }
+		    }
 		    void nextOut(Arc &e) const {
 		      if( ! e.forward ) {
 		        Node n = Parent::target(e);
 		        Parent::nextIn(e);
 		        if( Edge(e) == INVALID ) {
 		          Parent::firstOut(e, n);
 		          e.forward = true;
+		        }
+		      }
 		      else {
 		        Parent::nextOut(e);
+		      }
+		    }
 		    void firstIn(Arc &e, const Node &n) const {
 		      Parent::firstOut(e,n);
 		      if( Edge(e) != INVALID ) {
 		        e.forward = false;
+		      }
 		      else {
 		        Parent::firstIn(e,n);
 		        e.forward = true;
+		      }
+		    }
 		    void nextIn(Arc &e) const {
 		      if( ! e.forward ) {
 		        Node n = Parent::source(e);
 		        Parent::nextOut(e);
 		        if( Edge(e) == INVALID ) {
 		          Parent::firstIn(e, n);
 		          e.forward = true;
+		        }
+		      }
 		      else {
 		        Parent::nextIn(e);
+		      }
+		    }
 		    void firstInc(Edge &e, bool &d, const Node &n) const {
 		      d = true;
 		      Parent::firstOut(e, n);
 		      if (e != INVALID) return;
 		      d = false;
 		      Parent::firstIn(e, n);
+		    }
 		    void nextInc(Edge &e, bool &d) const {
 		      if (d) {
 		        Node s = Parent::source(e);
 		        Parent::nextOut(e);
 		        if (e != INVALID) return;
 		        d = false;
 		        Parent::firstIn(e, s);
 		      } else {
 		        Parent::nextIn(e);
+		      }
+		    }
 		    Node nodeFromId(int ix) const {
 		      return Parent::nodeFromId(ix);
+		    }
 		    Arc arcFromId(int ix) const {
 		      return direct(Parent::arcFromId(ix >> 1), bool(ix & 1));
+		    }
 		    Edge edgeFromId(int ix) const {
 		      return Parent::arcFromId(ix);
+		    }
 		    int id(const Node &n) const {
 		      return Parent::id(n);
+		    }
 		    int id(const Edge &e) const {
 		      return Parent::id(e);
+		    }
 		    int id(const Arc &e) const {
 		      return 2 * Parent::id(e) + int(e.forward);
+		    }
 		    int maxNodeId() const {
 		      return Parent::maxNodeId();
+		    }
 		    int maxArcId() const {
 		      return 2 * Parent::maxArcId() + 1;
+		    }
 		    int maxEdgeId() const {
 		      return Parent::maxArcId();
+		    }
 		    int arcNum() const {
 		      return 2 * Parent::arcNum();
+		    }
 		    int edgeNum() const {
 		      return Parent::arcNum();
+		    }
 		    Arc findArc(Node s, Node t, Arc p = INVALID) const {
 		      if (p == INVALID) {
 		        Edge arc = Parent::findArc(s, t);
 		        if (arc != INVALID) return direct(arc, true);
 		        arc = Parent::findArc(t, s);
 		        if (arc != INVALID) return direct(arc, false);
 		      } else if (direction(p)) {
 		        Edge arc = Parent::findArc(s, t, p);
 		        if (arc != INVALID) return direct(arc, true);
 		        arc = Parent::findArc(t, s);
 		        if (arc != INVALID) return direct(arc, false);
 		      } else {
 		        Edge arc = Parent::findArc(t, s, p);
 		        if (arc != INVALID) return direct(arc, false);
+		      }
 		      return INVALID;
+		    }
 		    Edge findEdge(Node s, Node t, Edge p = INVALID) const {
 		      if (s != t) {
 		        if (p == INVALID) {
 		          Edge arc = Parent::findArc(s, t);
 		          if (arc != INVALID) return arc;
 		          arc = Parent::findArc(t, s);
 		          if (arc != INVALID) return arc;
 		        } else if (Parent::s(p) == s) {
 		          Edge arc = Parent::findArc(s, t, p);
 		          if (arc != INVALID) return arc;
 		          arc = Parent::findArc(t, s);
 		          if (arc != INVALID) return arc;
 		        } else {
 		          Edge arc = Parent::findArc(t, s, p);
 		          if (arc != INVALID) return arc;
+		        }
 		      } else {
 		        return Parent::findArc(s, t, p);
+		      }
 		      return INVALID;
+		    }
 		  };
 		  template <typename Base>
 		  class BidirBpGraphExtender : public Base {
 		  public:
 		    typedef Base Parent;
 		    typedef BidirBpGraphExtender Digraph;
 		    typedef typename Parent::Node Node;
 		    typedef typename Parent::Edge Edge;
 		    using Parent::first;
 		    using Parent::next;
 		    using Parent::id;
 		    class Red : public Node {
 		      friend class BidirBpGraphExtender;
 		    public:
 		      Red() {}
 		      Red(const Node& node) : Node(node) {
 		        LEMON_ASSERT(Parent::red(node) || node == INVALID,
 		                     typename Parent::NodeSetError());
+		      }
 		      Red& operator=(const Node& node) {
 		        LEMON_ASSERT(Parent::red(node) || node == INVALID,
 		                     typename Parent::NodeSetError());
 		        Node::operator=(node);
 		        return *this;
+		      }
 		      Red(Invalid) : Node(INVALID) {}
 		      Red& operator=(Invalid) {
 		        Node::operator=(INVALID);
 		        return *this;
+		      }
 		    };
 		    void first(Red& node) const {
 		      Parent::firstRed(static_cast<Node&>(node));
+		    }
 		    void next(Red& node) const {
 		      Parent::nextRed(static_cast<Node&>(node));
+		    }
 		    int id(const Red& node) const {
 		      return Parent::redId(node);
+		    }
 		    class Blue : public Node {
 		      friend class BidirBpGraphExtender;
 		    public:
 		      Blue() {}
 		      Blue(const Node& node) : Node(node) {
 		        LEMON_ASSERT(Parent::blue(node) || node == INVALID,
 		                     typename Parent::NodeSetError());
+		      }
 		      Blue& operator=(const Node& node) {
 		        LEMON_ASSERT(Parent::blue(node) || node == INVALID,
 		                     typename Parent::NodeSetError());
 		        Node::operator=(node);
 		        return *this;
+		      }
 		      Blue(Invalid) : Node(INVALID) {}
 		      Blue& operator=(Invalid) {
 		        Node::operator=(INVALID);
 		        return *this;
+		      }
 		    };
 		    void first(Blue& node) const {
 		      Parent::firstBlue(static_cast<Node&>(node));
+		    }
 		    void next(Blue& node) const {
 		      Parent::nextBlue(static_cast<Node&>(node));
+		    }
 		    int id(const Blue& node) const {
 		      return Parent::redId(node);
+		    }
 		    Node source(const Edge& arc) const {
 		      return red(arc);
+		    }
 		    Node target(const Edge& arc) const {
 		      return blue(arc);
+		    }
 		    void firstInc(Edge& arc, bool& dir, const Node& node) const {
 		      if (Parent::red(node)) {
 		        Parent::firstFromRed(arc, node);
 		        dir = true;
 		      } else {
 		        Parent::firstFromBlue(arc, node);
 		        dir = static_cast<Edge&>(arc) == INVALID;
+		      }
+		    }
 		    void nextInc(Edge& arc, bool& dir) const {
 		      if (dir) {
 		        Parent::nextFromRed(arc);
 		      } else {
 		        Parent::nextFromBlue(arc);
 		        if (arc == INVALID) dir = true;
+		      }
+		    }
 		    class Arc : public Edge {
 		      friend class BidirBpGraphExtender;
 		    protected:
 		      bool forward;
 		      Arc(const Edge& arc, bool _forward)
 		        : Edge(arc), forward(_forward) {}
 		    public:
 		      Arc() {}
 		      Arc (Invalid) : Edge(INVALID), forward(true) {}
 		      bool operator==(const Arc& i) const {
 		        return Edge::operator==(i) && forward == i.forward;
+		      }
 		      bool operator!=(const Arc& i) const {
 		        return Edge::operator!=(i) || forward != i.forward;
+		      }
 		      bool operator<(const Arc& i) const {
 		        return Edge::operator<(i) ||
 		          (!(i.forward<forward) && Edge(*this)<Edge(i));
+		      }

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-2008
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_BITS_GRAPH_EXTENDER_H
 		#define LEMON_BITS_GRAPH_EXTENDER_H
 		#include <lemon/bits/invalid.h>
 		#include <lemon/bits/utility.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 digraph types
 		namespace lemon {
 		  /// \ingroup graphbits
 		  ///
 		  /// \brief Extender for the Digraphs
 		  template <typename Base>
 		  class DigraphExtender : public Base {
 		  public:
 		    typedef Base Parent;
 		    typedef DigraphExtender Digraph;
 		    // Base extensions
 		    typedef typename Parent::Node Node;
 		    typedef typename Parent::Arc Arc;
 		    int maxId(Node) const {
 		      return Parent::maxNodeId();
+		    }
 		    int maxId(Arc) const {
 		      return Parent::maxArcId();
+		    }
 		    Node fromId(int id, Node) const {
 		      return Parent::nodeFromId(id);
+		    }
 		    Arc fromId(int id, Arc) const {
 		      return Parent::arcFromId(id);
+		    }
 		    Node oppositeNode(const Node &node, const Arc &arc) const {
 		      if (node == Parent::source(arc))
 		        return Parent::target(arc);
 		      else if(node == Parent::target(arc))
 		        return Parent::source(arc);
 		      else
 		        return INVALID;
+		    }
 		    // Alterable extension
 		    typedef AlterationNotifier<DigraphExtender, Node> NodeNotifier;
 		    typedef AlterationNotifier<DigraphExtender, Arc> ArcNotifier;
 		  protected:
 		    mutable NodeNotifier node_notifier;
 		    mutable ArcNotifier arc_notifier;
 		  public:
 		    NodeNotifier& notifier(Node) const {
 		      return node_notifier;
+		    }
 		    ArcNotifier& notifier(Arc) const {
 		      return arc_notifier;
+		    }
 		    class NodeIt : public Node {
 		      const Digraph* _digraph;
 		    public:
 		      NodeIt() {}
 		      NodeIt(Invalid i) : Node(i) { }
 		      explicit NodeIt(const Digraph& digraph) : _digraph(&digraph) {
 		        _digraph->first(static_cast<Node&>(*this));
+		      }
 		      NodeIt(const Digraph& digraph, const Node& node)
 		        : Node(node), _digraph(&digraph) {}
 		      NodeIt& operator++() {
 		        _digraph->next(*this);
 		        return *this;
+		      }
 		    };
 		    class ArcIt : public Arc {
 		      const Digraph* _digraph;
 		    public:
 		      ArcIt() { }
 		      ArcIt(Invalid i) : Arc(i) { }
 		      explicit ArcIt(const Digraph& digraph) : _digraph(&digraph) {
 		        _digraph->first(static_cast<Arc&>(*this));
+		      }
 		      ArcIt(const Digraph& digraph, const Arc& arc) :
 		        Arc(arc), _digraph(&digraph) { }
 		      ArcIt& operator++() {
 		        _digraph->next(*this);
 		        return *this;
+		      }
 		    };
 		    class OutArcIt : public Arc {
 		      const Digraph* _digraph;
 		    public:
 		      OutArcIt() { }
 		      OutArcIt(Invalid i) : Arc(i) { }
 		      OutArcIt(const Digraph& digraph, const Node& node)
 		        : _digraph(&digraph) {
 		        _digraph->firstOut(*this, node);
+		      }
 		      OutArcIt(const Digraph& digraph, const Arc& arc)
 		        : Arc(arc), _digraph(&digraph) {}
 		      OutArcIt& operator++() {
 		        _digraph->nextOut(*this);
 		        return *this;
+		      }
 		    };
 		    class InArcIt : public Arc {
 		      const Digraph* _digraph;
 		    public:
 		      InArcIt() { }
 		      InArcIt(Invalid i) : Arc(i) { }
 		      InArcIt(const Digraph& digraph, const Node& node)
 		        : _digraph(&digraph) {
 		        _digraph->firstIn(*this, node);
+		      }
 		      InArcIt(const Digraph& digraph, const Arc& arc) :
 		        Arc(arc), _digraph(&digraph) {}
 		      InArcIt& operator++() {
 		        _digraph->nextIn(*this);
 		        return *this;
+		      }
 		    };
 		    /// \brief Base node of the iterator
 		    ///
 		    /// Returns the base node (i.e. the source in this case) of the iterator
 		    Node baseNode(const OutArcIt &arc) const {
 		      return Parent::source(arc);
+		    }
 		    /// \brief Running node of the iterator
 		    ///
 		    /// Returns the running node (i.e. the target in this case) of the
 		    /// iterator
 		    Node runningNode(const OutArcIt &arc) const {
 		      return Parent::target(arc);
+		    }
 		    /// \brief Base node of the iterator
 		    ///
 		    /// Returns the base node (i.e. the target in this case) of the iterator
 		    Node baseNode(const InArcIt &arc) const {
 		      return Parent::target(arc);
+		    }
 		    /// \brief Running node of the iterator
 		    ///
 		    /// Returns the running node (i.e. the source in this case) of the
 		    /// iterator
 		    Node runningNode(const InArcIt &arc) const {
 		      return Parent::source(arc);
+		    }
 		    template <typename _Value>
 		    class NodeMap
 		      : public MapExtender<DefaultMap<Digraph, Node, _Value> > {
 		    public:
 		      typedef DigraphExtender Digraph;
 		      typedef MapExtender<DefaultMap<Digraph, Node, _Value> > Parent;
 		      explicit NodeMap(const Digraph& digraph)
 		        : Parent(digraph) {}
 		      NodeMap(const Digraph& digraph, const _Value& value)
 		        : Parent(digraph, value) {}
 		      NodeMap& operator=(const NodeMap& cmap) {
 		        return operator=<NodeMap>(cmap);
+		      }
 		      template <typename CMap>
 		      NodeMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		    template <typename _Value>
 		    class ArcMap
 		      : public MapExtender<DefaultMap<Digraph, Arc, _Value> > {
 		    public:
 		      typedef DigraphExtender Digraph;
 		      typedef MapExtender<DefaultMap<Digraph, Arc, _Value> > Parent;
 		      explicit ArcMap(const Digraph& digraph)
 		        : Parent(digraph) {}
 		      ArcMap(const Digraph& digraph, const _Value& value)
 		        : Parent(digraph, value) {}
 		      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 {
 		  public:
 		    typedef Base Parent;
 		    typedef GraphExtender Graph;
 		    typedef True UndirectedTag;
 		    typedef typename Parent::Node Node;
 		    typedef typename Parent::Arc Arc;
 		    typedef typename Parent::Edge Edge;
 		    // Graph extension
 		    int maxId(Node) const {
 		      return Parent::maxNodeId();
+		    }
 		    int maxId(Arc) const {
 		      return Parent::maxArcId();
+		    }
 		    int maxId(Edge) const {
 		      return Parent::maxEdgeId();
+		    }
 		    Node fromId(int id, Node) const {
 		      return Parent::nodeFromId(id);
+		    }
 		    Arc fromId(int id, Arc) const {
 		      return Parent::arcFromId(id);
+		    }
 		    Edge fromId(int id, Edge) const {
 		      return Parent::edgeFromId(id);
+		    }
 		    Node oppositeNode(const Node &n, const Edge &e) const {
 		      if( n == Parent::u(e))
 		        return Parent::v(e);
 		      else if( n == Parent::v(e))
 		        return Parent::u(e);
 		      else
 		        return INVALID;
+		    }
 		    Arc oppositeArc(const Arc &arc) const {
 		      return Parent::direct(arc, !Parent::direction(arc));
+		    }
 		    using Parent::direct;
 		    Arc direct(const Edge &edge, const Node &node) const {
 		      return Parent::direct(edge, Parent::u(edge) == node);
+		    }
 		    // Alterable extension
 		    typedef AlterationNotifier<GraphExtender, Node> NodeNotifier;
 		    typedef AlterationNotifier<GraphExtender, Arc> ArcNotifier;
 		    typedef AlterationNotifier<GraphExtender, Edge> EdgeNotifier;
 		  protected:
 		    mutable NodeNotifier node_notifier;
 		    mutable ArcNotifier arc_notifier;
 		    mutable EdgeNotifier edge_notifier;
 		  public:
 		    NodeNotifier& notifier(Node) const {
 		      return node_notifier;
+		    }
 		    ArcNotifier& notifier(Arc) const {
 		      return arc_notifier;

lemon/bits/traits.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_BITS_TRAITS_H
 		#define LEMON_BITS_TRAITS_H
 		#include <lemon/bits/utility.h>
 		///\file
 		///\brief Traits for graphs and maps
 		///
 		#include <lemon/bits/enable_if.h>
 		namespace lemon {
 		  struct InvalidType {};
 		  template <typename _Graph, typename _Item>
 		  class ItemSetTraits {};
 		  template <typename Graph, typename Enable = void>
 		  struct NodeNotifierIndicator {
 		    typedef InvalidType Type;
 		  };
 		  template <typename Graph>
 		  struct NodeNotifierIndicator<
 		    Graph,
 		    typename enable_if<typename Graph::NodeNotifier::Notifier, void>::type
 		  > {
 		    typedef typename Graph::NodeNotifier Type;
 		  };
 		  template <typename _Graph>
 		  class ItemSetTraits<_Graph, typename _Graph::Node> {
 		  public:
 		    typedef _Graph Graph;
 		    typedef typename Graph::Node Item;
 		    typedef typename Graph::NodeIt ItemIt;
 		    typedef typename NodeNotifierIndicator<Graph>::Type ItemNotifier;
 		    template <typename _Value>
 		    class Map : public Graph::template NodeMap<_Value> {
 		    public:
 		      typedef typename Graph::template NodeMap<_Value> Parent;
 		      typedef typename Graph::template NodeMap<_Value> Type;
 		      typedef typename Parent::Value Value;
 		      Map(const Graph& _digraph) : Parent(_digraph) {}
 		      Map(const Graph& _digraph, const Value& _value)
 		        : Parent(_digraph, _value) {}
 		     };
 		  };
 		  template <typename Graph, typename Enable = void>
 		  struct ArcNotifierIndicator {
 		    typedef InvalidType Type;
 		  };
 		  template <typename Graph>
 		  struct ArcNotifierIndicator<
 		    Graph,
 		    typename enable_if<typename Graph::ArcNotifier::Notifier, void>::type
 		  > {
 		    typedef typename Graph::ArcNotifier Type;
 		  };
 		  template <typename _Graph>
 		  class ItemSetTraits<_Graph, typename _Graph::Arc> {
 		  public:
 		    typedef _Graph Graph;
 		    typedef typename Graph::Arc Item;
 		    typedef typename Graph::ArcIt ItemIt;
 		    typedef typename ArcNotifierIndicator<Graph>::Type ItemNotifier;
 		    template <typename _Value>
 		    class Map : public Graph::template ArcMap<_Value> {
 		    public:
 		      typedef typename Graph::template ArcMap<_Value> Parent;
 		      typedef typename Graph::template ArcMap<_Value> Type;
 		      typedef typename Parent::Value Value;
 		      Map(const Graph& _digraph) : Parent(_digraph) {}
 		      Map(const Graph& _digraph, const Value& _value)
 		        : Parent(_digraph, _value) {}
 		    };
 		  };
 		  template <typename Graph, typename Enable = void>
 		  struct EdgeNotifierIndicator {
 		    typedef InvalidType Type;
 		  };
 		  template <typename Graph>
 		  struct EdgeNotifierIndicator<
 		    Graph,
 		    typename enable_if<typename Graph::EdgeNotifier::Notifier, void>::type
 		  > {
 		    typedef typename Graph::EdgeNotifier Type;
 		  };
 		  template <typename _Graph>
 		  class ItemSetTraits<_Graph, typename _Graph::Edge> {
 		  public:
 		    typedef _Graph Graph;
 		    typedef typename Graph::Edge Item;
 		    typedef typename Graph::EdgeIt ItemIt;
 		    typedef typename EdgeNotifierIndicator<Graph>::Type ItemNotifier;
 		    template <typename _Value>
 		    class Map : public Graph::template EdgeMap<_Value> {
 		    public:
 		      typedef typename Graph::template EdgeMap<_Value> Parent;
 		      typedef typename Graph::template EdgeMap<_Value> Type;
 		      typedef typename Parent::Value Value;
 		      Map(const Graph& _digraph) : Parent(_digraph) {}
 		      Map(const Graph& _digraph, const Value& _value)
 		        : Parent(_digraph, _value) {}
 		    };
 		  };
 		  template <typename Map, typename Enable = void>
 		  struct MapTraits {
 		    typedef False ReferenceMapTag;
 		    typedef typename Map::Key Key;
 		    typedef typename Map::Value Value;
 		    typedef Value ConstReturnValue;
 		    typedef Value ReturnValue;
 		  };
 		  template <typename Map>
 		  struct MapTraits<
 		    Map, typename enable_if<typename Map::ReferenceMapTag, void>::type >
+		  {
 		    typedef True ReferenceMapTag;
 		    typedef typename Map::Key Key;
 		    typedef typename Map::Value Value;
 		    typedef typename Map::ConstReference ConstReturnValue;
 		    typedef typename Map::Reference ReturnValue;
 		    typedef typename Map::ConstReference ConstReference;
 		    typedef typename Map::Reference Reference;
 		 };
 		  template <typename MatrixMap, typename Enable = void>
 		  struct MatrixMapTraits {
 		    typedef False ReferenceMapTag;
 		    typedef typename MatrixMap::FirstKey FirstKey;
 		    typedef typename MatrixMap::SecondKey SecondKey;
 		    typedef typename MatrixMap::Value Value;
 		    typedef Value ConstReturnValue;
 		    typedef Value ReturnValue;
 		  };
 		  template <typename MatrixMap>
 		  struct MatrixMapTraits<
 		    MatrixMap, typename enable_if<typename MatrixMap::ReferenceMapTag,
 		                                  void>::type >
+		  {
 		    typedef True ReferenceMapTag;
 		    typedef typename MatrixMap::FirstKey FirstKey;
 		    typedef typename MatrixMap::SecondKey SecondKey;
 		    typedef typename MatrixMap::Value Value;
 		    typedef typename MatrixMap::ConstReference ConstReturnValue;
 		    typedef typename MatrixMap::Reference ReturnValue;
 		    typedef typename MatrixMap::ConstReference ConstReference;
 		    typedef typename MatrixMap::Reference Reference;
 		 };
 		  // Indicators for the tags
 		  template <typename Graph, typename Enable = void>
 		  struct NodeNumTagIndicator {
 		    static const bool value = false;
 		  };
 		  template <typename Graph>
 		  struct NodeNumTagIndicator<
 		    Graph,
 		    typename enable_if<typename Graph::NodeNumTag, void>::type
 		  > {
 		    static const bool value = true;
 		  };
 		  template <typename Graph, typename Enable = void>
 		  struct EdgeNumTagIndicator {
 		    static const bool value = false;
 		  };
 		  template <typename Graph>
 		  struct EdgeNumTagIndicator<
 		    Graph,
 		    typename enable_if<typename Graph::EdgeNumTag, void>::type
 		  > {
 		    static const bool value = true;
 		  };
 		  template <typename Graph, typename Enable = void>
 		  struct FindEdgeTagIndicator {
 		    static const bool value = false;
 		  };
 		  template <typename Graph>
 		  struct FindEdgeTagIndicator<
 		    Graph,
 		    typename enable_if<typename Graph::FindEdgeTag, void>::type
 		  > {
 		    static const bool value = true;
 		  };
 		  template <typename Graph, typename Enable = void>
 		  struct UndirectedTagIndicator {
 		    static const bool value = false;
 		  };
 		  template <typename Graph>
 		  struct UndirectedTagIndicator<
 		    Graph,
 		    typename enable_if<typename Graph::UndirectedTag, void>::type
 		  > {
 		    static const bool value = true;
 		  };
 		  template <typename Graph, typename Enable = void>
 		  struct BuildTagIndicator {
 		    static const bool value = false;
 		  };
 		  template <typename Graph>
 		  struct BuildTagIndicator<
 		    Graph,
 		    typename enable_if<typename Graph::BuildTag, void>::type
 		  > {
 		    static const bool value = true;
 		  };
+		}
 		#endif

lemon/bits/vector_map.h

Show inline comments

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

lemon/concepts/digraph.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_CONCEPT_DIGRAPH_H
 		#define LEMON_CONCEPT_DIGRAPH_H
 		///\ingroup graph_concepts
 		///\file
 		///\brief The concept of directed graphs.
 		#include <lemon/bits/invalid.h>
 		#include <lemon/bits/utility.h>
 		#include <lemon/core.h>
 		#include <lemon/concepts/maps.h>
 		#include <lemon/concept_check.h>
 		#include <lemon/concepts/graph_components.h>
 		namespace lemon {
 		  namespace concepts {
 		    /// \ingroup graph_concepts
 		    ///
 		    /// \brief Class describing the concept of directed graphs.
 		    ///
 		    /// This class describes the \ref concept "concept" of the
 		    /// immutable directed digraphs.
 		    ///
 		    /// Note that actual digraph implementation like @ref ListDigraph or
 		    /// @ref SmartDigraph may have several additional functionality.
 		    ///
 		    /// \sa concept
 		    class Digraph {
 		    private:
 		      ///Digraphs are \e not copy constructible. Use DigraphCopy() instead.
 		      ///Digraphs are \e not copy constructible. Use DigraphCopy() instead.
 		      ///
 		      Digraph(const Digraph &) {};
 		      ///\brief Assignment of \ref Digraph "Digraph"s to another ones are
 		      ///\e not allowed. Use DigraphCopy() instead.
 		      ///Assignment of \ref Digraph "Digraph"s to another ones are
 		      ///\e not allowed.  Use DigraphCopy() instead.
 		      void operator=(const Digraph &) {}
 		    public:
 		      ///\e
 		      /// Defalult constructor.
 		      /// Defalult constructor.
 		      ///
 		      Digraph() { }
 		      /// Class for identifying a node of the digraph
 		      /// This class identifies a node of the digraph. It also serves
 		      /// as a base class of the node iterators,
 		      /// thus they will convert to this type.
 		      class Node {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        Node() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        Node(const Node&) { }
 		        /// Invalid constructor \& conversion.
 		        /// This constructor initializes the iterator to be invalid.
 		        /// \sa Invalid for more details.
 		        Node(Invalid) { }
 		        /// Equality operator
 		        /// Two iterators are equal if and only if they point to the
 		        /// same object or both are invalid.
 		        bool operator==(Node) const { return true; }
 		        /// Inequality operator
 		        /// \sa operator==(Node n)
 		        ///
 		        bool operator!=(Node) const { return true; }
 		        /// Artificial ordering operator.
 		        /// To allow the use of digraph descriptors as key type in std::map or
 		        /// similar associative container we require this.
 		        ///
 		        /// \note This operator only have to define some strict ordering of
 		        /// the items; this order has nothing to do with the iteration
 		        /// ordering of the items.
 		        bool operator<(Node) const { return false; }
 		      };
 		      /// This iterator goes through each node.
 		      /// This iterator goes through each node.
 		      /// Its usage is quite simple, for example you can count the number
 		      /// of nodes in digraph \c g of type \c Digraph like this:
 		      ///\code
 		      /// int count=0;
 		      /// for (Digraph::NodeIt n(g); n!=INVALID; ++n) ++count;
 		      ///\endcode
 		      class NodeIt : public Node {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        NodeIt() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        NodeIt(const NodeIt& n) : Node(n) { }
 		        /// Invalid constructor \& conversion.
 		        /// Initialize the iterator to be invalid.
 		        /// \sa Invalid for more details.
 		        NodeIt(Invalid) { }
 		        /// Sets the iterator to the first node.
 		        /// Sets the iterator to the first node of \c g.
 		        ///
 		        NodeIt(const Digraph&) { }
 		        /// Node -> NodeIt conversion.
 		        /// Sets the iterator to the node of \c the digraph pointed by
 		        /// the trivial iterator.
 		        /// This feature necessitates that each time we
 		        /// iterate the arc-set, the iteration order is the same.
 		        NodeIt(const Digraph&, const Node&) { }
 		        /// Next node.
 		        /// Assign the iterator to the next node.
 		        ///
 		        NodeIt& operator++() { return *this; }
 		      };
 		      /// Class for identifying an arc of the digraph
 		      /// This class identifies an arc of the digraph. It also serves
 		      /// as a base class of the arc iterators,
 		      /// thus they will convert to this type.
 		      class Arc {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        Arc() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        Arc(const Arc&) { }
 		        /// Initialize the iterator to be invalid.
 		        /// Initialize the iterator to be invalid.
 		        ///
 		        Arc(Invalid) { }
 		        /// Equality operator
 		        /// Two iterators are equal if and only if they point to the
 		        /// same object or both are invalid.
 		        bool operator==(Arc) const { return true; }
 		        /// Inequality operator
 		        /// \sa operator==(Arc n)
 		        ///
 		        bool operator!=(Arc) const { return true; }
 		        /// Artificial ordering operator.
 		        /// To allow the use of digraph descriptors as key type in std::map or
 		        /// similar associative container we require this.
 		        ///
 		        /// \note This operator only have to define some strict ordering of
 		        /// the items; this order has nothing to do with the iteration
 		        /// ordering of the items.
 		        bool operator<(Arc) const { return false; }
 		      };
 		      /// This iterator goes trough the outgoing arcs of a node.
 		      /// This iterator goes trough the \e outgoing arcs of a certain node
 		      /// of a digraph.
 		      /// Its usage is quite simple, for example you can count the number
 		      /// of outgoing arcs of a node \c n
 		      /// in digraph \c g of type \c Digraph as follows.
 		      ///\code
 		      /// int count=0;
 		      /// for (Digraph::OutArcIt e(g, n); e!=INVALID; ++e) ++count;
 		      ///\endcode
 		      class OutArcIt : public Arc {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        OutArcIt() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        OutArcIt(const OutArcIt& e) : Arc(e) { }
 		        /// Initialize the iterator to be invalid.
 		        /// Initialize the iterator to be invalid.
 		        ///
 		        OutArcIt(Invalid) { }
 		        /// This constructor sets the iterator to the first outgoing arc.
 		        /// This constructor sets the iterator to the first outgoing arc of
 		        /// the node.
 		        OutArcIt(const Digraph&, const Node&) { }
 		        /// Arc -> OutArcIt conversion
 		        /// Sets the iterator to the value of the trivial iterator.
 		        /// This feature necessitates that each time we
 		        /// iterate the arc-set, the iteration order is the same.
 		        OutArcIt(const Digraph&, const Arc&) { }
 		        ///Next outgoing arc
 		        /// Assign the iterator to the next
 		        /// outgoing arc of the corresponding node.
 		        OutArcIt& operator++() { return *this; }
 		      };
 		      /// This iterator goes trough the incoming arcs of a node.
 		      /// This iterator goes trough the \e incoming arcs of a certain node
 		      /// of a digraph.
 		      /// Its usage is quite simple, for example you can count the number
 		      /// of outgoing arcs of a node \c n
 		      /// in digraph \c g of type \c Digraph as follows.
 		      ///\code
 		      /// int count=0;
 		      /// for(Digraph::InArcIt e(g, n); e!=INVALID; ++e) ++count;
 		      ///\endcode
 		      class InArcIt : public Arc {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        InArcIt() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        InArcIt(const InArcIt& e) : Arc(e) { }
 		        /// Initialize the iterator to be invalid.
 		        /// Initialize the iterator to be invalid.
 		        ///
 		        InArcIt(Invalid) { }
 		        /// This constructor sets the iterator to first incoming arc.
 		        /// This constructor set the iterator to the first incoming arc of
 		        /// the node.
 		        InArcIt(const Digraph&, const Node&) { }
 		        /// Arc -> InArcIt conversion
 		        /// Sets the iterator to the value of the trivial iterator \c e.
 		        /// This feature necessitates that each time we
 		        /// iterate the arc-set, the iteration order is the same.
 		        InArcIt(const Digraph&, const Arc&) { }
 		        /// Next incoming arc
 		        /// Assign the iterator to the next inarc of the corresponding node.
 		        ///
 		        InArcIt& operator++() { return *this; }
 		      };
 		      /// This iterator goes through each arc.
 		      /// This iterator goes through each arc of a digraph.
 		      /// Its usage is quite simple, for example you can count the number
 		      /// of arcs in a digraph \c g of type \c Digraph as follows:
 		      ///\code
 		      /// int count=0;
 		      /// for(Digraph::ArcIt e(g); e!=INVALID; ++e) ++count;
 		      ///\endcode
 		      class ArcIt : public Arc {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        ArcIt() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        ArcIt(const ArcIt& e) : Arc(e) { }
 		        /// Initialize the iterator to be invalid.
 		        /// Initialize the iterator to be invalid.
 		        ///
 		        ArcIt(Invalid) { }
 		        /// This constructor sets the iterator to the first arc.
 		        /// This constructor sets the iterator to the first arc of \c g.
 		        ///@param g the digraph
 		        ArcIt(const Digraph& g) { ignore_unused_variable_warning(g); }
 		        /// Arc -> ArcIt conversion
 		        /// Sets the iterator to the value of the trivial iterator \c e.
 		        /// This feature necessitates that each time we
 		        /// iterate the arc-set, the iteration order is the same.
 		        ArcIt(const Digraph&, const Arc&) { }
 		        ///Next arc
 		        /// Assign the iterator to the next arc.
 		        ArcIt& operator++() { return *this; }
 		      };
 		      ///Gives back the target node of an arc.
 		      ///Gives back the target node of an arc.
 		      ///
 		      Node target(Arc) const { return INVALID; }
 		      ///Gives back the source node of an arc.
 		      ///Gives back the source node of an arc.
 		      ///
 		      Node source(Arc) const { return INVALID; }
 		      /// \brief Returns the ID of the node.
 		      int id(Node) const { return -1; }
 		      /// \brief Returns the ID of the arc.
 		      int id(Arc) const { return -1; }
 		      /// \brief Returns the node with the given ID.
 		      ///
 		      /// \pre The argument should be a valid node ID in the graph.
 		      Node nodeFromId(int) const { return INVALID; }
 		      /// \brief Returns the arc with the given ID.
 		      ///
 		      /// \pre The argument should be a valid arc ID in the graph.
 		      Arc arcFromId(int) const { return INVALID; }
 		      /// \brief Returns an upper bound on the node IDs.
 		      int maxNodeId() const { return -1; }
 		      /// \brief Returns an upper bound on the arc IDs.
 		      int maxArcId() const { return -1; }
 		      void first(Node&) const {}
 		      void next(Node&) const {}
 		      void first(Arc&) const {}
 		      void next(Arc&) const {}
 		      void firstIn(Arc&, const Node&) const {}
 		      void nextIn(Arc&) const {}
 		      void firstOut(Arc&, const Node&) const {}
 		      void nextOut(Arc&) const {}
 		      // The second parameter is dummy.
 		      Node fromId(int, Node) const { return INVALID; }
 		      // The second parameter is dummy.
 		      Arc fromId(int, Arc) const { return INVALID; }
 		      // Dummy parameter.
 		      int maxId(Node) const { return -1; }
 		      // Dummy parameter.
 		      int maxId(Arc) const { return -1; }
 		      /// \brief The base node of the iterator.
 		      ///
 		      /// Gives back the base node of the iterator.
 		      /// It is always the target of the pointed arc.
 		      Node baseNode(const InArcIt&) const { return INVALID; }
 		      /// \brief The running node of the iterator.
 		      ///
 		      /// Gives back the running node of the iterator.
 		      /// It is always the source of the pointed arc.
 		      Node runningNode(const InArcIt&) const { return INVALID; }
 		      /// \brief The base node of the iterator.
 		      ///
 		      /// Gives back the base node of the iterator.
 		      /// It is always the source of the pointed arc.

lemon/concepts/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-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.
+		 *
 		 */
 		///\ingroup graph_concepts
 		///\file
 		///\brief The concept of Undirected Graphs.
 		#ifndef LEMON_CONCEPT_GRAPH_H
 		#define LEMON_CONCEPT_GRAPH_H
 		#include <lemon/concepts/graph_components.h>
 		#include <lemon/concepts/graph.h>
-		#include <lemon/bits/utility.h>
+		#include <lemon/core.h>
 		namespace lemon {
 		  namespace concepts {
 		    /// \ingroup graph_concepts
 		    ///
 		    /// \brief Class describing the concept of Undirected Graphs.
 		    ///
 		    /// This class describes the common interface of all Undirected
 		    /// Graphs.
 		    ///
 		    /// As all concept describing classes it provides only interface
 		    /// without any sensible implementation. So any algorithm for
 		    /// undirected graph should compile with this class, but it will not
 		    /// run properly, of course.
 		    ///
 		    /// The LEMON undirected graphs also fulfill the concept of
 		    /// directed graphs (\ref lemon::concepts::Digraph "Digraph
 		    /// Concept"). Each edges can be seen as two opposite
 		    /// directed arc and consequently the undirected graph can be
 		    /// seen as the direceted graph of these directed arcs. The
 		    /// Graph has the Edge inner class for the edges and
 		    /// the Arc type for the directed arcs. The Arc type is
 		    /// convertible to Edge or inherited from it so from a directed
 		    /// arc we can get the represented edge.
 		    ///
 		    /// In the sense of the LEMON each edge has a default
 		    /// direction (it should be in every computer implementation,
 		    /// because the order of edge's nodes defines an
 		    /// orientation). With the default orientation we can define that
 		    /// the directed arc is forward or backward directed. With the \c
 		    /// direction() and \c direct() function we can get the direction
 		    /// of the directed arc and we can direct an edge.
 		    ///
 		    /// The EdgeIt is an iterator for the edges. We can use
 		    /// the EdgeMap to map values for the edges. The InArcIt and
 		    /// OutArcIt iterates on the same edges but with opposite
 		    /// direction. The IncEdgeIt iterates also on the same edges
 		    /// as the OutArcIt and InArcIt but it is not convertible to Arc just
 		    /// to Edge.
 		    class Graph {
 		    public:
 		      /// \brief The undirected graph should be tagged by the
 		      /// UndirectedTag.
 		      ///
 		      /// The undirected graph should be tagged by the UndirectedTag. This
 		      /// tag helps the enable_if technics to make compile time
 		      /// specializations for undirected graphs.
 		      typedef True UndirectedTag;
 		      /// \brief The base type of node iterators,
 		      /// or in other words, the trivial node iterator.
 		      ///
 		      /// This is the base type of each node iterator,
 		      /// thus each kind of node iterator converts to this.
 		      /// More precisely each kind of node iterator should be inherited
 		      /// from the trivial node iterator.
 		      class Node {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        Node() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        Node(const Node&) { }
 		        /// Invalid constructor \& conversion.
 		        /// This constructor initializes the iterator to be invalid.
 		        /// \sa Invalid for more details.
 		        Node(Invalid) { }
 		        /// Equality operator
 		        /// Two iterators are equal if and only if they point to the
 		        /// same object or both are invalid.
 		        bool operator==(Node) const { return true; }
 		        /// Inequality operator
 		        /// \sa operator==(Node n)
 		        ///
 		        bool operator!=(Node) const { return true; }
 		        /// Artificial ordering operator.
 		        /// To allow the use of graph descriptors as key type in std::map or
 		        /// similar associative container we require this.
 		        ///
 		        /// \note This operator only have to define some strict ordering of
 		        /// the items; this order has nothing to do with the iteration
 		        /// ordering of the items.
 		        bool operator<(Node) const { return false; }
 		      };
 		      /// This iterator goes through each node.
 		      /// This iterator goes through each node.
 		      /// Its usage is quite simple, for example you can count the number
 		      /// of nodes in graph \c g of type \c Graph like this:
 		      ///\code
 		      /// int count=0;
 		      /// for (Graph::NodeIt n(g); n!=INVALID; ++n) ++count;
 		      ///\endcode
 		      class NodeIt : public Node {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        NodeIt() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        NodeIt(const NodeIt& n) : Node(n) { }
 		        /// Invalid constructor \& conversion.
 		        /// Initialize the iterator to be invalid.
 		        /// \sa Invalid for more details.
 		        NodeIt(Invalid) { }
 		        /// Sets the iterator to the first node.
 		        /// Sets the iterator to the first node of \c g.
 		        ///
 		        NodeIt(const Graph&) { }
 		        /// Node -> NodeIt conversion.
 		        /// Sets the iterator to the node of \c the graph pointed by
 		        /// the trivial iterator.
 		        /// This feature necessitates that each time we
 		        /// iterate the arc-set, the iteration order is the same.
 		        NodeIt(const Graph&, const Node&) { }
 		        /// Next node.
 		        /// Assign the iterator to the next node.
 		        ///
 		        NodeIt& operator++() { return *this; }
 		      };
 		      /// The base type of the edge iterators.
 		      /// The base type of the edge iterators.
 		      ///
 		      class Edge {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        Edge() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        Edge(const Edge&) { }
 		        /// Initialize the iterator to be invalid.
 		        /// Initialize the iterator to be invalid.
 		        ///
 		        Edge(Invalid) { }
 		        /// Equality operator
 		        /// Two iterators are equal if and only if they point to the
 		        /// same object or both are invalid.
 		        bool operator==(Edge) const { return true; }
 		        /// Inequality operator
 		        /// \sa operator==(Edge n)
 		        ///
 		        bool operator!=(Edge) const { return true; }
 		        /// Artificial ordering operator.
 		        /// To allow the use of graph descriptors as key type in std::map or
 		        /// similar associative container we require this.
 		        ///
 		        /// \note This operator only have to define some strict ordering of
 		        /// the items; this order has nothing to do with the iteration
 		        /// ordering of the items.
 		        bool operator<(Edge) const { return false; }
 		      };
 		      /// This iterator goes through each edge.
 		      /// This iterator goes through each edge of a graph.
 		      /// Its usage is quite simple, for example you can count the number
 		      /// of edges in a graph \c g of type \c Graph as follows:
 		      ///\code
 		      /// int count=0;
 		      /// for(Graph::EdgeIt e(g); e!=INVALID; ++e) ++count;
 		      ///\endcode
 		      class EdgeIt : public Edge {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        EdgeIt() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        EdgeIt(const EdgeIt& e) : Edge(e) { }
 		        /// Initialize the iterator to be invalid.
 		        /// Initialize the iterator to be invalid.
 		        ///
 		        EdgeIt(Invalid) { }
 		        /// This constructor sets the iterator to the first edge.
 		        /// This constructor sets the iterator to the first edge.
 		        EdgeIt(const Graph&) { }
 		        /// Edge -> EdgeIt conversion
 		        /// Sets the iterator to the value of the trivial iterator.
 		        /// This feature necessitates that each time we
 		        /// iterate the edge-set, the iteration order is the
 		        /// same.
 		        EdgeIt(const Graph&, const Edge&) { }
 		        /// Next edge
 		        /// Assign the iterator to the next edge.
 		        EdgeIt& operator++() { return *this; }
 		      };
 		      /// \brief This iterator goes trough the incident undirected
 		      /// arcs of a node.
 		      ///
 		      /// This iterator goes trough the incident edges
 		      /// of a certain node of a graph. You should assume that the
 		      /// loop arcs will be iterated twice.
 		      ///
 		      /// Its usage is quite simple, for example you can compute the
 		      /// degree (i.e. count the number of incident arcs of a node \c n
 		      /// in graph \c g of type \c Graph as follows.
 		      ///
 		      ///\code
 		      /// int count=0;
 		      /// for(Graph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count;
 		      ///\endcode
 		      class IncEdgeIt : public Edge {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        IncEdgeIt() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        IncEdgeIt(const IncEdgeIt& e) : Edge(e) { }
 		        /// Initialize the iterator to be invalid.
 		        /// Initialize the iterator to be invalid.
 		        ///
 		        IncEdgeIt(Invalid) { }
 		        /// This constructor sets the iterator to first incident arc.
 		        /// This constructor set the iterator to the first incident arc of
 		        /// the node.
 		        IncEdgeIt(const Graph&, const Node&) { }
 		        /// Edge -> IncEdgeIt conversion
 		        /// Sets the iterator to the value of the trivial iterator \c e.
 		        /// This feature necessitates that each time we
 		        /// iterate the arc-set, the iteration order is the same.
 		        IncEdgeIt(const Graph&, const Edge&) { }
 		        /// Next incident arc
 		        /// Assign the iterator to the next incident arc
 		        /// of the corresponding node.
 		        IncEdgeIt& operator++() { return *this; }
 		      };
 		      /// The directed arc type.
 		      /// The directed arc type. It can be converted to the
 		      /// edge or it should be inherited from the undirected
 		      /// arc.
 		      class Arc : public Edge {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        Arc() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        Arc(const Arc& e) : Edge(e) { }
 		        /// Initialize the iterator to be invalid.
 		        /// Initialize the iterator to be invalid.
 		        ///
 		        Arc(Invalid) { }
 		        /// Equality operator
 		        /// Two iterators are equal if and only if they point to the
 		        /// same object or both are invalid.
 		        bool operator==(Arc) const { return true; }
 		        /// Inequality operator
 		        /// \sa operator==(Arc n)
 		        ///
 		        bool operator!=(Arc) const { return true; }
 		        /// Artificial ordering operator.
 		        /// To allow the use of graph descriptors as key type in std::map or
 		        /// similar associative container we require this.
 		        ///
 		        /// \note This operator only have to define some strict ordering of
 		        /// the items; this order has nothing to do with the iteration
 		        /// ordering of the items.
 		        bool operator<(Arc) const { return false; }
 		      };
 		      /// This iterator goes through each directed arc.
 		      /// This iterator goes through each arc of a graph.
 		      /// Its usage is quite simple, for example you can count the number
 		      /// of arcs in a graph \c g of type \c Graph as follows:
 		      ///\code
 		      /// int count=0;
 		      /// for(Graph::ArcIt e(g); e!=INVALID; ++e) ++count;
 		      ///\endcode
 		      class ArcIt : public Arc {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        ArcIt() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        ArcIt(const ArcIt& e) : Arc(e) { }
 		        /// Initialize the iterator to be invalid.
 		        /// Initialize the iterator to be invalid.
 		        ///
 		        ArcIt(Invalid) { }
 		        /// This constructor sets the iterator to the first arc.
 		        /// This constructor sets the iterator to the first arc of \c g.
 		        ///@param g the graph
 		        ArcIt(const Graph &g) { ignore_unused_variable_warning(g); }
 		        /// Arc -> ArcIt conversion
 		        /// Sets the iterator to the value of the trivial iterator \c e.
 		        /// This feature necessitates that each time we
 		        /// iterate the arc-set, the iteration order is the same.
 		        ArcIt(const Graph&, const Arc&) { }
 		        ///Next arc
 		        /// Assign the iterator to the next arc.
 		        ArcIt& operator++() { return *this; }
 		      };
 		      /// This iterator goes trough the outgoing directed arcs of a node.
 		      /// This iterator goes trough the \e outgoing arcs of a certain node
 		      /// of a graph.
 		      /// Its usage is quite simple, for example you can count the number
 		      /// of outgoing arcs of a node \c n
 		      /// in graph \c g of type \c Graph as follows.
 		      ///\code
 		      /// int count=0;
 		      /// for (Graph::OutArcIt e(g, n); e!=INVALID; ++e) ++count;
 		      ///\endcode
 		      class OutArcIt : public Arc {
 		      public:
 		        /// Default constructor

lemon/concepts/graph_components.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-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.
+		 *
 		 */
 		///\ingroup graph_concepts
 		///\file
 		///\brief The concept of graph components.
 		#ifndef LEMON_CONCEPT_GRAPH_COMPONENTS_H
 		#define LEMON_CONCEPT_GRAPH_COMPONENTS_H
-		#include <lemon/bits/invalid.h>
+		#include <lemon/core.h>
 		#include <lemon/concepts/maps.h>
 		#include <lemon/bits/alteration_notifier.h>
 		namespace lemon {
 		  namespace concepts {
 		    /// \brief Skeleton class for graph Node and Arc types
 		    ///
 		    /// This class describes the interface of Node and Arc (and Edge
 		    /// in undirected graphs) subtypes of graph types.
 		    ///
 		    /// \note This class is a template class so that we can use it to
 		    /// create graph skeleton classes. The reason for this is than Node
 		    /// and Arc types should \em not derive from the same base class.
 		    /// For Node you should instantiate it with character 'n' and for Arc
 		    /// with 'a'.
 		#ifndef DOXYGEN
 		    template <char _selector = '0'>
 		#endif
 		    class GraphItem {
 		    public:
 		      /// \brief Default constructor.
 		      ///
 		      /// \warning The default constructor is not required to set
 		      /// the item to some well-defined value. So you should consider it
 		      /// as uninitialized.
 		      GraphItem() {}
 		      /// \brief Copy constructor.
 		      ///
 		      /// Copy constructor.
 		      ///
 		      GraphItem(const GraphItem &) {}
 		      /// \brief Invalid constructor \& conversion.
 		      ///
 		      /// This constructor initializes the item to be invalid.
 		      /// \sa Invalid for more details.
 		      GraphItem(Invalid) {}
 		      /// \brief Assign operator for nodes.
 		      ///
 		      /// The nodes are assignable.
 		      ///
 		      GraphItem& operator=(GraphItem const&) { return *this; }
 		      /// \brief Equality operator.
 		      ///
 		      /// Two iterators are equal if and only if they represents the
 		      /// same node in the graph or both are invalid.
 		      bool operator==(GraphItem) const { return false; }
 		      /// \brief Inequality operator.
 		      ///
 		      /// \sa operator==(const Node& n)
 		      ///
 		      bool operator!=(GraphItem) const { return false; }
 		      /// \brief Artificial ordering operator.
 		      ///
 		      /// To allow the use of graph descriptors as key type in std::map or
 		      /// similar associative container we require this.
 		      ///
 		      /// \note This operator only have to define some strict ordering of
 		      /// the items; this order has nothing to do with the iteration
 		      /// ordering of the items.
 		      bool operator<(GraphItem) const { return false; }
 		      template<typename _GraphItem>
 		      struct Constraints {
 		        void constraints() {
 		          _GraphItem i1;
 		          _GraphItem i2 = i1;
 		          _GraphItem i3 = INVALID;
 		          i1 = i2 = i3;
 		          bool b;
 		          //          b = (ia == ib) && (ia != ib) && (ia < ib);
 		          b = (ia == ib) && (ia != ib);
 		          b = (ia == INVALID) && (ib != INVALID);
 		          b = (ia < ib);
+		        }
 		        const _GraphItem &ia;
 		        const _GraphItem &ib;
 		      };
 		    };
 		    /// \brief An empty base directed graph class.
 		    ///
 		    /// This class provides the minimal set of features needed for a
 		    /// directed graph structure. All digraph concepts have to be
 		    /// conform to this base directed graph. It just provides types
 		    /// for nodes and arcs and functions to get the source and the
 		    /// target of the arcs.
 		    class BaseDigraphComponent {
 		    public:
 		      typedef BaseDigraphComponent Digraph;
 		      /// \brief Node class of the digraph.
 		      ///
 		      /// This class represents the Nodes of the digraph.
 		      ///
 		      typedef GraphItem<'n'> Node;
 		      /// \brief Arc class of the digraph.
 		      ///
 		      /// This class represents the Arcs of the digraph.
 		      ///
 		      typedef GraphItem<'e'> Arc;
 		      /// \brief Gives back the target node of an arc.
 		      ///
 		      /// Gives back the target node of an arc.
 		      ///
 		      Node target(const Arc&) const { return INVALID;}
 		      /// \brief Gives back the source node of an arc.
 		      ///
 		      /// Gives back the source node of an arc.
 		      ///
 		      Node source(const Arc&) const { return INVALID;}
 		      /// \brief Gives back the opposite node on the given arc.
 		      ///
 		      /// Gives back the opposite node on the given arc.
 		      Node oppositeNode(const Node&, const Arc&) const {
 		        return INVALID;
+		      }
 		      template <typename _Digraph>
 		      struct Constraints {
 		        typedef typename _Digraph::Node Node;
 		        typedef typename _Digraph::Arc Arc;
 		        void constraints() {
 		          checkConcept<GraphItem<'n'>, Node>();
 		          checkConcept<GraphItem<'a'>, Arc>();
+		          {
 		            Node n;
 		            Arc e(INVALID);
 		            n = digraph.source(e);
 		            n = digraph.target(e);
 		            n = digraph.oppositeNode(n, e);
+		          }
+		        }
 		        const _Digraph& digraph;
 		      };
 		    };
 		    /// \brief An empty base undirected graph class.
 		    ///
 		    /// This class provides the minimal set of features needed for an
 		    /// undirected graph structure. All undirected graph concepts have
 		    /// to be conform to this base graph. It just provides types for
 		    /// nodes, arcs and edges and functions to get the
 		    /// source and the target of the arcs and edges,
 		    /// conversion from arcs to edges and function to get
 		    /// both direction of the edges.
 		    class BaseGraphComponent : public BaseDigraphComponent {
 		    public:
 		      typedef BaseDigraphComponent::Node Node;
 		      typedef BaseDigraphComponent::Arc Arc;
 		      /// \brief Undirected arc class of the graph.
 		      ///
 		      /// This class represents the edges of the graph.
 		      /// The undirected graphs can be used as a directed graph which
 		      /// for each arc contains the opposite arc too so the graph is
 		      /// bidirected. The edge represents two opposite
 		      /// directed arcs.
 		      class Edge : public GraphItem<'u'> {
 		      public:
 		        typedef GraphItem<'u'> Parent;
 		        /// \brief Default constructor.
 		        ///
 		        /// \warning The default constructor is not required to set
 		        /// the item to some well-defined value. So you should consider it
 		        /// as uninitialized.
 		        Edge() {}
 		        /// \brief Copy constructor.
 		        ///
 		        /// Copy constructor.
 		        ///
 		        Edge(const Edge &) : Parent() {}
 		        /// \brief Invalid constructor \& conversion.
 		        ///
 		        /// This constructor initializes the item to be invalid.
 		        /// \sa Invalid for more details.
 		        Edge(Invalid) {}
 		        /// \brief Converter from arc to edge.
 		        ///
 		        /// Besides the core graph item functionality each arc should
 		        /// be convertible to the represented edge.
 		        Edge(const Arc&) {}
 		        /// \brief Assign arc to edge.
 		        ///
 		        /// Besides the core graph item functionality each arc should
 		        /// be convertible to the represented edge.
 		        Edge& operator=(const Arc&) { return *this; }
 		      };
 		      /// \brief Returns the direction of the arc.
 		      ///
 		      /// Returns the direction of the arc. Each arc represents an
 		      /// edge with a direction. It gives back the
 		      /// direction.
 		      bool direction(const Arc&) const { return true; }
 		      /// \brief Returns the directed arc.
 		      ///
 		      /// Returns the directed arc from its direction and the
 		      /// represented edge.
 		      Arc direct(const Edge&, bool) const { return INVALID;}
 		      /// \brief Returns the directed arc.
 		      ///
 		      /// Returns the directed arc from its source and the
 		      /// represented edge.
 		      Arc direct(const Edge&, const Node&) const { return INVALID;}
 		      /// \brief Returns the opposite arc.
 		      ///
 		      /// Returns the opposite arc. It is the arc representing the
 		      /// same edge and has opposite direction.
 		      Arc oppositeArc(const Arc&) const { return INVALID;}
 		      /// \brief Gives back one ending of an edge.
 		      ///
 		      /// Gives back one ending of an edge.
 		      Node u(const Edge&) const { return INVALID;}
 		      /// \brief Gives back the other ending of an edge.
 		      ///
 		      /// Gives back the other ending of an edge.
 		      Node v(const Edge&) const { return INVALID;}
 		      template <typename _Graph>
 		      struct Constraints {
 		        typedef typename _Graph::Node Node;
 		        typedef typename _Graph::Arc Arc;
 		        typedef typename _Graph::Edge Edge;
 		        void constraints() {
 		          checkConcept<BaseDigraphComponent, _Graph>();
 		          checkConcept<GraphItem<'u'>, Edge>();
+		          {
 		            Node n;
 		            Edge ue(INVALID);
 		            Arc e;
 		            n = graph.u(ue);
 		            n = graph.v(ue);
 		            e = graph.direct(ue, true);
 		            e = graph.direct(ue, n);
 		            e = graph.oppositeArc(e);
 		            ue = e;
 		            bool d = graph.direction(e);
 		            ignore_unused_variable_warning(d);
+		          }
+		        }
 		        const _Graph& graph;
 		      };
 		    };
 		    /// \brief An empty idable base digraph class.
 		    ///
 		    /// This class provides beside the core digraph features
 		    /// core id functions for the digraph structure.
 		    /// The most of the base digraphs should be conform to this concept.
 		    /// The id's are unique and immutable.
 		    template <typename _Base = BaseDigraphComponent>
 		    class IDableDigraphComponent : public _Base {
 		    public:
 		      typedef _Base Base;
 		      typedef typename Base::Node Node;
 		      typedef typename Base::Arc Arc;
 		      /// \brief Gives back an unique integer id for the Node.
 		      ///
 		      /// Gives back an unique integer id for the Node.
 		      ///
 		      int id(const Node&) const { return -1;}
 		      /// \brief Gives back the node by the unique id.
 		      ///
 		      /// Gives back the node by the unique id.
 		      /// If the digraph does not contain node with the given id
 		      /// then the result of the function is undetermined.
 		      Node nodeFromId(int) const { return INVALID;}
 		      /// \brief Gives back an unique integer id for the Arc.
 		      ///
 		      /// Gives back an unique integer id for the Arc.
 		      ///
 		      int id(const Arc&) const { return -1;}
 		      /// \brief Gives back the arc by the unique id.
 		      ///
 		      /// Gives back the arc by the unique id.
 		      /// If the digraph does not contain arc with the given id
 		      /// then the result of the function is undetermined.
 		      Arc arcFromId(int) const { return INVALID;}
 		      /// \brief Gives back an integer greater or equal to the maximum
 		      /// Node id.
 		      ///
 		      /// Gives back an integer greater or equal to the maximum Node
 		      /// id.
 		      int maxNodeId() const { return -1;}
 		      /// \brief Gives back an integer greater or equal to the maximum
 		      /// Arc id.
 		      ///
 		      /// Gives back an integer greater or equal to the maximum Arc
 		      /// id.
 		      int maxArcId() const { return -1;}
 		      template <typename _Digraph>
 		      struct Constraints {
 		        void constraints() {
 		          checkConcept<Base, _Digraph >();
 		          typename _Digraph::Node node;
 		          int nid = digraph.id(node);
 		          nid = digraph.id(node);
 		          node = digraph.nodeFromId(nid);
 		          typename _Digraph::Arc arc;
 		          int eid = digraph.id(arc);
 		          eid = digraph.id(arc);
 		          arc = digraph.arcFromId(eid);
 		          nid = digraph.maxNodeId();
 		          ignore_unused_variable_warning(nid);
 		          eid = digraph.maxArcId();
 		          ignore_unused_variable_warning(eid);
+		        }
 		        const _Digraph& digraph;
 		      };
 		    };
 		    /// \brief An empty idable base undirected graph class.
 		    ///
 		    /// This class provides beside the core undirected graph features
 		    /// core id functions for the undirected graph structure.  The
 		    /// most of the base undirected graphs should be conform to this
 		    /// concept.  The id's are unique and immutable.
 		    template <typename _Base = BaseGraphComponent>
 		    class IDableGraphComponent : public IDableDigraphComponent<_Base> {
 		    public:
 		      typedef _Base Base;
 		      typedef typename Base::Edge Edge;
 		      using IDableDigraphComponent<_Base>::id;
 		      /// \brief Gives back an unique integer id for the Edge.
 		      ///
 		      /// Gives back an unique integer id for the Edge.
 		      ///
 		      int id(const Edge&) const { return -1;}
 		      /// \brief Gives back the edge by the unique id.
 		      ///
 		      /// Gives back the edge by the unique id.  If the
 		      /// graph does not contain arc with the given id then the
 		      /// result of the function is undetermined.
 		      Edge edgeFromId(int) const { return INVALID;}
 		      /// \brief Gives back an integer greater or equal to the maximum
 		      /// Edge id.
 		      ///
 		      /// Gives back an integer greater or equal to the maximum Edge
 		      /// id.
 		      int maxEdgeId() const { return -1;}
 		      template <typename _Graph>
 		      struct Constraints {
 		        void constraints() {
 		          checkConcept<Base, _Graph >();
 		          checkConcept<IDableDigraphComponent<Base>, _Graph >();

lemon/concepts/heap.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		///\ingroup concept
 		///\file
 		///\brief The concept of heaps.
 		#ifndef LEMON_CONCEPT_HEAP_H
 		#define LEMON_CONCEPT_HEAP_H
-		#include <lemon/bits/invalid.h>
+		#include <lemon/core.h>
 		namespace lemon {
 		  namespace concepts {
 		    /// \addtogroup concept
 		    /// @{
 		    /// \brief The heap concept.
 		    ///
 		    /// Concept class describing the main interface of heaps.
 		    template <typename Priority, typename ItemIntMap>
 		    class Heap {
 		    public:
 		      /// Type of the items stored in the heap.
 		      typedef typename ItemIntMap::Key Item;
 		      /// Type of the priorities.
 		      typedef Priority Prio;
 		      /// \brief Type to represent the states of the items.
 		      ///
 		      /// Each item has a state associated to it. It can be "in heap",
 		      /// "pre heap" or "post heap". The later two are indifferent
 		      /// from the point of view of the heap, but may be useful for
 		      /// the user.
 		      ///
 		      /// The \c ItemIntMap must be initialized in such a way, that it
 		      /// assigns \c PRE_HEAP (<tt>-1</tt>) to every item.
 		      enum State {
 		        IN_HEAP = 0,
 		        PRE_HEAP = -1,
 		        POST_HEAP = -2
 		      };
 		      /// \brief The constructor.
 		      ///
 		      /// The constructor.
 		      /// \param map A map that assigns \c int values to keys of type
 		      /// \c Item. It is used internally by the heap implementations to
 		      /// handle the cross references. The assigned value must be
 		      /// \c PRE_HEAP (<tt>-1</tt>) for every item.
 		      explicit Heap(ItemIntMap &map) {}
 		      /// \brief The number of items stored in the heap.
 		      ///
 		      /// Returns the number of items stored in the heap.
 		      int size() const { return 0; }
 		      /// \brief Checks if the heap is empty.
 		      ///
 		      /// Returns \c true if the heap is empty.
 		      bool empty() const { return false; }
 		      /// \brief Makes the heap empty.
 		      ///
 		      /// Makes the heap empty.
 		      void clear();
 		      /// \brief Inserts an item into the heap with the given priority.
 		      ///
 		      /// Inserts the given item into the heap with the given priority.
 		      /// \param i The item to insert.
 		      /// \param p The priority of the item.
 		      void push(const Item &i, const Prio &p) {}
 		      /// \brief Returns the item having minimum priority.
 		      ///
 		      /// Returns the item having minimum priority.
 		      /// \pre The heap must be non-empty.
 		      Item top() const {}
 		      /// \brief The minimum priority.
 		      ///
 		      /// Returns the minimum priority.
 		      /// \pre The heap must be non-empty.
 		      Prio prio() const {}
 		      /// \brief Removes the item having minimum priority.
 		      ///
 		      /// Removes the item having minimum priority.
 		      /// \pre The heap must be non-empty.
 		      void pop() {}
 		      /// \brief Removes an item from the heap.
 		      ///
 		      /// Removes the given item from the heap if it is already stored.
 		      /// \param i The item to delete.
 		      void erase(const Item &i) {}
 		      /// \brief The priority of an item.
 		      ///
 		      /// Returns the priority of the given item.
 		      /// \pre \c i must be in the heap.
 		      /// \param i The item.
 		      Prio operator[](const Item &i) const {}
 		      /// \brief Sets the priority of an item or inserts it, if it is
 		      /// not stored in the heap.
 		      ///
 		      /// This method sets the priority of the given item if it is
 		      /// already stored in the heap.
 		      /// Otherwise it inserts the given item with the given priority.
 		      ///
 		      /// It may throw an \ref UnderflowPriorityException.
 		      /// \param i The item.
 		      /// \param p The priority.
 		      void set(const Item &i, const Prio &p) {}
 		      /// \brief Decreases the priority of an item to the given value.
 		      ///
 		      /// Decreases the priority of an item to the given value.
 		      /// \pre \c i must be stored in the heap with priority at least \c p.
 		      /// \param i The item.
 		      /// \param p The priority.
 		      void decrease(const Item &i, const Prio &p) {}
 		      /// \brief Increases the priority of an item to the given value.
 		      ///
 		      /// Increases the priority of an item to the given value.
 		      /// \pre \c i must be stored in the heap with priority at most \c p.
 		      /// \param i The item.
 		      /// \param p The priority.
 		      void increase(const Item &i, const Prio &p) {}
 		      /// \brief Returns if an item is in, has already been in, or has
 		      /// never been in the heap.
 		      ///
 		      /// This method returns \c PRE_HEAP if the given item has never
 		      /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
 		      /// and \c POST_HEAP otherwise.
 		      /// In the latter case it is possible that the item will get back
 		      /// to the heap again.
 		      /// \param i The item.
 		      State state(const Item &i) const {}
 		      /// \brief Sets the state of an item in the heap.
 		      ///
 		      /// Sets the state of the given item in the heap. It can be used
 		      /// to manually clear the heap when it is important to achive the
 		      /// better time complexity.
 		      /// \param i The item.
 		      /// \param st The state. It should not be \c IN_HEAP.
 		      void state(const Item& i, State st) {}
 		      template <typename _Heap>
 		      struct Constraints {
 		      public:
 		        void constraints() {
 		          typedef typename _Heap::Item OwnItem;
 		          typedef typename _Heap::Prio OwnPrio;
 		          typedef typename _Heap::State OwnState;
 		          Item item;
 		          Prio prio;
 		          item=Item();
 		          prio=Prio();
 		          ignore_unused_variable_warning(item);
 		          ignore_unused_variable_warning(prio);
 		          OwnItem own_item;
 		          OwnPrio own_prio;
 		          OwnState own_state;
 		          own_item=Item();
 		          own_prio=Prio();
 		          ignore_unused_variable_warning(own_item);
 		          ignore_unused_variable_warning(own_prio);
 		          ignore_unused_variable_warning(own_state);
 		          _Heap heap1(map);
 		          _Heap heap2 = heap1;
 		          ignore_unused_variable_warning(heap1);
 		          ignore_unused_variable_warning(heap2);
 		          int s = heap.size();
 		          ignore_unused_variable_warning(s);
 		          bool e = heap.empty();
 		          ignore_unused_variable_warning(e);
 		          prio = heap.prio();
 		          item = heap.top();
 		          prio = heap[item];
 		          own_prio = heap.prio();
 		          own_item = heap.top();
 		          own_prio = heap[own_item];
 		          heap.push(item, prio);
 		          heap.push(own_item, own_prio);
 		          heap.pop();
 		          heap.set(item, prio);
 		          heap.decrease(item, prio);
 		          heap.increase(item, prio);
 		          heap.set(own_item, own_prio);
 		          heap.decrease(own_item, own_prio);
 		          heap.increase(own_item, own_prio);
 		          heap.erase(item);
 		          heap.erase(own_item);
 		          heap.clear();
 		          own_state = heap.state(own_item);
 		          heap.state(own_item, own_state);
 		          own_state = _Heap::PRE_HEAP;
 		          own_state = _Heap::IN_HEAP;
 		          own_state = _Heap::POST_HEAP;
+		        }
 		        _Heap& heap;
 		        ItemIntMap& map;
 		      };
 		    };
 		    /// @}
 		  } // namespace lemon
+		}
 		#endif // LEMON_CONCEPT_PATH_H

lemon/concepts/maps.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_CONCEPT_MAPS_H
 		#define LEMON_CONCEPT_MAPS_H
-		#include <lemon/bits/utility.h>
+		#include <lemon/core.h>
 		#include <lemon/concept_check.h>
 		///\ingroup concept
 		///\file
 		///\brief The concept of maps.
 		namespace lemon {
 		  namespace concepts {
 		    /// \addtogroup concept
 		    /// @{
 		    /// Readable map concept
 		    /// Readable map concept.
 		    ///
 		    template<typename K, typename T>
 		    class ReadMap
+		    {
 		    public:
 		      /// The key type of the map.
 		      typedef K Key;
 		      /// \brief The value type of the map.
 		      /// (The type of objects associated with the keys).
 		      typedef T Value;
 		      /// Returns the value associated with the given key.
 		      Value operator[](const Key &) const {
 		        return *static_cast<Value *>(0);
+		      }
 		      template<typename _ReadMap>
 		      struct Constraints {
 		        void constraints() {
 		          Value val = m[key];
 		          val = m[key];
 		          typename _ReadMap::Value own_val = m[own_key];
 		          own_val = m[own_key];
 		          ignore_unused_variable_warning(key);
 		          ignore_unused_variable_warning(val);
 		          ignore_unused_variable_warning(own_key);
 		          ignore_unused_variable_warning(own_val);
+		        }
 		        const Key& key;
 		        const typename _ReadMap::Key& own_key;
 		        const _ReadMap& m;
 		      };
 		    };
 		    /// Writable map concept
 		    /// Writable map concept.
 		    ///
 		    template<typename K, typename T>
 		    class WriteMap
+		    {
 		    public:
 		      /// The key type of the map.
 		      typedef K Key;
 		      /// \brief The value type of the map.
 		      /// (The type of objects associated with the keys).
 		      typedef T Value;
 		      /// Sets the value associated with the given key.
 		      void set(const Key &, const Value &) {}
 		      /// Default constructor.
 		      WriteMap() {}
 		      template <typename _WriteMap>
 		      struct Constraints {
 		        void constraints() {
 		          m.set(key, val);
 		          m.set(own_key, own_val);
 		          ignore_unused_variable_warning(key);
 		          ignore_unused_variable_warning(val);
 		          ignore_unused_variable_warning(own_key);
 		          ignore_unused_variable_warning(own_val);
+		        }
 		        const Key& key;
 		        const Value& val;
 		        const typename _WriteMap::Key& own_key;
 		        const typename _WriteMap::Value& own_val;
 		        _WriteMap& m;
 		      };
 		    };
 		    /// Read/writable map concept
 		    /// Read/writable map concept.
 		    ///
 		    template<typename K, typename T>
 		    class ReadWriteMap : public ReadMap<K,T>,
 		                         public WriteMap<K,T>
+		    {
 		    public:
 		      /// The key type of the map.
 		      typedef K Key;
 		      /// \brief The value type of the map.
 		      /// (The type of objects associated with the keys).
 		      typedef T Value;
 		      /// Returns the value associated with the given key.
 		      Value operator[](const Key &) const {
 		        return *static_cast<Value *>(0);
+		      }
 		      /// Sets the value associated with the given key.
 		      void set(const Key &, const Value &) {}
 		      template<typename _ReadWriteMap>
 		      struct Constraints {
 		        void constraints() {
 		          checkConcept<ReadMap<K, T>, _ReadWriteMap >();
 		          checkConcept<WriteMap<K, T>, _ReadWriteMap >();
+		        }
 		      };
 		    };
 		    /// Dereferable map concept
 		    /// Dereferable map concept.
 		    ///
 		    template<typename K, typename T, typename R, typename CR>
 		    class ReferenceMap : public ReadWriteMap<K,T>
+		    {
 		    public:
 		      /// Tag for reference maps.
 		      typedef True ReferenceMapTag;
 		      /// The key type of the map.
 		      typedef K Key;
 		      /// \brief The value type of the map.
 		      /// (The type of objects associated with the keys).
 		      typedef T Value;
 		      /// The reference type of the map.
 		      typedef R Reference;
 		      /// The const reference type of the map.
 		      typedef CR ConstReference;
 		    public:
 		      /// Returns a reference to the value associated with the given key.
 		      Reference operator[](const Key &) {
 		        return *static_cast<Value *>(0);
+		      }
 		      /// Returns a const reference to the value associated with the given key.
 		      ConstReference operator[](const Key &) const {
 		        return *static_cast<Value *>(0);
+		      }
 		      /// Sets the value associated with the given key.
 		      void set(const Key &k,const Value &t) { operator[](k)=t; }
 		      template<typename _ReferenceMap>
 		      struct Constraints {
 		        void constraints() {
 		          checkConcept<ReadWriteMap<K, T>, _ReferenceMap >();
 		          ref = m[key];
 		          m[key] = val;
 		          m[key] = ref;
 		          m[key] = cref;
 		          own_ref = m[own_key];
 		          m[own_key] = own_val;
 		          m[own_key] = own_ref;
 		          m[own_key] = own_cref;
 		          m[key] = m[own_key];
 		          m[own_key] = m[key];
+		        }
 		        const Key& key;
 		        Value& val;
 		        Reference ref;
 		        ConstReference cref;
 		        const typename _ReferenceMap::Key& own_key;
 		        typename _ReferenceMap::Value& own_val;
 		        typename _ReferenceMap::Reference own_ref;
 		        typename _ReferenceMap::ConstReference own_cref;
 		        _ReferenceMap& m;
 		      };
 		    };
 		    // @}
 		  } //namespace concepts
 		} //namespace lemon
 		#endif // LEMON_CONCEPT_MAPS_H

lemon/concepts/path.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		///\ingroup concept
 		///\file
 		///\brief Classes for representing paths in digraphs.
 		///
 		///\todo Iterators have obsolete style
 		#ifndef LEMON_CONCEPT_PATH_H
 		#define LEMON_CONCEPT_PATH_H
 		#include <lemon/bits/invalid.h>
 		#include <lemon/bits/utility.h>
 		#include <lemon/core.h>
 		#include <lemon/concept_check.h>
 		namespace lemon {
 		  namespace concepts {
 		    /// \addtogroup concept
 		    /// @{
 		    /// \brief A skeleton structure for representing directed paths in
 		    /// a digraph.
 		    ///
 		    /// A skeleton structure for representing directed paths in a
 		    /// digraph.
 		    /// \tparam _Digraph The digraph type in which the path is.
 		    ///
 		    /// In a sense, the path can be treated as a list of arcs. The
 		    /// lemon path type stores just this list. As a consequence it
 		    /// cannot enumerate the nodes in the path and the zero length
 		    /// paths cannot store the source.
 		    ///
 		    template <typename _Digraph>
 		    class Path {
 		    public:
 		      /// Type of the underlying digraph.
 		      typedef _Digraph Digraph;
 		      /// Arc type of the underlying digraph.
 		      typedef typename Digraph::Arc Arc;
 		      class ArcIt;
 		      /// \brief Default constructor
 		      Path() {}
 		      /// \brief Template constructor
 		      template <typename CPath>
 		      Path(const CPath& cpath) {}
 		      /// \brief Template assigment
 		      template <typename CPath>
 		      Path& operator=(const CPath& cpath) {}
 		      /// Length of the path ie. the number of arcs in the path.
 		      int length() const { return 0;}
 		      /// Returns whether the path is empty.
 		      bool empty() const { return true;}
 		      /// Resets the path to an empty path.
 		      void clear() {}
 		      /// \brief Lemon style iterator for path arcs
 		      ///
 		      /// This class is used to iterate on the arcs of the paths.
 		      class ArcIt {
 		      public:
 		        /// Default constructor
 		        ArcIt() {}
 		        /// Invalid constructor
 		        ArcIt(Invalid) {}
 		        /// Constructor for first arc
 		        ArcIt(const Path &) {}
 		        /// Conversion to Arc
 		        operator Arc() const { return INVALID; }
 		        /// Next arc
 		        ArcIt& operator++() {return *this;}
 		        /// Comparison operator
 		        bool operator==(const ArcIt&) const {return true;}
 		        /// Comparison operator
 		        bool operator!=(const ArcIt&) const {return true;}
 		        /// Comparison operator
 		        bool operator<(const ArcIt&) const {return false;}
 		      };
 		      template <typename _Path>
 		      struct Constraints {
 		        void constraints() {
 		          Path<Digraph> pc;
 		          _Path p, pp(pc);
 		          int l = p.length();
 		          int e = p.empty();
 		          p.clear();
 		          p = pc;
 		          typename _Path::ArcIt id, ii(INVALID), i(p);
 		          ++i;
 		          typename Digraph::Arc ed = i;
 		          e = (i == ii);
 		          e = (i != ii);
 		          e = (i < ii);
 		          ignore_unused_variable_warning(l);
 		          ignore_unused_variable_warning(pp);
 		          ignore_unused_variable_warning(e);
 		          ignore_unused_variable_warning(id);
 		          ignore_unused_variable_warning(ii);
 		          ignore_unused_variable_warning(ed);
+		        }
 		      };
 		    };
 		    namespace _path_bits {
 		      template <typename _Digraph, typename _Path, typename RevPathTag = void>
 		      struct PathDumperConstraints {
 		        void constraints() {
 		          int l = p.length();
 		          int e = p.empty();
 		          typename _Path::ArcIt id, i(p);
 		          ++i;
 		          typename _Digraph::Arc ed = i;
 		          e = (i == INVALID);
 		          e = (i != INVALID);
 		          ignore_unused_variable_warning(l);
 		          ignore_unused_variable_warning(e);
 		          ignore_unused_variable_warning(id);
 		          ignore_unused_variable_warning(ed);
+		        }
 		        _Path& p;
 		      };
 		      template <typename _Digraph, typename _Path>
 		      struct PathDumperConstraints<
 		        _Digraph, _Path,
 		        typename enable_if<typename _Path::RevPathTag, void>::type
 		      > {
 		        void constraints() {
 		          int l = p.length();
 		          int e = p.empty();
 		          typename _Path::RevArcIt id, i(p);
 		          ++i;
 		          typename _Digraph::Arc ed = i;
 		          e = (i == INVALID);
 		          e = (i != INVALID);
 		          ignore_unused_variable_warning(l);
 		          ignore_unused_variable_warning(e);
 		          ignore_unused_variable_warning(id);
 		          ignore_unused_variable_warning(ed);
+		        }
 		        _Path& p;
 		      };
+		    }
 		    /// \brief A skeleton structure for path dumpers.
 		    ///
 		    /// A skeleton structure for path dumpers. The path dumpers are
 		    /// the generalization of the paths. The path dumpers can
 		    /// enumerate the arcs of the path wheter in forward or in
 		    /// backward order.  In most time these classes are not used
 		    /// directly rather it used to assign a dumped class to a real
 		    /// path type.
 		    ///
 		    /// The main purpose of this concept is that the shortest path
 		    /// algorithms can enumerate easily the arcs in reverse order.
 		    /// If we would like to give back a real path from these
 		    /// algorithms then we should create a temporarly path object. In
 		    /// Lemon such algorithms gives back a path dumper what can
 		    /// assigned to a real path and the dumpers can be implemented as
 		    /// an adaptor class to the predecessor map.
 		    /// \tparam _Digraph  The digraph type in which the path is.
 		    ///
 		    /// The paths can be constructed from any path type by a
 		    /// template constructor or a template assignment operator.
 		    ///
 		    template <typename _Digraph>
 		    class PathDumper {
 		    public:
 		      /// Type of the underlying digraph.
 		      typedef _Digraph Digraph;
 		      /// Arc type of the underlying digraph.
 		      typedef typename Digraph::Arc Arc;
 		      /// Length of the path ie. the number of arcs in the path.
 		      int length() const { return 0;}
 		      /// Returns whether the path is empty.
 		      bool empty() const { return true;}
 		      /// \brief Forward or reverse dumping
 		      ///
 		      /// If the RevPathTag is defined and true then reverse dumping
 		      /// is provided in the path dumper. In this case instead of the
 		      /// ArcIt the RevArcIt iterator should be implemented in the
 		      /// dumper.
 		      typedef False RevPathTag;
 		      /// \brief Lemon style iterator for path arcs
 		      ///
 		      /// This class is used to iterate on the arcs of the paths.
 		      class ArcIt {
 		      public:
 		        /// Default constructor
 		        ArcIt() {}
 		        /// Invalid constructor
 		        ArcIt(Invalid) {}
 		        /// Constructor for first arc
 		        ArcIt(const PathDumper&) {}
 		        /// Conversion to Arc
 		        operator Arc() const { return INVALID; }
 		        /// Next arc
 		        ArcIt& operator++() {return *this;}
 		        /// Comparison operator
 		        bool operator==(const ArcIt&) const {return true;}
 		        /// Comparison operator
 		        bool operator!=(const ArcIt&) const {return true;}
 		        /// Comparison operator
 		        bool operator<(const ArcIt&) const {return false;}
 		      };
 		      /// \brief Lemon style iterator for path arcs
 		      ///
 		      /// This class is used to iterate on the arcs of the paths in
 		      /// reverse direction.
 		      class RevArcIt {
 		      public:
 		        /// Default constructor
 		        RevArcIt() {}
 		        /// Invalid constructor
 		        RevArcIt(Invalid) {}
 		        /// Constructor for first arc
 		        RevArcIt(const PathDumper &) {}
 		        /// Conversion to Arc
 		        operator Arc() const { return INVALID; }
 		        /// Next arc
 		        RevArcIt& operator++() {return *this;}
 		        /// Comparison operator
 		        bool operator==(const RevArcIt&) const {return true;}
 		        /// Comparison operator
 		        bool operator!=(const RevArcIt&) const {return true;}
 		        /// Comparison operator
 		        bool operator<(const RevArcIt&) const {return false;}
 		      };
 		      template <typename _Path>
 		      struct Constraints {
 		        void constraints() {
 		          function_requires<_path_bits::
 		            PathDumperConstraints<Digraph, _Path> >();
+		        }
 		      };
 		    };
 		    ///@}
+		  }
 		} // namespace lemon
 		#endif // LEMON_CONCEPT_PATH_H

lemon/dfs.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_DFS_H
 		#define LEMON_DFS_H
 		///\ingroup search
 		///\file
 		///\brief Dfs algorithm.
 		#include <lemon/list_graph.h>
 		#include <lemon/graph_utils.h>
 		#include <lemon/bits/path_dump.h>
-		#include <lemon/bits/invalid.h>
+		#include <lemon/core.h>
 		#include <lemon/error.h>
 		#include <lemon/maps.h>
 		#include <lemon/concept_check.h>
 		namespace lemon {
 		  ///Default traits class of Dfs class.
 		  ///Default traits class of Dfs class.
 		  ///\tparam GR Digraph type.
 		  template<class GR>
 		  struct DfsDefaultTraits
+		  {
 		    ///The digraph type the algorithm runs on.
 		    typedef GR Digraph;
 		    ///\brief The type of the map that stores the last
 		    ///arcs of the %DFS paths.
 		    ///
 		    ///The type of the map that stores the last
 		    ///arcs of the %DFS paths.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    ///
 		    typedef typename Digraph::template NodeMap<typename GR::Arc> PredMap;
 		    ///Instantiates a PredMap.
 		    ///This function instantiates a \ref PredMap.
 		    ///\param G is the digraph, to which we would like to define the PredMap.
 		    ///\todo The digraph alone may be insufficient to initialize
 		    static PredMap *createPredMap(const GR &G)
+		    {
 		      return new PredMap(G);
+		    }
 		    ///The type of the map that indicates which nodes are processed.
 		    ///The type of the map that indicates which nodes are processed.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    ///\todo named parameter to set this type, function to read and write.
 		    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
 		    ///Instantiates a ProcessedMap.
 		    ///This function instantiates a \ref ProcessedMap.
 		    ///\param g is the digraph, to which
 		    ///we would like to define the \ref ProcessedMap
 		#ifdef DOXYGEN
 		    static ProcessedMap *createProcessedMap(const GR &g)
 		#else
 		    static ProcessedMap *createProcessedMap(const GR &)
 		#endif
+		    {
 		      return new ProcessedMap();
+		    }
 		    ///The type of the map that indicates which nodes are reached.
 		    ///The type of the map that indicates which nodes are reached.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    ///\todo named parameter to set this type, function to read and write.
 		    typedef typename Digraph::template NodeMap<bool> ReachedMap;
 		    ///Instantiates a ReachedMap.
 		    ///This function instantiates a \ref ReachedMap.
 		    ///\param G is the digraph, to which
 		    ///we would like to define the \ref ReachedMap.
 		    static ReachedMap *createReachedMap(const GR &G)
+		    {
 		      return new ReachedMap(G);
+		    }
 		    ///The type of the map that stores the dists of the nodes.
 		    ///The type of the map that stores the dists of the nodes.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    ///
 		    typedef typename Digraph::template NodeMap<int> DistMap;
 		    ///Instantiates a DistMap.
 		    ///This function instantiates a \ref DistMap.
 		    ///\param G is the digraph, to which we would like to define
 		    ///the \ref DistMap
 		    static DistMap *createDistMap(const GR &G)
+		    {
 		      return new DistMap(G);
+		    }
 		  };
 		  ///%DFS algorithm class.
 		  ///\ingroup search
 		  ///This class provides an efficient implementation of the %DFS algorithm.
 		  ///
 		  ///\tparam GR The digraph type the algorithm runs on. The default value is
 		  ///\ref ListDigraph. The value of GR is not used directly by Dfs, it
 		  ///is only passed to \ref DfsDefaultTraits.
 		  ///\tparam TR Traits class to set various data types used by the algorithm.
 		  ///The default traits class is
 		  ///\ref DfsDefaultTraits "DfsDefaultTraits<GR>".
 		  ///See \ref DfsDefaultTraits for the documentation of
 		  ///a Dfs traits class.
 		#ifdef DOXYGEN
 		  template <typename GR,
 		            typename TR>
 		#else
 		  template <typename GR=ListDigraph,
 		            typename TR=DfsDefaultTraits<GR> >
 		#endif
 		  class Dfs {
 		  public:
 		    /**
 		     * \brief \ref Exception for uninitialized parameters.
+		     *
 		     * This error represents problems in the initialization
 		     * of the parameters of the algorithms.
 		     */
 		    class UninitializedParameter : public lemon::UninitializedParameter {
 		    public:
 		      virtual const char* what() const throw() {
 		        return "lemon::Dfs::UninitializedParameter";
+		      }
 		    };
 		    typedef TR Traits;
 		    ///The type of the underlying digraph.
 		    typedef typename TR::Digraph Digraph;
 		    ///\e
 		    typedef typename Digraph::Node Node;
 		    ///\e
 		    typedef typename Digraph::NodeIt NodeIt;
 		    ///\e
 		    typedef typename Digraph::Arc Arc;
 		    ///\e
 		    typedef typename Digraph::OutArcIt OutArcIt;
 		    ///\brief The type of the map that stores the last
 		    ///arcs of the %DFS paths.
 		    typedef typename TR::PredMap PredMap;
 		    ///The type of the map indicating which nodes are reached.
 		    typedef typename TR::ReachedMap ReachedMap;
 		    ///The type of the map indicating which nodes are processed.
 		    typedef typename TR::ProcessedMap ProcessedMap;
 		    ///The type of the map that stores the dists of the nodes.
 		    typedef typename TR::DistMap DistMap;
 		  private:
 		    /// Pointer to the underlying digraph.
 		    const Digraph *G;
 		    ///Pointer to the map of predecessors arcs.
 		    PredMap *_pred;
 		    ///Indicates if \ref _pred is locally allocated (\c true) or not.
 		    bool local_pred;
 		    ///Pointer to the map of distances.
 		    DistMap *_dist;
 		    ///Indicates if \ref _dist is locally allocated (\c true) or not.
 		    bool local_dist;
 		    ///Pointer to the map of reached status of the nodes.
 		    ReachedMap *_reached;
 		    ///Indicates if \ref _reached is locally allocated (\c true) or not.
 		    bool local_reached;
 		    ///Pointer to the map of processed status of the nodes.
 		    ProcessedMap *_processed;
 		    ///Indicates if \ref _processed is locally allocated (\c true) or not.
 		    bool local_processed;
 		    std::vector<typename Digraph::OutArcIt> _stack;
 		    int _stack_head;
 		    ///Creates the maps if necessary.
 		    ///\todo Better memory allocation (instead of new).
 		    void create_maps()
+		    {
 		      if(!_pred) {
 		        local_pred = true;
 		        _pred = Traits::createPredMap(*G);
+		      }
 		      if(!_dist) {
 		        local_dist = true;
 		        _dist = Traits::createDistMap(*G);
+		      }
 		      if(!_reached) {
 		        local_reached = true;
 		        _reached = Traits::createReachedMap(*G);
+		      }
 		      if(!_processed) {
 		        local_processed = true;
 		        _processed = Traits::createProcessedMap(*G);
+		      }
+		    }
 		  protected:
 		    Dfs() {}
 		  public:
 		    typedef Dfs Create;
 		    ///\name Named template parameters
 		    ///@{
 		    template <class T>
 		    struct DefPredMapTraits : public Traits {
 		      typedef T PredMap;
 		      static PredMap *createPredMap(const Digraph &G)
+		      {
 		        throw UninitializedParameter();
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///PredMap type
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting PredMap type
 		    ///
 		    template <class T>
 		    struct DefPredMap : public Dfs<Digraph, DefPredMapTraits<T> > {
 		      typedef Dfs<Digraph, DefPredMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct DefDistMapTraits : public Traits {
 		      typedef T DistMap;
 		      static DistMap *createDistMap(const Digraph &)
+		      {
 		        throw UninitializedParameter();
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///DistMap type
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting DistMap
 		    ///type
 		    template <class T>
 		    struct DefDistMap {
 		      typedef Dfs<Digraph, DefDistMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct DefReachedMapTraits : public Traits {
 		      typedef T ReachedMap;
 		      static ReachedMap *createReachedMap(const Digraph &)
+		      {
 		        throw UninitializedParameter();
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///ReachedMap type
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting ReachedMap type
 		    ///
 		    template <class T>
 		    struct DefReachedMap : public Dfs< Digraph, DefReachedMapTraits<T> > {
 		      typedef Dfs< Digraph, DefReachedMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct DefProcessedMapTraits : public Traits {
 		      typedef T ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &)
+		      {
 		        throw UninitializedParameter();
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///ProcessedMap type
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting ProcessedMap type
 		    ///
 		    template <class T>
 		    struct DefProcessedMap : public Dfs< Digraph, DefProcessedMapTraits<T> > {
 		      typedef Dfs< Digraph, DefProcessedMapTraits<T> > Create;
 		    };
 		    struct DefDigraphProcessedMapTraits : public Traits {
 		      typedef typename Digraph::template NodeMap<bool> ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &G)
+		      {
 		        return new ProcessedMap(G);
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter"
 		    ///for setting the ProcessedMap type to be Digraph::NodeMap<bool>.
 		    ///
 		    ///\ref named-templ-param "Named parameter"
 		    ///for setting the ProcessedMap type to be Digraph::NodeMap<bool>.
 		    ///If you don't set it explicitely, it will be automatically allocated.
 		    template <class T>
 		    class DefProcessedMapToBeDefaultMap :
 		      public Dfs< Digraph, DefDigraphProcessedMapTraits> {
 		      typedef Dfs< Digraph, DefDigraphProcessedMapTraits> Create;
 		    };
 		    ///@}
 		  public:
 		    ///Constructor.
 		    ///\param _G the digraph the algorithm will run on.
 		    ///
 		    Dfs(const Digraph& _G) :
 		      G(&_G),
 		      _pred(NULL), local_pred(false),
 		      _dist(NULL), local_dist(false),
 		      _reached(NULL), local_reached(false),
 		      _processed(NULL), local_processed(false)
 		    { }
 		    ///Destructor.
 		    ~Dfs()
+		    {
 		      if(local_pred) delete _pred;
 		      if(local_dist) delete _dist;
 		      if(local_reached) delete _reached;
 		      if(local_processed) delete _processed;
+		    }
 		    ///Sets the map storing the predecessor arcs.
 		    ///Sets the map storing the predecessor arcs.
 		    ///If you don't use this function before calling \ref run(),
 		    ///it will allocate one. The destuctor deallocates this
 		    ///automatically allocated map, of course.
 		    ///\return <tt> (*this) </tt>
 		    Dfs &predMap(PredMap &m)
+		    {
 		      if(local_pred) {
 		        delete _pred;
 		        local_pred=false;
+		      }
 		      _pred = &m;
 		      return *this;
+		    }
 		    ///Sets the map storing the distances calculated by the algorithm.
 		    ///Sets the map storing the distances calculated by the algorithm.
 		    ///If you don't use this function before calling \ref run(),
 		    ///it will allocate one. The destuctor deallocates this
 		    ///automatically allocated map, of course.
 		    ///\return <tt> (*this) </tt>
 		    Dfs &distMap(DistMap &m)
+		    {
 		      if(local_dist) {
 		        delete _dist;
 		        local_dist=false;
+		      }
 		      _dist = &m;
 		      return *this;
+		    }
 		    ///Sets the map indicating if a node is reached.
 		    ///Sets the map indicating if a node is reached.
 		    ///If you don't use this function before calling \ref run(),
 		    ///it will allocate one. The destuctor deallocates this
 		    ///automatically allocated map, of course.
 		    ///\return <tt> (*this) </tt>
 		    Dfs &reachedMap(ReachedMap &m)
+		    {
 		      if(local_reached) {
 		        delete _reached;
 		        local_reached=false;
+		      }
 		      _reached = &m;
 		      return *this;
+		    }
 		    ///Sets the map indicating if a node is processed.
 		    ///Sets the map indicating if a node is processed.
 		    ///If you don't use this function before calling \ref run(),
 		    ///it will allocate one. The destuctor deallocates this
 		    ///automatically allocated map, of course.
 		    ///\return <tt> (*this) </tt>
 		    Dfs &processedMap(ProcessedMap &m)
+		    {
 		      if(local_processed) {
 		        delete _processed;
 		        local_processed=false;
+		      }
 		      _processed = &m;
 		      return *this;
+		    }

lemon/dijkstra.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_DIJKSTRA_H
 		#define LEMON_DIJKSTRA_H
 		///\ingroup shortest_path
 		///\file
 		///\brief Dijkstra algorithm.
 		#include <limits>
 		#include <lemon/list_graph.h>
 		#include <lemon/bin_heap.h>
 		#include <lemon/bits/path_dump.h>
-		#include <lemon/bits/invalid.h>
+		#include <lemon/core.h>
 		#include <lemon/error.h>
 		#include <lemon/maps.h>
 		namespace lemon {
 		  /// \brief Default OperationTraits for the Dijkstra algorithm class.
 		  ///
 		  /// It defines all computational operations and constants which are
 		  /// used in the Dijkstra algorithm.
 		  template <typename Value>
 		  struct DijkstraDefaultOperationTraits {
 		    /// \brief Gives back the zero value of the type.
 		    static Value zero() {
 		      return static_cast<Value>(0);
+		    }
 		    /// \brief Gives back the sum of the given two elements.
 		    static Value plus(const Value& left, const Value& right) {
 		      return left + right;
+		    }
 		    /// \brief Gives back true only if the first value less than the second.
 		    static bool less(const Value& left, const Value& right) {
 		      return left < right;
+		    }
 		  };
 		  /// \brief Widest path OperationTraits for the Dijkstra algorithm class.
 		  ///
 		  /// It defines all computational operations and constants which are
 		  /// used in the Dijkstra algorithm for widest path computation.
 		  template <typename Value>
 		  struct DijkstraWidestPathOperationTraits {
 		    /// \brief Gives back the maximum value of the type.
 		    static Value zero() {
 		      return std::numeric_limits<Value>::max();
+		    }
 		    /// \brief Gives back the minimum of the given two elements.
 		    static Value plus(const Value& left, const Value& right) {
 		      return std::min(left, right);
+		    }
 		    /// \brief Gives back true only if the first value less than the second.
 		    static bool less(const Value& left, const Value& right) {
 		      return left < right;
+		    }
 		  };
 		  ///Default traits class of Dijkstra class.
 		  ///Default traits class of Dijkstra class.
 		  ///\tparam GR Digraph type.
 		  ///\tparam LM Type of length map.
 		  template<class GR, class LM>
 		  struct DijkstraDefaultTraits
+		  {
 		    ///The digraph type the algorithm runs on.
 		    typedef GR Digraph;
 		    ///The type of the map that stores the arc lengths.
 		    ///The type of the map that stores the arc lengths.
 		    ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
 		    typedef LM LengthMap;
 		    //The type of the length of the arcs.
 		    typedef typename LM::Value Value;
 		    /// Operation traits for Dijkstra algorithm.
 		    /// It defines the used operation by the algorithm.
 		    /// \see DijkstraDefaultOperationTraits
 		    typedef DijkstraDefaultOperationTraits<Value> OperationTraits;
 		    /// The cross reference type used by heap.
 		    /// The cross reference type used by heap.
 		    /// Usually it is \c Digraph::NodeMap<int>.
 		    typedef typename Digraph::template NodeMap<int> HeapCrossRef;
 		    ///Instantiates a HeapCrossRef.
 		    ///This function instantiates a \c HeapCrossRef.
 		    /// \param G is the digraph, to which we would like to define the
 		    /// HeapCrossRef.
 		    static HeapCrossRef *createHeapCrossRef(const GR &G)
+		    {
 		      return new HeapCrossRef(G);
+		    }
 		    ///The heap type used by Dijkstra algorithm.
 		    ///The heap type used by Dijkstra algorithm.
 		    ///
 		    ///\sa BinHeap
 		    ///\sa Dijkstra
 		    typedef BinHeap<typename LM::Value, HeapCrossRef, std::less<Value> > Heap;
 		    static Heap *createHeap(HeapCrossRef& R)
+		    {
 		      return new Heap(R);
+		    }
 		    ///\brief The type of the map that stores the last
 		    ///arcs of the shortest paths.
 		    ///
 		    ///The type of the map that stores the last
 		    ///arcs of the shortest paths.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    ///
 		    typedef typename Digraph::template NodeMap<typename GR::Arc> PredMap;
 		    ///Instantiates a PredMap.
 		    ///This function instantiates a \c PredMap.
 		    ///\param G is the digraph, to which we would like to define the PredMap.
 		    ///\todo The digraph alone may be insufficient for the initialization
 		    static PredMap *createPredMap(const GR &G)
+		    {
 		      return new PredMap(G);
+		    }
 		    ///The type of the map that stores whether a nodes is processed.
 		    ///The type of the map that stores whether a nodes is processed.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    ///By default it is a NullMap.
 		    ///\todo If it is set to a real map,
 		    ///Dijkstra::processed() should read this.
 		    ///\todo named parameter to set this type, function to read and write.
 		    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
 		    ///Instantiates a ProcessedMap.
 		    ///This function instantiates a \c ProcessedMap.
 		    ///\param g is the digraph, to which
 		    ///we would like to define the \c ProcessedMap
 		#ifdef DOXYGEN
 		    static ProcessedMap *createProcessedMap(const GR &g)
 		#else
 		    static ProcessedMap *createProcessedMap(const GR &)
 		#endif
+		    {
 		      return new ProcessedMap();
+		    }
 		    ///The type of the map that stores the dists of the nodes.
 		    ///The type of the map that stores the dists of the nodes.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    ///
 		    typedef typename Digraph::template NodeMap<typename LM::Value> DistMap;
 		    ///Instantiates a DistMap.
 		    ///This function instantiates a \ref DistMap.
 		    ///\param G is the digraph, to which we would like to define
 		    ///the \ref DistMap
 		    static DistMap *createDistMap(const GR &G)
+		    {
 		      return new DistMap(G);
+		    }
 		  };
 		  ///%Dijkstra algorithm class.
 		  /// \ingroup shortest_path
 		  ///This class provides an efficient implementation of %Dijkstra algorithm.
 		  ///The arc lengths are passed to the algorithm using a
 		  ///\ref concepts::ReadMap "ReadMap",
 		  ///so it is easy to change it to any kind of length.
 		  ///
 		  ///The type of the length is determined by the
 		  ///\ref concepts::ReadMap::Value "Value" of the length map.
 		  ///
 		  ///It is also possible to change the underlying priority heap.
 		  ///
 		  ///\tparam GR The digraph type the algorithm runs on. The default value
 		  ///is \ref ListDigraph. The value of GR is not used directly by
 		  ///Dijkstra, it is only passed to \ref DijkstraDefaultTraits.
 		  ///\tparam LM This read-only ArcMap determines the lengths of the
 		  ///arcs. It is read once for each arc, so the map may involve in
 		  ///relatively time consuming process to compute the arc length if
 		  ///it is necessary. The default map type is \ref
 		  ///concepts::Digraph::ArcMap "Digraph::ArcMap<int>".  The value
 		  ///of LM is not used directly by Dijkstra, it is only passed to \ref
 		  ///DijkstraDefaultTraits.
 		  ///\tparam TR Traits class to set
 		  ///various data types used by the algorithm.  The default traits
 		  ///class is \ref DijkstraDefaultTraits
 		  ///"DijkstraDefaultTraits<GR,LM>".  See \ref
 		  ///DijkstraDefaultTraits for the documentation of a Dijkstra traits
 		  ///class.
 		#ifdef DOXYGEN
 		  template <typename GR, typename LM, typename TR>
 		#else
 		  template <typename GR=ListDigraph,
 		            typename LM=typename GR::template ArcMap<int>,
 		            typename TR=DijkstraDefaultTraits<GR,LM> >
 		#endif
 		  class Dijkstra {
 		  public:
 		    /**
 		     * \brief \ref Exception for uninitialized parameters.
+		     *
 		     * This error represents problems in the initialization
 		     * of the parameters of the algorithms.
 		     */
 		    class UninitializedParameter : public lemon::UninitializedParameter {
 		    public:
 		      virtual const char* what() const throw() {
 		        return "lemon::Dijkstra::UninitializedParameter";
+		      }
 		    };
 		    typedef TR Traits;
 		    ///The type of the underlying digraph.
 		    typedef typename TR::Digraph Digraph;
 		    ///\e
 		    typedef typename Digraph::Node Node;
 		    ///\e
 		    typedef typename Digraph::NodeIt NodeIt;
 		    ///\e
 		    typedef typename Digraph::Arc Arc;
 		    ///\e
 		    typedef typename Digraph::OutArcIt OutArcIt;
 		    ///The type of the length of the arcs.
 		    typedef typename TR::LengthMap::Value Value;
 		    ///The type of the map that stores the arc lengths.
 		    typedef typename TR::LengthMap LengthMap;
 		    ///\brief The type of the map that stores the last
 		    ///arcs of the shortest paths.
 		    typedef typename TR::PredMap PredMap;
 		    ///The type of the map indicating if a node is processed.
 		    typedef typename TR::ProcessedMap ProcessedMap;
 		    ///The type of the map that stores the dists of the nodes.
 		    typedef typename TR::DistMap DistMap;
 		    ///The cross reference type used for the current heap.
 		    typedef typename TR::HeapCrossRef HeapCrossRef;
 		    ///The heap type used by the dijkstra algorithm.
 		    typedef typename TR::Heap Heap;
 		    ///The operation traits.
 		    typedef typename TR::OperationTraits OperationTraits;
 		  private:
 		    /// Pointer to the underlying digraph.
 		    const Digraph *G;
 		    /// Pointer to the length map
 		    const LengthMap *length;
 		    ///Pointer to the map of predecessors arcs.
 		    PredMap *_pred;
 		    ///Indicates if \ref _pred is locally allocated (\c true) or not.
 		    bool local_pred;
 		    ///Pointer to the map of distances.
 		    DistMap *_dist;
 		    ///Indicates if \ref _dist is locally allocated (\c true) or not.
 		    bool local_dist;
 		    ///Pointer to the map of processed status of the nodes.
 		    ProcessedMap *_processed;
 		    ///Indicates if \ref _processed is locally allocated (\c true) or not.
 		    bool local_processed;
 		    ///Pointer to the heap cross references.
 		    HeapCrossRef *_heap_cross_ref;
 		    ///Indicates if \ref _heap_cross_ref is locally allocated (\c true) or not.
 		    bool local_heap_cross_ref;
 		    ///Pointer to the heap.
 		    Heap *_heap;
 		    ///Indicates if \ref _heap is locally allocated (\c true) or not.
 		    bool local_heap;
 		    ///Creates the maps if necessary.
 		    ///\todo Better memory allocation (instead of new).
 		    void create_maps()
+		    {
 		      if(!_pred) {
 		        local_pred = true;
 		        _pred = Traits::createPredMap(*G);
+		      }
 		      if(!_dist) {
 		        local_dist = true;
 		        _dist = Traits::createDistMap(*G);
+		      }
 		      if(!_processed) {
 		        local_processed = true;
 		        _processed = Traits::createProcessedMap(*G);
+		      }
 		      if (!_heap_cross_ref) {
 		        local_heap_cross_ref = true;
 		        _heap_cross_ref = Traits::createHeapCrossRef(*G);
+		      }
 		      if (!_heap) {
 		        local_heap = true;
 		        _heap = Traits::createHeap(*_heap_cross_ref);
+		      }
+		    }
 		  public :
 		    typedef Dijkstra Create;
 		    ///\name Named template parameters
 		    ///@{
 		    template <class T>
 		    struct DefPredMapTraits : public Traits {
 		      typedef T PredMap;
 		      static PredMap *createPredMap(const Digraph &)
+		      {
 		        throw UninitializedParameter();
+		      }
 		    };
 		    ///\ref named-templ-param "Named parameter" for setting PredMap type
 		    ///\ref named-templ-param "Named parameter" for setting PredMap type
 		    ///
 		    template <class T>
 		    struct DefPredMap
 		      : public Dijkstra< Digraph, LengthMap, DefPredMapTraits<T> > {
 		      typedef Dijkstra< Digraph, LengthMap, DefPredMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct DefDistMapTraits : public Traits {
 		      typedef T DistMap;
 		      static DistMap *createDistMap(const Digraph &)
+		      {
 		        throw UninitializedParameter();
+		      }
 		    };
 		    ///\ref named-templ-param "Named parameter" for setting DistMap type
 		    ///\ref named-templ-param "Named parameter" for setting DistMap type
 		    ///
 		    template <class T>
 		    struct DefDistMap
 		      : public Dijkstra< Digraph, LengthMap, DefDistMapTraits<T> > {
 		      typedef Dijkstra< Digraph, LengthMap, DefDistMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct DefProcessedMapTraits : public Traits {
 		      typedef T ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &G)
+		      {
 		        throw UninitializedParameter();
+		      }
 		    };
 		    ///\ref named-templ-param "Named parameter" for setting ProcessedMap type
 		    ///\ref named-templ-param "Named parameter" for setting ProcessedMap type
 		    ///
 		    template <class T>
 		    struct DefProcessedMap
 		      : public Dijkstra< Digraph, LengthMap, DefProcessedMapTraits<T> > {
 		      typedef Dijkstra< Digraph, LengthMap, DefProcessedMapTraits<T> > Create;
 		    };
 		    struct DefDigraphProcessedMapTraits : public Traits {
 		      typedef typename Digraph::template NodeMap<bool> ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &G)
+		      {
 		        return new ProcessedMap(G);
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter"
 		    ///for setting the ProcessedMap type to be Digraph::NodeMap<bool>.
 		    ///
 		    ///\ref named-templ-param "Named parameter"
 		    ///for setting the ProcessedMap type to be Digraph::NodeMap<bool>.
 		    ///If you don't set it explicitely, it will be automatically allocated.
 		    template <class T>
 		    struct DefProcessedMapToBeDefaultMap
 		      : public Dijkstra< Digraph, LengthMap, DefDigraphProcessedMapTraits> {
 		      typedef Dijkstra< Digraph, LengthMap, DefDigraphProcessedMapTraits>
 		      Create;
 		    };
 		    template <class H, class CR>
 		    struct DefHeapTraits : public Traits {
 		      typedef CR HeapCrossRef;
 		      typedef H Heap;
 		      static HeapCrossRef *createHeapCrossRef(const Digraph &) {
 		        throw UninitializedParameter();
+		      }
 		      static Heap *createHeap(HeapCrossRef &)
+		      {
 		        throw UninitializedParameter();
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///heap and cross reference type
 		    ///

lemon/dim2.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_DIM2_H
 		#define LEMON_DIM2_H
 		#include <iostream>
-		#include <lemon/bits/utility.h>
+		#include <lemon/core.h>
 		///\ingroup misc
 		///\file
 		///\brief A simple two dimensional vector and a bounding box implementation
 		///
 		/// The class \ref lemon::dim2::Point "dim2::Point" implements
 		/// a two dimensional vector with the usual operations.
 		///
 		/// The class \ref lemon::dim2::BoundingBox "dim2::BoundingBox"
 		/// can be used to determine
 		/// the rectangular bounding box of a set of
 		/// \ref lemon::dim2::Point "dim2::Point"'s.
 		namespace lemon {
 		  ///Tools for handling two dimensional coordinates
 		  ///This namespace is a storage of several
 		  ///tools for handling two dimensional coordinates
 		  namespace dim2 {
 		  /// \addtogroup misc
 		  /// @{
 		  /// A simple two dimensional vector (plainvector) implementation
 		  /// A simple two dimensional vector (plainvector) implementation
 		  /// with the usual vector operations.
 		  template<typename T>
 		    class Point {
 		    public:
 		      typedef T Value;
 		      ///First coordinate
 		      T x;
 		      ///Second coordinate
 		      T y;
 		      ///Default constructor
 		      Point() {}
 		      ///Construct an instance from coordinates
 		      Point(T a, T b) : x(a), y(b) { }
 		      ///Returns the dimension of the vector (i.e. returns 2).
 		      ///The dimension of the vector.
 		      ///This function always returns 2.
 		      int size() const { return 2; }
 		      ///Subscripting operator
 		      ///\c p[0] is \c p.x and \c p[1] is \c p.y
 		      ///
 		      T& operator[](int idx) { return idx == 0 ? x : y; }
 		      ///Const subscripting operator
 		      ///\c p[0] is \c p.x and \c p[1] is \c p.y
 		      ///
 		      const T& operator[](int idx) const { return idx == 0 ? x : y; }
 		      ///Conversion constructor
 		      template<class TT> Point(const Point<TT> &p) : x(p.x), y(p.y) {}
 		      ///Give back the square of the norm of the vector
 		      T normSquare() const {
 		        return x*x+y*y;
+		      }
 		      ///Increment the left hand side by \c u
 		      Point<T>& operator +=(const Point<T>& u) {
 		        x += u.x;
 		        y += u.y;
 		        return *this;
+		      }
 		      ///Decrement the left hand side by \c u
 		      Point<T>& operator -=(const Point<T>& u) {
 		        x -= u.x;
 		        y -= u.y;
 		        return *this;
+		      }
 		      ///Multiply the left hand side with a scalar
 		      Point<T>& operator *=(const T &u) {
 		        x *= u;
 		        y *= u;
 		        return *this;
+		      }
 		      ///Divide the left hand side by a scalar
 		      Point<T>& operator /=(const T &u) {
 		        x /= u;
 		        y /= u;
 		        return *this;
+		      }
 		      ///Return the scalar product of two vectors
 		      T operator *(const Point<T>& u) const {
 		        return x*u.x+y*u.y;
+		      }
 		      ///Return the sum of two vectors
 		      Point<T> operator+(const Point<T> &u) const {
 		        Point<T> b=*this;
 		        return b+=u;
+		      }
 		      ///Return the negative of the vector
 		      Point<T> operator-() const {
 		        Point<T> b=*this;
 		        b.x=-b.x; b.y=-b.y;
 		        return b;
+		      }
 		      ///Return the difference of two vectors
 		      Point<T> operator-(const Point<T> &u) const {
 		        Point<T> b=*this;
 		        return b-=u;
+		      }
 		      ///Return a vector multiplied by a scalar
 		      Point<T> operator*(const T &u) const {
 		        Point<T> b=*this;
 		        return b*=u;
+		      }
 		      ///Return a vector divided by a scalar
 		      Point<T> operator/(const T &u) const {
 		        Point<T> b=*this;
 		        return b/=u;
+		      }
 		      ///Test equality
 		      bool operator==(const Point<T> &u) const {
 		        return (x==u.x) && (y==u.y);
+		      }
 		      ///Test inequality
 		      bool operator!=(Point u) const {
 		        return  (x!=u.x) || (y!=u.y);
+		      }
 		    };
 		  ///Return a Point
 		  ///Return a Point.
 		  ///\relates Point
 		  template <typename T>
 		  inline Point<T> makePoint(const T& x, const T& y) {
 		    return Point<T>(x, y);
+		  }
 		  ///Return a vector multiplied by a scalar
 		  ///Return a vector multiplied by a scalar.
 		  ///\relates Point
 		  template<typename T> Point<T> operator*(const T &u,const Point<T> &x) {
 		    return x*u;
+		  }
 		  ///Read a plainvector from a stream
 		  ///Read a plainvector from a stream.
 		  ///\relates Point
 		  ///
 		  template<typename T>
 		  inline std::istream& operator>>(std::istream &is, Point<T> &z) {
 		    char c;
 		    if (is >> c) {
 		      if (c != '(') is.putback(c);
 		    } else {
 		      is.clear();
+		    }
 		    if (!(is >> z.x)) return is;
 		    if (is >> c) {
 		      if (c != ',') is.putback(c);
 		    } else {
 		      is.clear();
+		    }
 		    if (!(is >> z.y)) return is;
 		    if (is >> c) {
 		      if (c != ')') is.putback(c);
 		    } else {
 		      is.clear();
+		    }
 		    return is;
+		  }
 		  ///Write a plainvector to a stream
 		  ///Write a plainvector to a stream.
 		  ///\relates Point
 		  ///
 		  template<typename T>
 		  inline std::ostream& operator<<(std::ostream &os, const Point<T>& z)
+		  {
 		    os << "(" << z.x << ", " << z.y << ")";
 		    return os;
+		  }
 		  ///Rotate by 90 degrees
 		  ///Returns the parameter rotated by 90 degrees in positive direction.
 		  ///\relates Point
 		  ///
 		  template<typename T>
 		  inline Point<T> rot90(const Point<T> &z)
+		  {
 		    return Point<T>(-z.y,z.x);
+		  }
 		  ///Rotate by 180 degrees
 		  ///Returns the parameter rotated by 180 degrees.
 		  ///\relates Point
 		  ///
 		  template<typename T>
 		  inline Point<T> rot180(const Point<T> &z)
+		  {
 		    return Point<T>(-z.x,-z.y);
+		  }
 		  ///Rotate by 270 degrees
 		  ///Returns the parameter rotated by 90 degrees in negative direction.
 		  ///\relates Point
 		  ///
 		  template<typename T>
 		  inline Point<T> rot270(const Point<T> &z)
+		  {
 		    return Point<T>(z.y,-z.x);
+		  }
 		  /// A class to calculate or store the bounding box of plainvectors.
 		  /// A class to calculate or store the bounding box of plainvectors.
 		  ///
 		    template<typename T>
 		    class BoundingBox {
 		      Point<T> bottom_left, top_right;
 		      bool _empty;
 		    public:
 		      ///Default constructor: creates an empty bounding box
 		      BoundingBox() { _empty = true; }
 		      ///Construct an instance from one point
 		      BoundingBox(Point<T> a) { bottom_left=top_right=a; _empty = false; }
 		      ///Construct an instance from two points
 		      ///Construct an instance from two points.
 		      ///\param a The bottom left corner.
 		      ///\param b The top right corner.
 		      ///\warning The coordinates of the bottom left corner must be no more
 		      ///than those of the top right one.
 		      BoundingBox(Point<T> a,Point<T> b)
+		      {
 		        bottom_left=a;
 		        top_right=b;
 		        _empty = false;
+		      }
 		      ///Construct an instance from four numbers
 		      ///Construct an instance from four numbers.
 		      ///\param l The left side of the box.
 		      ///\param b The bottom of the box.
 		      ///\param r The right side of the box.
 		      ///\param t The top of the box.
 		      ///\warning The left side must be no more than the right side and
 		      ///bottom must be no more than the top.
 		      BoundingBox(T l,T b,T r,T t)
+		      {
 		        bottom_left=Point<T>(l,b);
 		        top_right=Point<T>(r,t);
 		        _empty = false;
+		      }
 		      ///Return \c true if the bounding box is empty.
 		      ///Return \c true if the bounding box is empty (i.e. return \c false
 		      ///if at least one point was added to the box or the coordinates of
 		      ///the box were set).
 		      ///
 		      ///The coordinates of an empty bounding box are not defined.
 		      bool empty() const {
 		        return _empty;
+		      }
 		      ///Make the BoundingBox empty
 		      void clear() {
 		        _empty=1;
+		      }
 		      ///Give back the bottom left corner of the box
 		      ///Give back the bottom left corner of the box.
 		      ///If the bounding box is empty, then the return value is not defined.
 		      Point<T> bottomLeft() const {
 		        return bottom_left;
+		      }
 		      ///Set the bottom left corner of the box
 		      ///Set the bottom left corner of the box.
 		      ///It should only be used for non-empty box.
 		      void bottomLeft(Point<T> p) {
 		        bottom_left = p;
+		      }
 		      ///Give back the top right corner of the box
 		      ///Give back the top right corner of the box.
 		      ///If the bounding box is empty, then the return value is not defined.
 		      Point<T> topRight() const {
 		        return top_right;
+		      }
 		      ///Set the top right corner of the box
 		      ///Set the top right corner of the box.
 		      ///It should only be used for non-empty box.
 		      void topRight(Point<T> p) {
 		        top_right = p;
+		      }
 		      ///Give back the bottom right corner of the box
 		      ///Give back the bottom right corner of the box.
 		      ///If the bounding box is empty, then the return value is not defined.
 		      Point<T> bottomRight() const {
 		        return Point<T>(top_right.x,bottom_left.y);
+		      }
 		      ///Set the bottom right corner of the box
 		      ///Set the bottom right corner of the box.
 		      ///It should only be used for non-empty box.
 		      void bottomRight(Point<T> p) {
 		        top_right.x = p.x;
 		        bottom_left.y = p.y;
+		      }
 		      ///Give back the top left corner of the box
 		      ///Give back the top left corner of the box.
 		      ///If the bounding box is empty, then the return value is not defined.
 		      Point<T> topLeft() const {
 		        return Point<T>(bottom_left.x,top_right.y);
+		      }
 		      ///Set the top left corner of the box
 		      ///Set the top left corner of the box.
 		      ///It should only be used for non-empty box.
 		      void topLeft(Point<T> p) {
 		        top_right.y = p.y;
 		        bottom_left.x = p.x;
+		      }
 		      ///Give back the bottom of the box
 		      ///Give back the bottom of the box.
 		      ///If the bounding box is empty, then the return value is not defined.
 		      T bottom() const {
 		        return bottom_left.y;
+		      }
 		      ///Set the bottom of the box
 		      ///Set the bottom of the box.
 		      ///It should only be used for non-empty box.
 		      void bottom(T t) {
 		        bottom_left.y = t;
+		      }

lemon/bits/invalid.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_BITS_INVALID_H
 		#define LEMON_BITS_INVALID_H
 		///\file
 		///\brief Definition of INVALID.
 		namespace lemon {
 		  /// \brief Dummy type to make it easier to create invalid iterators.
 		  ///
 		  /// Dummy type to make it easier to create invalid iterators.
 		  /// See \ref INVALID for the usage.
 		  struct Invalid {
 		  public:
 		    bool operator==(Invalid) { return true;  }
 		    bool operator!=(Invalid) { return false; }
 		    bool operator< (Invalid) { return false; }
 		  };
 		  /// \brief Invalid iterators.
 		  ///
 		  /// \ref Invalid is a global type that converts to each iterator
 		  /// in such a way that the value of the target iterator will be invalid.
 		  //Some people didn't like this:
 		  //const Invalid &INVALID = *(Invalid *)0;
 		#ifdef LEMON_ONLY_TEMPLATES
 		  const Invalid INVALID = Invalid();
 		#else
 		  extern const Invalid INVALID;
 		#endif
 		} //namespace lemon
 		#endif

lemon/bits/utility.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		// This file contains a modified version of the enable_if library from BOOST.
 		// See the appropriate copyright notice below.
 		// Boost enable_if library
 		// Copyright 2003 (c) The Trustees of Indiana University.
 		// Use, modification, and distribution is subject to the Boost Software
 		// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 		// http://www.boost.org/LICENSE_1_0.txt)
 		//    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
 		//             Jeremiah Willcock (jewillco at osl.iu.edu)
 		//             Andrew Lumsdaine (lums at osl.iu.edu)
 		#ifndef LEMON_BITS_UTILITY_H
 		#define LEMON_BITS_UTILITY_H
 		///\file
 		///\brief Miscellaneous basic utilities
 		///
 		///\todo Please rethink the organisation of the basic files like this.
 		///E.g. this file might be merged with invalid.h.
 		namespace lemon
+		{
 		  /// Basic type for defining "tags". A "YES" condition for \c enable_if.
 		  /// Basic type for defining "tags". A "YES" condition for \c enable_if.
 		  ///
 		  ///\sa False
 		  ///
 		  /// \todo This should go to a separate "basic_types.h" (or something)
 		  /// file.
 		  struct True {
 		    ///\e
 		    static const bool value = true;
 		  };
 		  /// Basic type for defining "tags". A "NO" condition for \c enable_if.
 		  /// Basic type for defining "tags". A "NO" condition for \c enable_if.
 		  ///
 		  ///\sa True
 		  struct False {
 		    ///\e
 		    static const bool value = false;
 		  };
 		  struct InvalidType {
 		  };
 		  template <typename T>
 		  struct Wrap {
 		    const T &value;
 		    Wrap(const T &t) : value(t) {}
 		  };
 		  /**************** dummy class to avoid ambiguity ****************/
 		  template<int T> struct dummy { dummy(int) {} };
 		  /**************** enable_if from BOOST ****************/
 		  template <typename Type, typename T = void>
 		  struct exists {
 		    typedef T type;
 		  };
 		  template <bool B, class T = void>
 		  struct enable_if_c {
 		    typedef T type;
 		  };
 		  template <class T>
 		  struct enable_if_c<false, T> {};
 		  template <class Cond, class T = void>
 		  struct enable_if : public enable_if_c<Cond::value, T> {};
 		  template <bool B, class T>
 		  struct lazy_enable_if_c {
 		    typedef typename T::type type;
 		  };
 		  template <class T>
 		  struct lazy_enable_if_c<false, T> {};
 		  template <class Cond, class T>
 		  struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {};
 		  template <bool B, class T = void>
 		  struct disable_if_c {
 		    typedef T type;
 		  };
 		  template <class T>
 		  struct disable_if_c<true, T> {};
 		  template <class Cond, class T = void>
 		  struct disable_if : public disable_if_c<Cond::value, T> {};
 		  template <bool B, class T>
 		  struct lazy_disable_if_c {
 		    typedef typename T::type type;
 		  };
 		  template <class T>
 		  struct lazy_disable_if_c<true, T> {};
 		  template <class Cond, class T>
 		  struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {};
 		} // namespace lemon
 		#endif

Changeset was too big and was cut off... Show full diff

0 comments (0 inline)

RhodeCode

Login to your account

Changeset was too big and was cut off... Show full diff

Changeset was too big and was cut off... Show full diff