LEMON/LEMON-main Changeset - r210:81cfc04531e8

Repositories » LEMON » LEMON-main

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

Changeset - r210:81cfc04531e8

« 209:765619

216:6d7bfc »
214:60eecd »
212:1ae84d »
211:542dd6 »

r210:81cfc04531e8

Sun, 13 Jul 2008 21:09:47

[Not Reviewed]

0 comments (0 inline)

alpar (Alpar Juttner)
alpar@cs.elte.hu

Remove long lines (from all but one file)

0 14 0

default

14 files changed:

doc/coding_style.dox

doc/groups.dox

lemon/arg_parser.cc

lemon/assert.h

lemon/bfs.h

lemon/concepts/maps.h

lemon/dfs.h

lemon/dijkstra.h

lemon/graph_to_eps.h

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

↑ Collapse diff ↑

doc/coding_style.dox

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.
+		 *
 		 */
 		/*!
 		\page coding_style LEMON Coding Style
 		\section naming_conv Naming Conventions
 		In order to make development easier we have made some conventions
 		according to coding style. These include names of types, classes,
 		functions, variables, constants and exceptions. If these conventions
 		are met in one's code then it is easier to read and maintain
 		it. Please comply with these conventions if you want to contribute
 		developing LEMON library.
 		\note When the coding style requires the capitalization of an abbreviation,
 		only the first letter should be upper case.
 		\code
 		XmlReader
 		\endcode
 		\warning In some cases we diverge from these rules.
 		This is primary done because STL uses different naming convention and
 		in certain cases
 		it is beneficial to provide STL compatible interface.
 		\subsection cs-files File Names
 		The header file names should look like the following.
 		\code
 		header_file.h
 		\endcode
 		Note that all standard LEMON headers are located in the \c lemon subdirectory,
 		so you should include them from C++ source like this:
 		\code
 		#include <lemon/header_file.h>
 		\endcode
 		The source code files use the same style and they have '.cc' extension.
 		\code
 		source_code.cc
 		\endcode
 		\subsection cs-class Classes and other types
 		The name of a class or any type should look like the following.
 		\code
 		AllWordsCapitalizedWithoutUnderscores
 		\endcode
 		\subsection cs-func Methods and other functions
 		The name of a function should look like the following.
 		\code
 		firstWordLowerCaseRestCapitalizedWithoutUnderscores
 		\endcode
 		\subsection cs-funcs Constants, Macros
 		The names of constants and macros should look like the following.
 		\code
 		ALL_UPPER_CASE_WITH_UNDERSCORES
 		\endcode
 		\subsection cs-loc-var Class and instance member variables, auto variables
-		The names of class and instance member variables and auto variables (=variables used locally in methods) should look like the following.
 		The names of class and instance member variables and auto variables
 		(=variables used locally in methods) should look like the following.
 		\code
 		all_lower_case_with_underscores
 		\endcode
 		\subsection pri-loc-var Private member variables
 		Private member variables should start with underscore
 		\code
 		_start_with_underscores
 		\endcode
 		\subsection cs-excep Exceptions
 		When writing exceptions please comply the following naming conventions.
 		\code
 		ClassNameEndsWithException
 		\endcode
 		or
 		\code
 		ClassNameEndsWithError
 		\endcode
 		\section header-template Template Header File
 		Each LEMON header file should look like this:
 		\include template.h
 		*/

doc/groups.dox

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.
+		 *
 		 */
 		/**
 		@defgroup datas Data Structures
 		This group describes the several data structures implemented in LEMON.
 		*/
 		/**
 		@defgroup graphs Graph Structures
 		@ingroup datas
 		\brief Graph structures implemented in LEMON.
 		The implementation of combinatorial algorithms heavily relies on
 		efficient graph implementations. LEMON offers data structures which are
 		planned to be easily used in an experimental phase of implementation studies,
 		and thereafter the program code can be made efficient by small modifications.
 		The most efficient implementation of diverse applications require the
 		usage of different physical graph implementations. These differences
 		appear in the size of graph we require to handle, memory or time usage
 		limitations or in the set of operations through which the graph can be
 		accessed.  LEMON provides several physical graph structures to meet
 		the diverging requirements of the possible users.  In order to save on
 		running time or on memory usage, some structures may fail to provide
 		some graph features like arc/edge or node deletion.
 		Alteration of standard containers need a very limited number of
 		operations, these together satisfy the everyday requirements.
 		In the case of graph structures, different operations are needed which do
 		not alter the physical graph, but gives another view. If some nodes or
 		arcs have to be hidden or the reverse oriented graph have to be used, then
 		this is the case. It also may happen that in a flow implementation
 		the residual graph can be accessed by another algorithm, or a node-set
 		is to be shrunk for another algorithm.
 		LEMON also provides a variety of graphs for these requirements called
 		\ref graph_adaptors "graph adaptors". Adaptors cannot be used alone but only
 		in conjunction with other graph representations.
 		You are free to use the graph structure that fit your requirements
 		the best, most graph algorithms and auxiliary data structures can be used
 		with any graph structures.
 		*/
 		/**
 		@defgroup semi_adaptors Semi-Adaptor Classes for Graphs
 		@ingroup graphs
 		\brief Graph types between real graphs and graph adaptors.
 		This group describes some graph types between real graphs and graph adaptors.
 		These classes wrap graphs to give new functionality as the adaptors do it.
 		On the other hand they are not light-weight structures as the adaptors.
 		*/
 		/**
 		@defgroup maps Maps
 		@ingroup datas
 		\brief Map structures implemented in LEMON.
 		This group describes the map structures implemented in LEMON.
 		LEMON provides several special purpose maps that e.g. combine
 		new maps from existing ones.
 		*/
 		/**
 		@defgroup graph_maps Graph Maps
 		@ingroup maps
 		\brief Special graph-related maps.
 		This group describes maps that are specifically designed to assign
 		values to the nodes and arcs of graphs.
 		*/
 		/**
 		\defgroup map_adaptors Map Adaptors
 		\ingroup maps
 		\brief Tools to create new maps from existing ones
 		This group describes map adaptors that are used to create "implicit"
 		maps from other maps.
 		Most of them are \ref lemon::concepts::ReadMap "read-only maps".
 		They can make arithmetic and logical operations between one or two maps
 		(negation, shifting, addition, multiplication, logical 'and', 'or',
 		'not' etc.) or e.g. convert a map to another one of different Value type.
 		The typical usage of this classes is passing implicit maps to
 		algorithms.  If a function type algorithm is called then the function
 		type map adaptors can be used comfortable. For example let's see the
 		usage of map adaptors with the \c digraphToEps() function.
 		\code
 		  Color nodeColor(int deg) {
 		    if (deg >= 2) {
 		      return Color(0.5, 0.0, 0.5);
 		    } else if (deg == 1) {
 		      return Color(1.0, 0.5, 1.0);
 		    } else {
 		      return Color(0.0, 0.0, 0.0);
+		    }
+		  }
 		  Digraph::NodeMap<int> degree_map(graph);
 		  digraphToEps(graph, "graph.eps")
 		    .coords(coords).scaleToA4().undirected()
 		    .nodeColors(composeMap(functorToMap(nodeColor), degree_map))
 		    .run();
 		\endcode
 		The \c functorToMap() function makes an \c int to \c Color map from the
 		\e nodeColor() function. The \c composeMap() compose the \e degree_map
 		and the previously created map. The composed map is a proper function to
 		get the color of each node.
 		The usage with class type algorithms is little bit harder. In this
 		case the function type map adaptors can not be used, because the
 		function map adaptors give back temporary objects.
 		\code
 		  Digraph graph;
 		  typedef Digraph::ArcMap<double> DoubleArcMap;
 		  DoubleArcMap length(graph);
 		  DoubleArcMap speed(graph);
 		  typedef DivMap<DoubleArcMap, DoubleArcMap> TimeMap;
 		  TimeMap time(length, speed);
 		  Dijkstra<Digraph, TimeMap> dijkstra(graph, time);
 		  dijkstra.run(source, target);
 		\endcode
 		We have a length map and a maximum speed map on the arcs of a digraph.
 		The minimum time to pass the arc can be calculated as the division of
 		the two maps which can be done implicitly with the \c DivMap template
 		class. We use the implicit minimum time map as the length map of the
 		\c Dijkstra algorithm.
 		*/
 		/**
 		@defgroup matrices Matrices
 		@ingroup datas
 		\brief Two dimensional data storages implemented in LEMON.
 		This group describes two dimensional data storages implemented in LEMON.
 		*/
 		/**
 		@defgroup paths Path Structures
 		@ingroup datas
 		\brief Path structures implemented in LEMON.
 		This group describes the path structures implemented in LEMON.
 		LEMON provides flexible data structures to work with paths.
 		All of them have similar interfaces and they can be copied easily with
 		assignment operators and copy constructors. This makes it easy and
 		efficient to have e.g. the Dijkstra algorithm to store its result in
 		any kind of path structure.
 		\sa lemon::concepts::Path
 		*/
 		/**
 		@defgroup auxdat Auxiliary Data Structures
 		@ingroup datas
 		\brief Auxiliary data structures implemented in LEMON.
 		This group describes some data structures implemented in LEMON in
 		order to make it easier to implement combinatorial algorithms.
 		*/
 		/**
 		@defgroup algs Algorithms
 		\brief This group describes the several algorithms
 		implemented in LEMON.
 		This group describes the several algorithms
 		implemented in LEMON.
 		*/
 		/**
 		@defgroup search Graph Search
 		@ingroup algs
 		\brief Common graph search algorithms.
 		This group describes the common graph search algorithms like
 		Breadth-first search (Bfs) and Depth-first search (Dfs).
 		*/
 		/**
 		@defgroup shortest_path Shortest Path algorithms
 		@ingroup algs
 		\brief Algorithms for finding shortest paths.
 		This group describes the algorithms for finding shortest paths in graphs.
 		*/
 		/**
 		@defgroup max_flow Maximum Flow algorithms
 		@ingroup algs
 		\brief Algorithms for finding maximum flows.
 		This group describes the algorithms for finding maximum flows and
 		feasible circulations.
 		The maximum flow problem is to find a flow between a single source and
 		a single target that is maximum. Formally, there is a \f$G=(V,A)\f$
 		directed graph, an \f$c_a:A\rightarrow\mathbf{R}^+_0\f$ capacity
 		function and given \f$s, t \in V\f$ source and target node. The
 		maximum flow is the \f$f_a\f$ solution of the next optimization problem:
 		\f[ 0 \le f_a \le c_a \f]
-		\f[ \sum_{v\in\delta^{-}(u)}f_{vu}=\sum_{v\in\delta^{+}(u)}f_{uv} \qquad \forall u \in V \setminus \{s,t\}\f]
 		\f[ \sum_{v\in\delta^{-}(u)}f_{vu}=\sum_{v\in\delta^{+}(u)}f_{uv}
 		\qquad \forall u \in V \setminus \{s,t\}\f]
 		\f[ \max \sum_{v\in\delta^{+}(s)}f_{uv} - \sum_{v\in\delta^{-}(s)}f_{vu}\f]
 		LEMON contains several algorithms for solving maximum flow problems:
 		- \ref lemon::EdmondsKarp "Edmonds-Karp"
 		- \ref lemon::Preflow "Goldberg's Preflow algorithm"
 		- \ref lemon::DinitzSleatorTarjan "Dinitz's blocking flow algorithm with dynamic trees"
 		- \ref lemon::GoldbergTarjan "Preflow algorithm with dynamic trees"
 		In most cases the \ref lemon::Preflow "Preflow" algorithm provides the
 		fastest method to compute the maximum flow. All impelementations
 		provides functions to query the minimum cut, which is the dual linear
 		programming problem of the maximum flow.
 		*/
 		/**
 		@defgroup min_cost_flow Minimum Cost Flow algorithms
 		@ingroup algs
 		\brief Algorithms for finding minimum cost flows and circulations.
 		This group describes the algorithms for finding minimum cost flows and
 		circulations.
 		*/
 		/**
 		@defgroup min_cut Minimum Cut algorithms
 		@ingroup algs
 		\brief Algorithms for finding minimum cut in graphs.
 		This group describes the algorithms for finding minimum cut in graphs.
 		The minimum cut problem is to find a non-empty and non-complete
 		\f$X\f$ subset of the vertices with minimum overall capacity on
 		outgoing arcs. Formally, there is \f$G=(V,A)\f$ directed graph, an
 		\f$c_a:A\rightarrow\mathbf{R}^+_0\f$ capacity function. The minimum
 		cut is the \f$X\f$ solution of the next optimization problem:
-		\f[ \min_{X \subset V, X\not\in \{\emptyset, V\}}\sum_{uv\in A, u\in X, v\not\in X}c_{uv}\f]
 		\f[ \min_{X \subset V, X\not\in \{\emptyset, V\}}
 		\sum_{uv\in A, u\in X, v\not\in X}c_{uv}\f]
 		LEMON contains several algorithms related to minimum cut problems:
 		- \ref lemon::HaoOrlin "Hao-Orlin algorithm" to calculate minimum cut
 		  in directed graphs
 		- \ref lemon::NagamochiIbaraki "Nagamochi-Ibaraki algorithm" to
 		  calculate minimum cut in undirected graphs
 		- \ref lemon::GomoryHuTree "Gomory-Hu tree computation" to calculate all
 		  pairs minimum cut in undirected graphs
 		If you want to find minimum cut just between two distinict nodes,
 		please see the \ref max_flow "Maximum Flow page".
 		*/
 		/**
 		@defgroup graph_prop Connectivity and other graph properties
 		@ingroup algs
 		\brief Algorithms for discovering the graph properties
 		This group describes the algorithms for discovering the graph properties
 		like connectivity, bipartiteness, euler property, simplicity etc.
 		\image html edge_biconnected_components.png
 		\image latex edge_biconnected_components.eps "bi-edge-connected components" width=\textwidth
 		*/
 		/**
 		@defgroup planar Planarity embedding and drawing
 		@ingroup algs
 		\brief Algorithms for planarity checking, embedding and drawing
-		This group describes the algorithms for planarity checking, embedding and drawing.
 		This group describes the algorithms for planarity checking,
 		embedding and drawing.
 		\image html planar.png
 		\image latex planar.eps "Plane graph" width=\textwidth
 		*/
 		/**
 		@defgroup matching Matching algorithms
 		@ingroup algs
 		\brief Algorithms for finding matchings in graphs and bipartite graphs.
 		This group contains algorithm objects and functions to calculate
 		matchings in graphs and bipartite graphs. The general matching problem is
 		finding a subset of the arcs which does not shares common endpoints.
 		There are several different algorithms for calculate matchings in
 		graphs.  The matching problems in bipartite graphs are generally
 		easier than in general graphs. The goal of the matching optimization
 		can be the finding maximum cardinality, maximum weight or minimum cost
 		matching. The search can be constrained to find perfect or
 		maximum cardinality matching.
 		Lemon contains the next algorithms:
 		- \ref lemon::MaxBipartiteMatching "MaxBipartiteMatching" Hopcroft-Karp
 		  augmenting path algorithm for calculate maximum cardinality matching in
 		  bipartite graphs
 		- \ref lemon::PrBipartiteMatching "PrBipartiteMatching" Push-Relabel
 		  algorithm for calculate maximum cardinality matching in bipartite graphs
 		- \ref lemon::MaxWeightedBipartiteMatching "MaxWeightedBipartiteMatching"
 		  Successive shortest path algorithm for calculate maximum weighted matching
 		  and maximum weighted bipartite matching in bipartite graph
 		- \ref lemon::MinCostMaxBipartiteMatching "MinCostMaxBipartiteMatching"
 		  Successive shortest path algorithm for calculate minimum cost maximum
 		  matching in bipartite graph
 		- \ref lemon::MaxMatching "MaxMatching" Edmond's blossom shrinking algorithm
 		  for calculate maximum cardinality matching in general graph
 		- \ref lemon::MaxWeightedMatching "MaxWeightedMatching" Edmond's blossom
 		  shrinking algorithm for calculate maximum weighted matching in general
 		  graph
 		- \ref lemon::MaxWeightedPerfectMatching "MaxWeightedPerfectMatching"
 		  Edmond's blossom shrinking algorithm for calculate maximum weighted
 		  perfect matching in general graph
 		\image html bipartite_matching.png
 		\image latex bipartite_matching.eps "Bipartite Matching" width=\textwidth
 		*/
 		/**
 		@defgroup spantree Minimum Spanning Tree algorithms
 		@ingroup algs
 		\brief Algorithms for finding a minimum cost spanning tree in a graph.
 		This group describes the algorithms for finding a minimum cost spanning
 		tree in a graph
 		*/
 		/**
 		@defgroup auxalg Auxiliary algorithms
 		@ingroup algs
 		\brief Auxiliary algorithms implemented in LEMON.
 		This group describes some algorithms implemented in LEMON
 		in order to make it easier to implement complex algorithms.
 		*/
 		/**
 		@defgroup approx Approximation algorithms
 		\brief Approximation algorithms.
 		This group describes the approximation and heuristic algorithms
 		implemented in LEMON.
 		*/
 		/**
 		@defgroup gen_opt_group General Optimization Tools
 		\brief This group describes some general optimization frameworks
 		implemented in LEMON.
 		This group describes some general optimization frameworks
 		implemented in LEMON.
 		*/
 		/**
 		@defgroup lp_group Lp and Mip solvers
 		@ingroup gen_opt_group
 		\brief Lp and Mip solver interfaces for LEMON.
 		This group describes Lp and Mip solver interfaces for LEMON. The
 		various LP solvers could be used in the same manner with this
 		interface.
 		*/
 		/**
 		@defgroup lp_utils Tools for Lp and Mip solvers
 		@ingroup lp_group
 		\brief Helper tools to the Lp and Mip solvers.
 		This group adds some helper tools to general optimization framework
 		implemented in LEMON.
 		*/
 		/**
 		@defgroup metah Metaheuristics
 		@ingroup gen_opt_group
 		\brief Metaheuristics for LEMON library.
 		This group describes some metaheuristic optimization tools.
 		*/
 		/**
 		@defgroup utils Tools and Utilities
 		\brief Tools and utilities for programming in LEMON
 		Tools and utilities for programming in LEMON.
 		*/
 		/**
 		@defgroup gutils Basic Graph Utilities
 		@ingroup utils
 		\brief Simple basic graph utilities.
 		This group describes some simple basic graph utilities.
 		*/
 		/**
 		@defgroup misc Miscellaneous Tools
 		@ingroup utils
 		\brief Tools for development, debugging and testing.
 		This group describes several useful tools for development,
 		debugging and testing.
 		*/
 		/**
 		@defgroup timecount Time measuring and Counting
 		@ingroup misc
 		\brief Simple tools for measuring the performance of algorithms.
 		This group describes simple tools for measuring the performance
 		of algorithms.
 		*/
 		/**
 		@defgroup graphbits Tools for Graph Implementation
 		@ingroup utils
 		\brief Tools to make it easier to create graphs.
 		This group describes the tools that makes it easier to create graphs and
 		the maps that dynamically update with the graph changes.
 		*/
 		/**
 		@defgroup exceptions Exceptions
 		@ingroup utils
 		\brief Exceptions defined in LEMON.
 		This group describes the exceptions defined in LEMON.
 		*/
 		/**
 		@defgroup io_group Input-Output
 		\brief Graph Input-Output methods
 		This group describes the tools for importing and exporting graphs
 		and graph related data. Now it supports the LEMON format, the
 		\c DIMACS format and the encapsulated postscript (EPS) format.
 		*/
 		/**
 		@defgroup lemon_io Lemon Input-Output
 		@ingroup io_group
 		\brief Reading and writing \ref lgf-format "Lemon Graph Format".
-		This group describes methods for reading and writing \ref lgf-format "Lemon Graph Format".
 		This group describes methods for reading and writing
 		\ref lgf-format "Lemon Graph Format".
 		*/
 		/**
 		@defgroup eps_io Postscript exporting
 		@ingroup io_group
 		\brief General \c EPS drawer and graph exporter
 		This group describes general \c EPS drawing methods and special
 		graph exporting tools.
 		*/
 		/**
 		@defgroup concept Concepts
 		\brief Skeleton classes and concept checking classes
 		This group describes the data/algorithm skeletons and concept checking
 		classes implemented in LEMON.
 		The purpose of the classes in this group is fourfold.
 		- These classes contain the documentations of the concepts. In order
 		  to avoid document multiplications, an implementation of a concept
 		  simply refers to the corresponding concept class.
 		- These classes declare every functions, <tt>typedef</tt>s etc. an
 		  implementation of the concepts should provide, however completely
 		  without implementations and real data structures behind the
 		  interface. On the other hand they should provide nothing else. All
 		  the algorithms working on a data structure meeting a certain concept
 		  should compile with these classes. (Though it will not run properly,
 		  of course.) In this way it is easily to check if an algorithm
 		  doesn't use any extra feature of a certain implementation.
 		- The concept descriptor classes also provide a <em>checker class</em>
 		  that makes it possible to check whether a certain implementation of a
 		  concept indeed provides all the required features.
 		- Finally, They can serve as a skeleton of a new implementation of a concept.
 		*/
 		/**
 		@defgroup graph_concepts Graph Structure Concepts
 		@ingroup concept
 		\brief Skeleton and concept checking classes for graph structures
 		This group describes the skeletons and concept checking classes of LEMON's
 		graph structures and helper classes used to implement these.
 		*/
 		/* --- Unused group
 		@defgroup experimental Experimental Structures and Algorithms
 		This group describes some Experimental structures and algorithms.
 		The stuff here is subject to change.
 		*/
 		/**
 		\anchor demoprograms
 		@defgroup demos Demo programs
 		Some demo programs are listed here. Their full source codes can be found in
 		the \c demo subdirectory of the source tree.
 		It order to compile them, use <tt>--enable-demo</tt> configure option when
 		build the library.
 		*/
 		/**
 		@defgroup tools Standalone utility applications
 		Some utility applications are listed here.
 		The standard compilation procedure (<tt>./configure;make</tt>) will compile
 		them, as well.
 		*/

lemon/arg_parser.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.
+		 *
 		 */
 		#include <lemon/arg_parser.h>
 		namespace lemon {
 		  void ArgParser::_showHelp(void *p)
+		  {
 		    (static_cast<ArgParser*>(p))->showHelp();
 		    exit(1);
+		  }
 		  ArgParser::ArgParser(int argc, const char **argv) :_argc(argc), _argv(argv),
 		                                                     _command_name(argv[0]) {
 		    funcOption("-help","Print a short help message",_showHelp,this);
 		    synonym("help","-help");
 		    synonym("h","-help");
+		  }
 		  ArgParser::~ArgParser()
+		  {
 		    for(Opts::iterator i=_opts.begin();i!=_opts.end();++i)
 		      if(i->second.self_delete)
 		        switch(i->second.type) {
 		        case BOOL:
 		          delete i->second.bool_p;
 		          break;
 		        case STRING:
 		          delete i->second.string_p;
 		          break;
 		        case DOUBLE:
 		          delete i->second.double_p;
 		          break;
 		        case INTEGER:
 		          delete i->second.int_p;
 		          break;
 		        case UNKNOWN:
 		          break;
 		        case FUNC:
 		          break;
+		        }
+		  }
 		  ArgParser &ArgParser::intOption(const std::string &name,
 		                               const std::string &help,
 		                               int value, bool obl)
+		  {
 		    ParData p;
 		    p.int_p=new int(value);
 		    p.self_delete=true;
 		    p.help=help;
 		    p.type=INTEGER;
 		    p.mandatory=obl;
 		    _opts[name]=p;
 		    return *this;
+		  }
 		  ArgParser &ArgParser::doubleOption(const std::string &name,
 		                               const std::string &help,
 		                               double value, bool obl)
+		  {
 		    ParData p;
 		    p.double_p=new double(value);
 		    p.self_delete=true;
 		    p.help=help;
 		    p.type=DOUBLE;
 		    p.mandatory=obl;
 		    _opts[name]=p;
 		    return *this;
+		  }
 		  ArgParser &ArgParser::boolOption(const std::string &name,
 		                               const std::string &help,
 		                               bool value, bool obl)
+		  {
 		    ParData p;
 		    p.bool_p=new bool(value);
 		    p.self_delete=true;
 		    p.help=help;
 		    p.type=BOOL;
 		    p.mandatory=obl;
 		    _opts[name]=p;
 		    return *this;
+		  }
 		  ArgParser &ArgParser::stringOption(const std::string &name,
 		                               const std::string &help,
 		                               std::string value, bool obl)
+		  {
 		    ParData p;
 		    p.string_p=new std::string(value);
 		    p.self_delete=true;
 		    p.help=help;
 		    p.type=STRING;
 		    p.mandatory=obl;
 		    _opts[name]=p;
 		    return *this;
+		  }
 		  ArgParser &ArgParser::refOption(const std::string &name,
 		                               const std::string &help,
 		                               int &ref, bool obl)
+		  {
 		    ParData p;
 		    p.int_p=&ref;
 		    p.self_delete=false;
 		    p.help=help;
 		    p.type=INTEGER;
 		    p.mandatory=obl;
 		    _opts[name]=p;
 		    return *this;
+		  }
 		  ArgParser &ArgParser::refOption(const std::string &name,
 		                                  const std::string &help,
 		                                  double &ref, bool obl)
+		  {
 		    ParData p;
 		    p.double_p=&ref;
 		    p.self_delete=false;
 		    p.help=help;
 		    p.type=DOUBLE;
 		    p.mandatory=obl;
 		    _opts[name]=p;
 		    return *this;
+		  }
 		  ArgParser &ArgParser::refOption(const std::string &name,
 		                                  const std::string &help,
 		                                  bool &ref, bool obl)
+		  {
 		    ParData p;
 		    p.bool_p=&ref;
 		    p.self_delete=false;
 		    p.help=help;
 		    p.type=BOOL;
 		    p.mandatory=obl;
 		    _opts[name]=p;
 		    ref = false;
 		    return *this;
+		  }
 		  ArgParser &ArgParser::refOption(const std::string &name,
 		                               const std::string &help,
 		                               std::string &ref, bool obl)
+		  {
 		    ParData p;
 		    p.string_p=&ref;
 		    p.self_delete=false;
 		    p.help=help;
 		    p.type=STRING;
 		    p.mandatory=obl;
 		    _opts[name]=p;
 		    return *this;
+		  }
 		  ArgParser &ArgParser::funcOption(const std::string &name,
 		                               const std::string &help,
 		                               void (*func)(void *),void *data)
+		  {
 		    ParData p;
 		    p.func_p.p=func;
 		    p.func_p.data=data;
 		    p.self_delete=false;
 		    p.help=help;
 		    p.type=FUNC;
 		    p.mandatory=false;
 		    _opts[name]=p;
 		    return *this;
+		  }
 		  ArgParser &ArgParser::optionGroup(const std::string &group,
 		                                    const std::string &opt)
+		  {
 		    Opts::iterator i = _opts.find(opt);
 		    LEMON_ASSERT(i!=_opts.end(), "Unknown option: '"+opt+"'");
 		    LEMON_ASSERT(!(i->second.ingroup),
 		                 "Option already in option group: '"+opt+"'");
 		    GroupData &g=_groups[group];
 		    g.opts.push_back(opt);
 		    i->second.ingroup=true;
 		    return *this;
+		  }
 		  ArgParser &ArgParser::onlyOneGroup(const std::string &group)
+		  {
 		    GroupData &g=_groups[group];
 		    g.only_one=true;
 		    return *this;
+		  }
 		  ArgParser &ArgParser::synonym(const std::string &syn,
 		                                const std::string &opt)
+		  {
 		    Opts::iterator o = _opts.find(opt);
 		    Opts::iterator s = _opts.find(syn);
 		    LEMON_ASSERT(o!=_opts.end(), "Unknown option: '"+opt+"'");
 		    LEMON_ASSERT(s==_opts.end(), "Option already used: '"+syn+"'");
 		    ParData p;
 		    p.help=opt;
 		    p.mandatory=false;
 		    p.syn=true;
 		    _opts[syn]=p;
 		    o->second.has_syn=true;
 		    return *this;
+		  }
 		  ArgParser &ArgParser::mandatoryGroup(const std::string &group)
+		  {
 		    GroupData &g=_groups[group];
 		    g.mandatory=true;
 		    return *this;
+		  }
 		  ArgParser &ArgParser::other(const std::string &name,
 		                              const std::string &help)
+		  {
 		    _others_help.push_back(OtherArg(name,help));
 		    return *this;
+		  }
 		  void ArgParser::show(std::ostream &os,Opts::iterator i)
+		  {
 		    os << "-" << i->first;
 		    if(i->second.has_syn)
 		      for(Opts::iterator j=_opts.begin();j!=_opts.end();++j)
 		        if(j->second.syn&&j->second.help==i->first)
 		          os << "|-" << j->first;
 		    switch(i->second.type) {
 		    case STRING:
 		      os << " str";
 		      break;
 		    case INTEGER:
 		      os << " int";
 		      break;
 		    case DOUBLE:
 		      os << " num";
 		      break;
 		    default:
 		      break;
+		    }
+		  }
 		  void ArgParser::show(std::ostream &os,Groups::iterator i)
+		  {
 		    GroupData::Opts::iterator o=i->second.opts.begin();
 		    while(o!=i->second.opts.end()) {
 		      show(os,_opts.find(*o));
 		      ++o;
 		      if(o!=i->second.opts.end()) os<<'|';
+		    }
+		  }
 		  void ArgParser::showHelp(Opts::iterator i)
+		  {
 		    if(i->second.help.size()==0||i->second.syn) return;
 		    std::cerr << "  ";
 		    show(std::cerr,i);
 		    std::cerr << std::endl;
 		    std::cerr << "     " << i->second.help << std::endl;
+		  }
 		  void ArgParser::showHelp(std::vector<ArgParser::OtherArg>::iterator i)
+		  {
 		    if(i->help.size()==0) return;
 		    std::cerr << "  " << i->name << std::endl
 		              << "     " << i->help << std::endl;
+		  }
 		  void ArgParser::shortHelp()
+		  {
 		    const unsigned int LINE_LEN=77;
 		    const std::string indent("    ");
 		    std::cerr << "Usage:\n  " << _command_name;
 		    int pos=_command_name.size()+2;
 		    for(Groups::iterator g=_groups.begin();g!=_groups.end();++g) {
 		      std::ostringstream cstr;
 		      cstr << ' ';
 		      if(!g->second.mandatory) cstr << '[';
 		      show(cstr,g);
 		      if(!g->second.mandatory) cstr << ']';
 		      if(pos+cstr.str().size()>LINE_LEN) {
 		        std::cerr << std::endl << indent;
 		        pos=indent.size();
+		      }
 		      std::cerr << cstr.str();
 		      pos+=cstr.str().size();
+		    }
 		    for(Opts::iterator i=_opts.begin();i!=_opts.end();++i)
 		      if(!i->second.ingroup&&!i->second.syn) {
 		        std::ostringstream cstr;
 		        cstr << ' ';
 		        if(!i->second.mandatory) cstr << '[';
 		        show(cstr,i);
 		        if(!i->second.mandatory) cstr << ']';
 		        if(pos+cstr.str().size()>LINE_LEN) {
 		          std::cerr << std::endl << indent;
 		          pos=indent.size();
+		        }
 		        std::cerr << cstr.str();
 		        pos+=cstr.str().size();
+		      }
 		    for(std::vector<OtherArg>::iterator i=_others_help.begin();
 		        i!=_others_help.end();++i)
+		      {
 		        std::ostringstream cstr;
 		        cstr << ' ' << i->name;
 		        if(pos+cstr.str().size()>LINE_LEN) {
 		          std::cerr << std::endl << indent;
 		          pos=indent.size();
+		        }
 		        std::cerr << cstr.str();
 		        pos+=cstr.str().size();
+		      }
 		    std::cerr << std::endl;
+		  }
 		  void ArgParser::showHelp()
+		  {
 		    shortHelp();
 		    std::cerr << "Where:\n";
 		    for(std::vector<OtherArg>::iterator i=_others_help.begin();
 		        i!=_others_help.end();++i) showHelp(i);
 		    for(Opts::iterator i=_opts.begin();i!=_opts.end();++i) showHelp(i);
 		    exit(1);
+		  }
 		  void ArgParser::unknownOpt(std::string arg)
+		  {
 		    std::cerr << "\nUnknown option: " << arg << "\n";
 		    std::cerr << "\nType '" << _command_name <<
 		      " --help' to obtain a short summary on the usage.\n\n";
 		    exit(1);
+		  }
 		  void ArgParser::requiresValue(std::string arg, OptType t)
+		  {
 		    std::cerr << "Argument '" << arg << "' requires a";
 		    switch(t) {
 		    case STRING:
 		      std::cerr << " string";
 		      break;
 		    case INTEGER:
 		      std::cerr << "n integer";
 		      break;
 		    case DOUBLE:
 		      std::cerr << " floating point";
 		      break;
 		    default:
 		      break;
+		    }
 		    std::cerr << " value\n\n";
 		    showHelp();
+		  }
 		  void ArgParser::checkMandatories()
+		  {
 		    bool ok=true;
 		    for(Opts::iterator i=_opts.begin();i!=_opts.end();++i)
 		      if(i->second.mandatory&&!i->second.set)
+		        {
 		          if(ok)
 		            std::cerr << _command_name
 		                      << ": The following mandatory arguments are missing.\n";
 		          ok=false;
 		          showHelp(i);
+		        }
 		    for(Groups::iterator i=_groups.begin();i!=_groups.end();++i)
 		      if(i->second.mandatory||i->second.only_one)
+		        {
 		          int set=0;
 		          for(GroupData::Opts::iterator o=i->second.opts.begin();
 		              o!=i->second.opts.end();++o)
 		            if(_opts.find(*o)->second.set) ++set;
 		          if(i->second.mandatory&&!set) {
 		            std::cerr << _command_name
 		                      << ": At least one of the following arguments is mandatory.\n";
 		            std::cerr << _command_name <<
 		              ": At least one of the following arguments is mandatory.\n";
 		            ok=false;
 		            for(GroupData::Opts::iterator o=i->second.opts.begin();
 		                o!=i->second.opts.end();++o)
 		              showHelp(_opts.find(*o));
+		          }
 		          if(i->second.only_one&&set>1) {
 		            std::cerr << _command_name
 		                      << ": At most one of the following arguments can be given.\n";
 		            std::cerr << _command_name <<
 		              ": At most one of the following arguments can be given.\n";
 		            ok=false;
 		            for(GroupData::Opts::iterator o=i->second.opts.begin();
 		                o!=i->second.opts.end();++o)
 		              showHelp(_opts.find(*o));
+		          }
+		        }
 		    if(!ok) {
 		      std::cerr << "\nType '" << _command_name <<
 		        " --help' to obtain a short summary on the usage.\n\n";
 		      exit(1);
+		    }
+		  }
 		  ArgParser &ArgParser::parse()
+		  {
 		    for(int ar=1; ar<_argc; ++ar) {
 		      std::string arg(_argv[ar]);
 		      if (arg[0] != '-' || arg.size() == 1) {
 		        _file_args.push_back(arg);
+		      }
 		      else {
 		        Opts::iterator i = _opts.find(arg.substr(1));
 		        if(i==_opts.end()) unknownOpt(arg);
 		        else {
 		          if(i->second.syn) i=_opts.find(i->second.help);
 		          ParData &p(i->second);
 		          if (p.type==BOOL) *p.bool_p=true;
 		          else if (p.type==FUNC) p.func_p.p(p.func_p.data);
 		          else if(++ar==_argc) requiresValue(arg, p.type);
 		          else {
 		            std::string val(_argv[ar]);
 		            std::istringstream vals(val);
 		            switch(p.type) {
 		            case STRING:
 		              *p.string_p=val;
 		              break;
 		            case INTEGER:
 		              vals >> *p.int_p;
 		              break;
 		            case DOUBLE:
 		              vals >> *p.double_p;
 		              break;
 		            default:
 		              break;
+		            }
 		            if(p.type!=STRING&&(!vals||!vals.eof()))
 		              requiresValue(arg, p.type);
+		          }
 		          p.set = true;
+		        }
+		      }
+		    }
 		    checkMandatories();
 		    return *this;
+		  }
+		}

lemon/assert.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_ASSERT_H
 		#define LEMON_ASSERT_H
 		/// \ingroup exceptions
 		/// \file
 		/// \brief Extended assertion handling
 		#include <lemon/error.h>
 		namespace lemon {
 		  inline void assert_fail_log(const char *file, int line, const char *function,
 		                              const char *message, const char *assertion)
+		  {
 		    std::cerr << file << ":" << line << ": ";
 		    if (function)
 		      std::cerr << function << ": ";
 		    std::cerr << message;
 		    if (assertion)
 		      std::cerr << " (assertion '" << assertion << "' failed)";
 		    std::cerr << std::endl;
+		  }
 		  inline void assert_fail_abort(const char *file, int line,
 		                                const char *function, const char* message,
 		                                const char *assertion)
+		  {
 		    assert_fail_log(file, line, function, message, assertion);
 		    std::abort();
+		  }
 		  namespace _assert_bits {
 		    inline const char* cstringify(const std::string& str) {
 		      return str.c_str();
+		    }
 		    inline const char* cstringify(const char* str) {
 		      return str;
+		    }
+		  }
+		}
 		#endif // LEMON_ASSERT_H
 		#undef LEMON_ASSERT
 		#undef LEMON_FIXME
 		#undef LEMON_DEBUG
 		#if (defined(LEMON_ASSERT_LOG) ? 1 : 0) +                \
 		  (defined(LEMON_ASSERT_ABORT) ? 1 : 0) +                \
 		  (defined(LEMON_ASSERT_CUSTOM) ? 1 : 0) > 1
 		#error "LEMON assertion system is not set properly"
 		#endif
 		#if ((defined(LEMON_ASSERT_LOG) ? 1 : 0) +                \
 		     (defined(LEMON_ASSERT_ABORT) ? 1 : 0) +                \
 		     (defined(LEMON_ASSERT_CUSTOM) ? 1 : 0) == 1 ||        \
 		     defined(LEMON_ENABLE_ASSERTS)) &&                        \
 		  (defined(LEMON_DISABLE_ASSERTS) ||                        \
 		   defined(NDEBUG))
 		#error "LEMON assertion system is not set properly"
 		#endif
 		#if defined LEMON_ASSERT_LOG
 		#  undef LEMON_ASSERT_HANDLER
 		#  define LEMON_ASSERT_HANDLER ::lemon::assert_fail_log
 		#elif defined LEMON_ASSERT_ABORT
 		#  undef LEMON_ASSERT_HANDLER
 		#  define LEMON_ASSERT_HANDLER ::lemon::assert_fail_abort
 		#elif defined LEMON_ASSERT_CUSTOM
 		#  undef LEMON_ASSERT_HANDLER
 		#  ifndef LEMON_CUSTOM_ASSERT_HANDLER
 		#    error "LEMON_CUSTOM_ASSERT_HANDLER is not set"
 		#  endif
 		#  define LEMON_ASSERT_HANDLER LEMON_CUSTOM_ASSERT_HANDLER
 		#elif defined LEMON_DISABLE_ASSERTS
 		#  undef LEMON_ASSERT_HANDLER
 		#elif defined NDEBUG
 		#  undef LEMON_ASSERT_HANDLER
 		#else
 		#  define LEMON_ASSERT_HANDLER ::lemon::assert_fail_abort
 		#endif
 		#ifndef LEMON_FUNCTION_NAME
 		#  if defined __GNUC__
 		#    define LEMON_FUNCTION_NAME (__PRETTY_FUNCTION__)
 		#  elif defined _MSC_VER
 		#    define LEMON_FUNCTION_NAME (__FUNCSIG__)
 		#  else
 		#    define LEMON_FUNCTION_NAME (__func__)
 		#  endif
 		#endif
 		#ifdef DOXYGEN
 		/// \ingroup exceptions
 		///
 		/// \brief Macro for assertion with customizable message
 		///
 		/// Macro for assertion with customizable message.  \param exp An
 		/// expression that must be convertible to \c bool.  If it is \c
 		/// false, then an assertion is raised. The concrete behaviour depends
 		/// on the settings of the assertion system.  \param msg A <tt>const
 		/// char*</tt> parameter, which can be used to provide information
 		/// about the circumstances of the failed assertion.
 		///
 		/// The assertions are enabled in the default behaviour.
 		/// You can disable them with the following code:
 		/// \code
 		/// #define LEMON_DISABLE_ASSERTS
 		/// \endcode
 		/// or with compilation parameters:
 		/// \code
 		/// g++ -DLEMON_DISABLE_ASSERTS
 		/// make CXXFLAGS='-DLEMON_DISABLE_ASSERTS'
 		/// \endcode
 		/// The checking is also disabled when the standard macro \c NDEBUG is defined.
 		///
 		/// The LEMON assertion system has a wide range of customization
 		/// properties. As a default behaviour the failed assertion prints a
 		/// short log message to the standard error and aborts the execution.
 		///
 		/// The following modes can be used in the assertion system:
 		///
 		/// - \c LEMON_ASSERT_LOG The failed assertion prints a short log
 		///   message to the standard error and continues the execution.
 		/// - \c LEMON_ASSERT_ABORT This mode is similar to the \c
 		///   LEMON_ASSERT_LOG, but it aborts the program. It is the default
 		///   behaviour.
 		/// - \c LEMON_ASSERT_CUSTOM The user can define own assertion handler
 		///   function.
 		///   \code
 		///     void custom_assert_handler(const char* file, int line, const char* function,
 		///                                const char* message, const char* assertion);
 		///     void custom_assert_handler(const char* file, int line,
 		///                                const char* function, const char* message,
 		///                                const char* assertion);
 		///   \endcode
 		///   The name of the function should be defined as the \c
 		///   LEMON_CUSTOM_ASSERT_HANDLER macro name.
 		///   \code
 		///     #define LEMON_CUSTOM_ASSERT_HANDLER custom_assert_handler
 		///   \endcode
 		///   Whenever an assertion is occured, the custom assertion
 		///   handler is called with appropiate parameters.
 		///
 		/// The assertion mode can also be changed within one compilation unit.
 		/// If the macros are redefined with other settings and the
 		/// \ref lemon/assert.h "assert.h" file is reincluded, then the
 		/// behaviour is changed appropiately to the new settings.
 		#  define LEMON_ASSERT(exp, msg)                                        \
 		  (static_cast<void> (!!(exp) ? 0 : (                                        \
 		    LEMON_ASSERT_HANDLER(__FILE__, __LINE__,                                \
 		                         LEMON_FUNCTION_NAME,                                \
 		                         ::lemon::_assert_bits::cstringify(msg), #exp), 0)))
 		/// \ingroup exceptions
 		///
 		/// \brief Macro for mark not yet implemented features.
 		///
 		/// Macro for mark not yet implemented features and outstanding bugs.
 		/// It is close to be the shortcut of the following code:
 		/// \code
 		///   LEMON_ASSERT(false, msg);
 		/// \endcode
 		///
 		/// \see LEMON_ASSERT
 		#  define LEMON_FIXME(msg)                                                \
 		  (LEMON_ASSERT_HANDLER(__FILE__, __LINE__, LEMON_FUNCTION_NAME,        \
-		                        ::lemon::_assert_bits::cstringify(msg),                \
 		                        ::lemon::_assert_bits::cstringify(msg),          \
 		                        static_cast<const char*>(0)))
 		/// \ingroup exceptions
 		///
 		/// \brief Macro for internal assertions
 		///
 		/// Macro for internal assertions, it is used in the library to check
 		/// the consistency of results of algorithms, several pre- and
 		/// postconditions and invariants. The checking is disabled by
 		/// default, but it can be turned on with the macro \c
 		/// LEMON_ENABLE_DEBUG.
 		/// \code
 		/// #define LEMON_ENABLE_DEBUG
 		/// \endcode
 		/// or with compilation parameters:
 		/// \code
 		/// g++ -DLEMON_ENABLE_DEBUG
 		/// make CXXFLAGS='-DLEMON_ENABLE_DEBUG'
 		/// \endcode
 		///
 		/// This macro works like the \c LEMON_ASSERT macro, therefore the
 		/// current behaviour depends on the settings of \c LEMON_ASSERT
 		/// macro.
 		///
 		/// \see LEMON_ASSERT
 		#  define LEMON_DEBUG(exp, msg)                                                \
 		  (static_cast<void> (!!(exp) ? 0 : (                                        \
 		    LEMON_ASSERT_HANDLER(__FILE__, __LINE__,                            \
 		                         LEMON_FUNCTION_NAME,                                \
 		                         ::lemon::_assert_bits::cstringify(msg), #exp), 0)))
 		#else
 		#  ifndef LEMON_ASSERT_HANDLER
 		#    define LEMON_ASSERT(exp, msg)  (static_cast<void>(0))
 		#    define LEMON_FIXME(msg) (static_cast<void>(0))
 		#    define LEMON_DEBUG(exp, msg) (static_cast<void>(0))
 		#  else
 		#    define LEMON_ASSERT(exp, msg)                                        \
 		       (static_cast<void> (!!(exp) ? 0 : (                                \
 		        LEMON_ASSERT_HANDLER(__FILE__, __LINE__,                        \
 		                             LEMON_FUNCTION_NAME,                        \
 		                             ::lemon::_assert_bits::cstringify(msg),        \
 		                             #exp), 0)))
 		#    define LEMON_FIXME(msg)                                                \
 		       (LEMON_ASSERT_HANDLER(__FILE__, __LINE__, LEMON_FUNCTION_NAME,        \
 		                             ::lemon::_assert_bits::cstringify(msg),        \
 		                             static_cast<const char*>(0)))
 		#    if LEMON_ENABLE_DEBUG
 		#      define LEMON_DEBUG(exp, msg)
 		         (static_cast<void> (!!(exp) ? 0 : (         \
 		           LEMON_ASSERT_HANDLER(__FILE__, __LINE__,  \
 		                                LEMON_FUNCTION_NAME, \
-		                                ::lemon::_assert_bits::cstringify(msg),        \
 		                                ::lemon::_assert_bits::cstringify(msg),     \
 		                                #exp), 0)))
 		#    else
 		#      define LEMON_DEBUG(exp, msg) (static_cast<void>(0))
 		#    endif
 		#  endif
 		#endif
 		#ifdef DOXYGEN
 		#else
 		#endif

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/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
 		    ///\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
 		    ///The simplest way to execute the algorithm is to use
 		    ///one of the member functions called \c run(...).
 		    ///\n
 		    ///If you need more control on the execution,
 		    ///first you must call \ref init(), then you can add several source nodes
 		    ///with \ref addSource().
 		    ///Finally \ref start() will perform the actual path
 		    ///computation.
 		    ///@{
 		    ///\brief Initializes the internal data structures.
 		    ///
 		    ///Initializes the internal data structures.
 		    ///
 		    void init()
+		    {
 		      create_maps();
 		      _queue.resize(countNodes(*G));
 		      _queue_head=_queue_tail=0;
 		      _curr_dist=1;
 		      for ( NodeIt u(*G) ; u!=INVALID ; ++u ) {
 		        _pred->set(u,INVALID);
 		        _reached->set(u,false);
 		        _processed->set(u,false);
+		      }
+		    }
 		    ///Adds a new source node.
 		    ///Adds a new source node to the set of nodes to be processed.
 		    ///
 		    void addSource(Node s)
+		    {
 		      if(!(*_reached)[s])
+		        {
 		          _reached->set(s,true);
 		          _pred->set(s,INVALID);
 		          _dist->set(s,0);
 		          _queue[_queue_head++]=s;
 		          _queue_next_dist=_queue_head;
+		        }
+		    }
 		    ///Processes the next node.
 		    ///Processes the next node.
 		    ///
 		    ///\return The processed node.
 		    ///
 		    ///\warning The queue must not be empty!
 		    Node processNextNode()
+		    {
 		      if(_queue_tail==_queue_next_dist) {
 		        _curr_dist++;
 		        _queue_next_dist=_queue_head;
+		      }
 		      Node n=_queue[_queue_tail++];
 		      _processed->set(n,true);
 		      Node m;
 		      for(OutArcIt e(*G,n);e!=INVALID;++e)
 		        if(!(*_reached)[m=G->target(e)]) {
 		          _queue[_queue_head++]=m;
 		          _reached->set(m,true);
 		          _pred->set(m,e);
 		          _dist->set(m,_curr_dist);
+		        }
 		      return n;
+		    }
 		    ///Processes the next node.
 		    ///Processes the next node. And checks that the given target node
 		    ///is reached. If the target node is reachable from the processed
 		    ///node then the reached parameter will be set true. The reached
 		    ///parameter should be initially false.
 		    ///
 		    ///\param target The target node.
 		    ///\retval reach Indicates that the target node is reached.
 		    ///\return The processed node.
 		    ///
 		    ///\warning The queue must not be empty!
 		    Node processNextNode(Node target, bool& reach)
+		    {
 		      if(_queue_tail==_queue_next_dist) {
 		        _curr_dist++;
 		        _queue_next_dist=_queue_head;
+		      }
 		      Node n=_queue[_queue_tail++];
 		      _processed->set(n,true);
 		      Node m;
 		      for(OutArcIt e(*G,n);e!=INVALID;++e)
 		        if(!(*_reached)[m=G->target(e)]) {
 		          _queue[_queue_head++]=m;
 		          _reached->set(m,true);
 		          _pred->set(m,e);
 		          _dist->set(m,_curr_dist);
 		          reach = reach || (target == m);
+		        }
 		      return n;
+		    }
 		    ///Processes the next node.
 		    ///Processes the next node. And checks that at least one of
 		    ///reached node has true value in the \c nm node map. If one node
 		    ///with true value is reachable from the processed node then the
 		    ///rnode parameter will be set to the first of such nodes.
 		    ///
 		    ///\param nm The node map of possible targets.
 		    ///\retval rnode The reached target node.
 		    ///\return The processed node.
 		    ///
 		    ///\warning The queue must not be empty!
 		    template<class NM>
 		    Node processNextNode(const NM& nm, Node& rnode)
+		    {
 		      if(_queue_tail==_queue_next_dist) {
 		        _curr_dist++;
 		        _queue_next_dist=_queue_head;
+		      }
 		      Node n=_queue[_queue_tail++];
 		      _processed->set(n,true);
 		      Node m;
 		      for(OutArcIt e(*G,n);e!=INVALID;++e)
 		        if(!(*_reached)[m=G->target(e)]) {
 		          _queue[_queue_head++]=m;
 		          _reached->set(m,true);
 		          _pred->set(m,e);
 		          _dist->set(m,_curr_dist);
 		          if (nm[m] && rnode == INVALID) rnode = m;
+		        }
 		      return n;
+		    }
 		    ///Next node to be processed.
 		    ///Next node to be processed.
 		    ///
 		    ///\return The next node to be processed or INVALID if the queue is
 		    /// empty.
 		    Node nextNode()
+		    {
 		      return _queue_tail<_queue_head?_queue[_queue_tail]:INVALID;
+		    }
 		    ///\brief Returns \c false if there are nodes
 		    ///to be processed in the queue
 		    ///
 		    ///Returns \c false if there are nodes
 		    ///to be processed in the queue
 		    bool emptyQueue() { return _queue_tail==_queue_head; }
 		    ///Returns the number of the nodes to be processed.
 		    ///Returns the number of the nodes to be processed in the queue.
 		    int queueSize() { return _queue_head-_queue_tail; }
 		    ///Executes the algorithm.
 		    ///Executes the algorithm.
 		    ///
 		    ///\pre init() must be called and at least one node should be added
 		    ///with addSource() before using this function.
 		    ///
 		    ///This method runs the %BFS algorithm from the root node(s)
 		    ///in order to
 		    ///compute the
 		    ///shortest path to each node. The algorithm computes
 		    ///- The shortest path tree.
 		    ///- The distance of each node from the root(s).
 		    void start()
+		    {
 		      while ( !emptyQueue() ) processNextNode();
+		    }
 		    ///Executes the algorithm until \c dest is reached.
 		    ///Executes the algorithm until \c dest is reached.
 		    ///
 		    ///\pre init() must be called and at least one node should be added
 		    ///with addSource() before using this function.
 		    ///
 		    ///This method runs the %BFS algorithm from the root node(s)
 		    ///in order to compute the shortest path to \c dest.
 		    ///The algorithm computes
 		    ///- The shortest path to \c  dest.
 		    ///- The distance of \c dest from the root(s).
 		    void start(Node dest)
+		    {
 		      bool reach = false;
 		      while ( !emptyQueue() && !reach ) processNextNode(dest, reach);
+		    }
 		    ///Executes the algorithm until a condition is met.
 		    ///Executes the algorithm until a condition is met.
 		    ///
 		    ///\pre init() must be called and at least one node should be added
 		    ///with addSource() before using this function.
 		    ///
 		    ///\param nm must be a bool (or convertible) node map. The
 		    ///algorithm will stop when it reaches a node \c v with
 		    /// <tt>nm[v]</tt> true.
 		    ///
 		    ///\return The reached node \c v with <tt>nm[v]</tt> true or
 		    ///\c INVALID if no such node was found.
 		    template<class NM>
 		    Node start(const NM &nm)
+		    {
 		      Node rnode = INVALID;
 		      while ( !emptyQueue() && rnode == INVALID ) {
 		        processNextNode(nm, rnode);
+		      }
 		      return rnode;
+		    }
 		    ///Runs %BFS algorithm from node \c s.
 		    ///This method runs the %BFS algorithm from a root node \c s
 		    ///in order to
 		    ///compute the
 		    ///shortest path to each node. The algorithm computes
 		    ///- The shortest path tree.
 		    ///- The distance of each node from the root.
 		    ///
 		    ///\note b.run(s) is just a shortcut of the following code.
 		    ///\code
 		    ///  b.init();
 		    ///  b.addSource(s);
 		    ///  b.start();
 		    ///\endcode
 		    void run(Node s) {
 		      init();
 		      addSource(s);
 		      start();
+		    }
 		    ///Finds the shortest path between \c s and \c t.
 		    ///Finds the shortest path between \c s and \c t.
 		    ///
 		    ///\return The length of the shortest s---t path if there exists one,
 		    ///0 otherwise.
 		    ///\note Apart from the return value, b.run(s) is
 		    ///just a shortcut of the following code.
 		    ///\code
 		    ///  b.init();
 		    ///  b.addSource(s);
 		    ///  b.start(t);
 		    ///\endcode
 		    int run(Node s,Node t) {
 		      init();
 		      addSource(s);
 		      start(t);
 		      return reached(t) ? _curr_dist : 0;
+		    }
 		    ///@}
 		    ///\name Query Functions
 		    ///The result of the %BFS algorithm can be obtained using these
 		    ///functions.\n
 		    ///Before the use of these functions,
 		    ///either run() or start() must be calleb.
 		    ///@{
 		    typedef PredMapPath<Digraph, PredMap> Path;
 		    ///Gives back the shortest path.
 		    ///Gives back the shortest path.
 		    ///\pre The \c t should be reachable from the source.
 		    Path path(Node t)
+		    {
 		      return Path(*G, *_pred, t);
+		    }
 		    ///The distance of a node from the root(s).
 		    ///Returns the distance of a node from the root(s).
 		    ///\pre \ref run() must be called before using this function.
 		    ///\warning If node \c v in unreachable from the root(s) the return value
 		    ///of this function is undefined.
 		    int dist(Node v) const { return (*_dist)[v]; }
 		    ///Returns the 'previous arc' of the shortest path tree.
 		    ///For a node \c v it returns the 'previous arc'
 		    ///of the shortest path tree,
 		    ///i.e. it returns the last arc of a shortest path from the root(s) to \c
 		    ///v. It is \ref INVALID
 		    ///if \c v is unreachable from the root(s) or \c v is a root. The
 		    ///shortest path tree used here is equal to the shortest path tree used in
 		    ///\ref predNode().
 		    ///\pre Either \ref run() or \ref start() must be called before using
 		    ///this function.
 		    Arc predArc(Node v) const { return (*_pred)[v];}
 		    ///Returns the 'previous node' of the shortest path tree.
 		    ///For a node \c v it returns the 'previous node'
 		    ///of the shortest path tree,
 		    ///i.e. it returns the last but one node from a shortest path from the
 		    ///root(a) to \c /v.
 		    ///It is INVALID if \c v is unreachable from the root(s) or
 		    ///if \c v itself a root.
 		    ///The shortest path tree used here is equal to the shortest path
 		    ///tree used in \ref predArc().
 		    ///\pre Either \ref run() or \ref start() must be called before
 		    ///using this function.
 		    Node predNode(Node v) const { return (*_pred)[v]==INVALID ? INVALID:
 		                                  G->source((*_pred)[v]); }
 		    ///Returns a reference to the NodeMap of distances.
 		    ///Returns a reference to the NodeMap of distances.
 		    ///\pre Either \ref run() or \ref init() must
 		    ///be called before using this function.
 		    const DistMap &distMap() const { return *_dist;}
 		    ///Returns a reference to the shortest path tree map.
 		    ///Returns a reference to the NodeMap of the arcs of the
 		    ///shortest path tree.
 		    ///\pre Either \ref run() or \ref init()
 		    ///must be called before using this function.
 		    const PredMap &predMap() const { return *_pred;}
 		    ///Checks if a node is reachable from the root.
 		    ///Returns \c true if \c v is reachable from the root.
 		    ///\warning The source nodes are indicated as unreached.
 		    ///\pre Either \ref run() or \ref start()
 		    ///must be called before using this function.
 		    ///
 		    bool reached(Node v) { return (*_reached)[v]; }
 		    ///@}
 		  };
 		  ///Default traits class of Bfs function.
 		  ///Default traits class of Bfs function.
 		  ///\tparam GR Digraph type.
 		  template<class GR>
 		  struct BfsWizardDefaultTraits
+		  {
 		    ///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 NullMap<typename Digraph::Node,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
 		#ifdef DOXYGEN
 		    static PredMap *createPredMap(const GR &g)
 		#else
 		    static PredMap *createPredMap(const GR &)
 		#endif
+		    {
 		      return new PredMap();
+		    }
 		    ///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 NullMap<typename Digraph::Node,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
 		    ///\param g is the digraph, to which we would like to define
 		    ///the \ref DistMap
 		#ifdef DOXYGEN
 		    static DistMap *createDistMap(const GR &g)
 		#else
 		    static DistMap *createDistMap(const GR &)
 		#endif
+		    {
 		      return new DistMap();
+		    }
 		  };
 		  /// Default traits used by \ref BfsWizard
 		  /// To make it easier to use Bfs algorithm
 		  ///we have created a wizard class.
 		  /// This \ref BfsWizard class needs default traits,
 		  ///as well as the \ref Bfs class.
 		  /// The \ref BfsWizardBase is a class to be the default traits of the
 		  /// \ref BfsWizard class.
 		  template<class GR>
 		  class BfsWizardBase : public BfsWizardDefaultTraits<GR>
+		  {
 		    typedef BfsWizardDefaultTraits<GR> Base;
 		  protected:
 		    /// Type of the nodes in the digraph.
 		    typedef typename Base::Digraph::Node Node;
 		    /// Pointer to the underlying digraph.
 		    void *_g;
 		    ///Pointer to the map of reached nodes.
 		    void *_reached;
 		    ///Pointer to the map of processed nodes.
 		    void *_processed;
 		    ///Pointer to the map of predecessors arcs.
 		    void *_pred;
 		    ///Pointer to the map of distances.
 		    void *_dist;
 		    ///Pointer to the source node.
 		    Node _source;
 		    public:
 		    /// Constructor.
 		    /// This constructor does not require parameters, therefore it initiates
 		    /// all of the attributes to default values (0, INVALID).
 		    BfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0),
 		                           _dist(0), _source(INVALID) {}
 		    /// Constructor.
 		    /// This constructor requires some parameters,
 		    /// listed in the parameters list.
 		    /// Others are initiated to 0.
 		    /// \param g is the initial value of  \ref _g
 		    /// \param s is the initial value of  \ref _source
 		    BfsWizardBase(const GR &g, Node s=INVALID) :
 		      _g(reinterpret_cast<void*>(const_cast<GR*>(&g))),
 		      _reached(0), _processed(0), _pred(0), _dist(0), _source(s) {}
 		  };
 		  /// A class to make the usage of Bfs algorithm easier
 		  /// This class is created to make it easier to use Bfs algorithm.
 		  /// It uses the functions and features of the plain \ref Bfs,
 		  /// but it is much simpler to use it.
 		  ///
 		  /// Simplicity means that the way to change the types defined
 		  /// in the traits class is based on functions that returns the new class
 		  /// and not on templatable built-in classes.
 		  /// When using the plain \ref Bfs
 		  /// the new class with the modified type comes from
 		  /// the original class by using the ::
 		  /// operator. In the case of \ref BfsWizard only
 		  /// a function have to be called and it will
 		  /// return the needed class.
 		  ///
 		  /// It does not have own \ref run method. When its \ref run method is called
 		  /// it initiates a plain \ref Bfs class, and calls the \ref Bfs::run
 		  /// method of it.
 		  template<class TR>
 		  class BfsWizard : public TR
+		  {
 		    typedef TR Base;
 		    ///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 reached nodes
 		    typedef typename TR::ReachedMap ReachedMap;
 		    ///\brief The type of the map that stores
 		    ///the processed nodes
 		    typedef typename TR::ProcessedMap ProcessedMap;
 		    ///\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 that stores the dists of the nodes.
 		    typedef typename TR::DistMap DistMap;
 		  public:
 		    /// Constructor.
 		    BfsWizard() : TR() {}
 		    /// Constructor that requires parameters.
 		    /// Constructor that requires parameters.
 		    /// These parameters will be the default values for the traits class.
 		    BfsWizard(const Digraph &g, Node s=INVALID) :
 		      TR(g,s) {}
 		    ///Copy constructor
 		    BfsWizard(const TR &b) : TR(b) {}
 		    ~BfsWizard() {}
 		    ///Runs Bfs algorithm from a given node.
 		    ///Runs Bfs algorithm from a given node.
 		    ///The node can be given by the \ref source function.
 		    void run()
+		    {
 		      if(Base::_source==INVALID) throw UninitializedParameter();
 		      Bfs<Digraph,TR> alg(*reinterpret_cast<const Digraph*>(Base::_g));
 		      if(Base::_reached)
 		        alg.reachedMap(*reinterpret_cast<ReachedMap*>(Base::_reached));
 		      if(Base::_processed)
 		        alg.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));
 		      if(Base::_pred)
 		        alg.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
 		      if(Base::_dist)
 		        alg.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
 		      alg.run(Base::_source);
+		    }
 		    ///Runs Bfs algorithm from the given node.
 		    ///Runs Bfs algorithm from the given node.
 		    ///\param s is the given source.
 		    void run(Node s)
+		    {
 		      Base::_source=s;
 		      run();
+		    }
 		    template<class T>
 		    struct DefPredMapBase : public Base {
 		      typedef T PredMap;
 		      static PredMap *createPredMap(const Digraph &) { return 0; };
 		      DefPredMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-templ-param "Named parameter"
 		    ///function for setting PredMap
 		    ///
 		    /// \ref named-templ-param "Named parameter"
 		    ///function for setting PredMap
 		    ///
 		    template<class T>
 		    BfsWizard<DefPredMapBase<T> > predMap(const T &t)
+		    {
 		      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
 		      return BfsWizard<DefPredMapBase<T> >(*this);
+		    }
 		    template<class T>
 		    struct DefReachedMapBase : public Base {
 		      typedef T ReachedMap;
 		      static ReachedMap *createReachedMap(const Digraph &) { return 0; };
 		      DefReachedMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-templ-param "Named parameter"
 		    ///function for setting ReachedMap
 		    ///
 		    /// \ref named-templ-param "Named parameter"
 		    ///function for setting ReachedMap
 		    ///
 		    template<class T>
 		    BfsWizard<DefReachedMapBase<T> > reachedMap(const T &t)
+		    {
 		      Base::_reached=reinterpret_cast<void*>(const_cast<T*>(&t));
 		      return BfsWizard<DefReachedMapBase<T> >(*this);
+		    }
 		    template<class T>
 		    struct DefProcessedMapBase : public Base {
 		      typedef T ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &) { return 0; };
 		      DefProcessedMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-templ-param "Named parameter"
 		    ///function for setting ProcessedMap
 		    ///
 		    /// \ref named-templ-param "Named parameter"
 		    ///function for setting ProcessedMap
 		    ///
 		    template<class T>
 		    BfsWizard<DefProcessedMapBase<T> > processedMap(const T &t)
+		    {
 		      Base::_processed=reinterpret_cast<void*>(const_cast<T*>(&t));
 		      return BfsWizard<DefProcessedMapBase<T> >(*this);
+		    }
 		    template<class T>
 		    struct DefDistMapBase : public Base {
 		      typedef T DistMap;
 		      static DistMap *createDistMap(const Digraph &) { return 0; };
 		      DefDistMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-templ-param "Named parameter"
 		    ///function for setting DistMap type
 		    ///
 		    /// \ref named-templ-param "Named parameter"
 		    ///function for setting DistMap type
 		    ///
 		    template<class T>
 		    BfsWizard<DefDistMapBase<T> > distMap(const T &t)
+		    {
 		      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
 		      return BfsWizard<DefDistMapBase<T> >(*this);
+		    }
 		    /// Sets the source node, from which the Bfs algorithm runs.
 		    /// Sets the source node, from which the Bfs algorithm runs.
 		    /// \param s is the source node.
 		    BfsWizard<TR> &source(Node s)
+		    {
 		      Base::_source=s;
 		      return *this;
+		    }
 		  };
 		  ///Function type interface for Bfs algorithm.
 		  /// \ingroup search
 		  ///Function type interface for Bfs algorithm.
 		  ///
 		  ///This function also has several
 		  ///\ref named-templ-func-param "named parameters",
 		  ///they are declared as the members of class \ref BfsWizard.
 		  ///The following
 		  ///example shows how to use these parameters.
 		  ///\code
 		  ///  bfs(g,source).predMap(preds).run();
 		  ///\endcode
 		  ///\warning Don't forget to put the \ref BfsWizard::run() "run()"
 		  ///to the end of the parameter list.
 		  ///\sa BfsWizard
 		  ///\sa Bfs
 		  template<class GR>
 		  BfsWizard<BfsWizardBase<GR> >
 		  bfs(const GR &g,typename GR::Node s=INVALID)
+		  {
 		    return BfsWizard<BfsWizardBase<GR> >(g,s);
+		  }
 		#ifdef DOXYGEN
 		  /// \brief Visitor class for bfs.
 		  ///
 		  /// This class defines the interface of the BfsVisit events, and
 		  /// it could be the base of a real Visitor class.
 		  template <typename _Digraph>
 		  struct BfsVisitor {
 		    typedef _Digraph Digraph;
 		    typedef typename Digraph::Arc Arc;
 		    typedef typename Digraph::Node Node;
 		    /// \brief Called when the arc reach a node.
 		    ///
 		    /// It is called when the bfs find an arc which target is not
 		    /// reached yet.
 		    void discover(const Arc& arc) {}
 		    /// \brief Called when the node reached first time.
 		    ///
 		    /// It is Called when the node reached first time.
 		    void reach(const Node& node) {}
 		    /// \brief Called when the arc examined but target of the arc
 		    /// already discovered.
 		    ///
 		    /// It called when the arc examined but the target of the arc
 		    /// already discovered.
 		    void examine(const Arc& arc) {}
 		    /// \brief Called for the source node of the bfs.
 		    ///
 		    /// It is called for the source node of the bfs.
 		    void start(const Node& node) {}
 		    /// \brief Called when the node processed.
 		    ///
 		    /// It is Called when the node processed.
 		    void process(const Node& node) {}
 		  };
 		#else
 		  template <typename _Digraph>
 		  struct BfsVisitor {
 		    typedef _Digraph Digraph;
 		    typedef typename Digraph::Arc Arc;
 		    typedef typename Digraph::Node Node;
 		    void discover(const Arc&) {}
 		    void reach(const Node&) {}
 		    void examine(const Arc&) {}
 		    void start(const Node&) {}
 		    void process(const Node&) {}
 		    template <typename _Visitor>
 		    struct Constraints {
 		      void constraints() {
 		        Arc arc;
 		        Node node;
 		        visitor.discover(arc);
 		        visitor.reach(node);
 		        visitor.examine(arc);
 		        visitor.start(node);
 		        visitor.process(node);
+		      }
 		      _Visitor& visitor;
 		    };
 		  };
 		#endif
 		  /// \brief Default traits class of BfsVisit class.
 		  ///
 		  /// Default traits class of BfsVisit class.
 		  /// \tparam _Digraph Digraph type.
 		  template<class _Digraph>
 		  struct BfsVisitDefaultTraits {
 		    /// \brief The digraph type the algorithm runs on.
 		    typedef _Digraph Digraph;
 		    /// \brief 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;
 		    /// \brief Instantiates a ReachedMap.
 		    ///
 		    /// This function instantiates a \ref ReachedMap.
 		    /// \param digraph is the digraph, to which
 		    /// we would like to define the \ref ReachedMap.
 		    static ReachedMap *createReachedMap(const Digraph &digraph) {
 		      return new ReachedMap(digraph);
+		    }
 		  };
 		  /// \ingroup search
 		  ///
 		  /// \brief %BFS Visit algorithm class.
 		  ///
 		  /// This class provides an efficient implementation of the %BFS algorithm
 		  /// with visitor interface.
 		  ///
 		  /// The %BfsVisit class provides an alternative interface to the Bfs
 		  /// class. It works with callback mechanism, the BfsVisit object calls
 		  /// on every bfs event the \c Visitor class member functions.
 		  ///
-		  /// \tparam _Digraph The digraph type the algorithm runs on. The default value is
 		  /// \tparam _Digraph The digraph type the algorithm runs on.
 		  /// The default value is
 		  /// \ref ListDigraph. The value of _Digraph is not used directly by Bfs, it
 		  /// is only passed to \ref BfsDefaultTraits.
 		  /// \tparam _Visitor The Visitor object for the algorithm. The
 		  /// \ref BfsVisitor "BfsVisitor<_Digraph>" is an empty Visitor which
 		  /// does not observe the Bfs events. If you want to observe the bfs
 		  /// events you should implement your own Visitor class.
 		  /// \tparam _Traits Traits class to set various data types used by the
 		  /// algorithm. The default traits class is
 		  /// \ref BfsVisitDefaultTraits "BfsVisitDefaultTraits<_Digraph>".
 		  /// See \ref BfsVisitDefaultTraits for the documentation of
 		  /// a Bfs visit traits class.
 		#ifdef DOXYGEN
 		  template <typename _Digraph, typename _Visitor, typename _Traits>
 		#else
 		  template <typename _Digraph = ListDigraph,
 		            typename _Visitor = BfsVisitor<_Digraph>,
 		            typename _Traits = BfsDefaultTraits<_Digraph> >
 		#endif
 		  class BfsVisit {
 		  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::BfsVisit::UninitializedParameter";
+		      }
 		    };
 		    typedef _Traits Traits;
 		    typedef typename Traits::Digraph Digraph;
 		    typedef _Visitor Visitor;
 		    ///The type of the map indicating which nodes are reached.
 		    typedef typename Traits::ReachedMap ReachedMap;
 		  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 *_digraph;
 		    /// Pointer to the visitor object.
 		    Visitor *_visitor;
 		    ///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;
 		    std::vector<typename Digraph::Node> _list;
 		    int _list_front, _list_back;
 		    /// \brief Creates the maps if necessary.
 		    ///
 		    /// Creates the maps if necessary.
 		    void create_maps() {
 		      if(!_reached) {
 		        local_reached = true;
 		        _reached = Traits::createReachedMap(*_digraph);
+		      }
+		    }
 		  protected:
 		    BfsVisit() {}
 		  public:
 		    typedef BfsVisit Create;
 		    /// \name Named template parameters
 		    ///@{
 		    template <class T>
 		    struct DefReachedMapTraits : public Traits {
 		      typedef T ReachedMap;
 		      static ReachedMap *createReachedMap(const Digraph &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 BfsVisit< Digraph, Visitor,
 		                                            DefReachedMapTraits<T> > {
 		      typedef BfsVisit< Digraph, Visitor, DefReachedMapTraits<T> > Create;
 		    };
 		    ///@}
 		  public:
 		    /// \brief Constructor.
 		    ///
 		    /// Constructor.
 		    ///
 		    /// \param digraph the digraph the algorithm will run on.
 		    /// \param visitor The visitor of the algorithm.
 		    ///
 		    BfsVisit(const Digraph& digraph, Visitor& visitor)
 		      : _digraph(&digraph), _visitor(&visitor),
 		        _reached(0), local_reached(false) {}
 		    /// \brief Destructor.
 		    ///
 		    /// Destructor.
 		    ~BfsVisit() {
 		      if(local_reached) delete _reached;
+		    }
 		    /// \brief 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>
 		    BfsVisit &reachedMap(ReachedMap &m) {
 		      if(local_reached) {
 		        delete _reached;
 		        local_reached = false;
+		      }
 		      _reached = &m;
 		      return *this;
+		    }
 		  public:
 		    /// \name Execution control
 		    /// The simplest way to execute the algorithm is to use
 		    /// one of the member functions called \c run(...).
 		    /// \n
 		    /// If you need more control on the execution,
 		    /// first you must call \ref init(), then you can adda source node
 		    /// with \ref addSource().
 		    /// Finally \ref start() will perform the actual path
 		    /// computation.
 		    /// @{
 		    /// \brief Initializes the internal data structures.
 		    ///
 		    /// Initializes the internal data structures.
 		    ///
 		    void init() {
 		      create_maps();
 		      _list.resize(countNodes(*_digraph));
 		      _list_front = _list_back = -1;
 		      for (NodeIt u(*_digraph) ; u != INVALID ; ++u) {
 		        _reached->set(u, false);
+		      }
+		    }
 		    /// \brief Adds a new source node.
 		    ///
 		    /// Adds a new source node to the set of nodes to be processed.
 		    void addSource(Node s) {
 		      if(!(*_reached)[s]) {
 		          _reached->set(s,true);
 		          _visitor->start(s);
 		          _visitor->reach(s);
 		          _list[++_list_back] = s;
+		        }
+		    }
 		    /// \brief Processes the next node.
 		    ///
 		    /// Processes the next node.
 		    ///
 		    /// \return The processed node.
 		    ///
 		    /// \pre The queue must not be empty!
 		    Node processNextNode() {
 		      Node n = _list[++_list_front];
 		      _visitor->process(n);
 		      Arc e;
 		      for (_digraph->firstOut(e, n); e != INVALID; _digraph->nextOut(e)) {
 		        Node m = _digraph->target(e);
 		        if (!(*_reached)[m]) {
 		          _visitor->discover(e);
 		          _visitor->reach(m);
 		          _reached->set(m, true);
 		          _list[++_list_back] = m;
 		        } else {
 		          _visitor->examine(e);
+		        }
+		      }
 		      return n;
+		    }
 		    /// \brief Processes the next node.
 		    ///
 		    /// Processes the next node. And checks that the given target node
 		    /// is reached. If the target node is reachable from the processed
 		    /// node then the reached parameter will be set true. The reached
 		    /// parameter should be initially false.
 		    ///
 		    /// \param target The target node.
 		    /// \retval reach Indicates that the target node is reached.
 		    /// \return The processed node.
 		    ///
 		    /// \warning The queue must not be empty!
 		    Node processNextNode(Node target, bool& reach) {
 		      Node n = _list[++_list_front];
 		      _visitor->process(n);
 		      Arc e;
 		      for (_digraph->firstOut(e, n); e != INVALID; _digraph->nextOut(e)) {
 		        Node m = _digraph->target(e);
 		        if (!(*_reached)[m]) {
 		          _visitor->discover(e);
 		          _visitor->reach(m);
 		          _reached->set(m, true);
 		          _list[++_list_back] = m;
 		          reach = reach || (target == m);
 		        } else {
 		          _visitor->examine(e);
+		        }
+		      }
 		      return n;
+		    }
 		    /// \brief Processes the next node.
 		    ///
 		    /// Processes the next node. And checks that at least one of
 		    /// reached node has true value in the \c nm node map. If one node
 		    /// with true value is reachable from the processed node then the
 		    /// rnode parameter will be set to the first of such nodes.
 		    ///
 		    /// \param nm The node map of possible targets.
 		    /// \retval rnode The reached target node.
 		    /// \return The processed node.
 		    ///
 		    /// \warning The queue must not be empty!
 		    template <typename NM>
 		    Node processNextNode(const NM& nm, Node& rnode) {
 		      Node n = _list[++_list_front];
 		      _visitor->process(n);
 		      Arc e;
 		      for (_digraph->firstOut(e, n); e != INVALID; _digraph->nextOut(e)) {
 		        Node m = _digraph->target(e);
 		        if (!(*_reached)[m]) {
 		          _visitor->discover(e);
 		          _visitor->reach(m);
 		          _reached->set(m, true);
 		          _list[++_list_back] = m;
 		          if (nm[m] && rnode == INVALID) rnode = m;
 		        } else {
 		          _visitor->examine(e);
+		        }
+		      }
 		      return n;
+		    }
 		    /// \brief Next node to be processed.
 		    ///
 		    /// Next node to be processed.
 		    ///
 		    /// \return The next node to be processed or INVALID if the stack is
 		    /// empty.
 		    Node nextNode() {
 		      return _list_front != _list_back ? _list[_list_front + 1] : INVALID;
+		    }
 		    /// \brief Returns \c false if there are nodes
 		    /// to be processed in the queue
 		    ///
 		    /// Returns \c false if there are nodes
 		    /// to be processed in the queue
 		    bool emptyQueue() { return _list_front == _list_back; }
 		    /// \brief Returns the number of the nodes to be processed.
 		    ///
 		    /// Returns the number of the nodes to be processed in the queue.
 		    int queueSize() { return _list_back - _list_front; }
 		    /// \brief Executes the algorithm.
 		    ///
 		    /// Executes the algorithm.
 		    ///
 		    /// \pre init() must be called and at least one node should be added
 		    /// with addSource() before using this function.
 		    void start() {
 		      while ( !emptyQueue() ) processNextNode();
+		    }
 		    /// \brief Executes the algorithm until \c dest is reached.
 		    ///
 		    /// Executes the algorithm until \c dest is reached.
 		    ///
 		    /// \pre init() must be called and at least one node should be added
 		    /// with addSource() before using this function.
 		    void start(Node dest) {
 		      bool reach = false;
 		      while ( !emptyQueue() && !reach ) processNextNode(dest, reach);
+		    }
 		    /// \brief Executes the algorithm until a condition is met.
 		    ///
 		    /// Executes the algorithm until a condition is met.
 		    ///
 		    /// \pre init() must be called and at least one node should be added
 		    /// with addSource() before using this function.
 		    ///
 		    ///\param nm must be a bool (or convertible) node map. The
 		    ///algorithm will stop when it reaches a node \c v with
 		    /// <tt>nm[v]</tt> true.
 		    ///
 		    ///\return The reached node \c v with <tt>nm[v]</tt> true or
 		    ///\c INVALID if no such node was found.
 		    template <typename NM>
 		    Node start(const NM &nm) {
 		      Node rnode = INVALID;
 		      while ( !emptyQueue() && rnode == INVALID ) {
 		        processNextNode(nm, rnode);
+		      }
 		      return rnode;
+		    }
 		    /// \brief Runs %BFSVisit algorithm from node \c s.
 		    ///
 		    /// This method runs the %BFS algorithm from a root node \c s.
 		    /// \note b.run(s) is just a shortcut of the following code.
 		    ///\code
 		    ///   b.init();
 		    ///   b.addSource(s);
 		    ///   b.start();
 		    ///\endcode
 		    void run(Node s) {
 		      init();
 		      addSource(s);
 		      start();
+		    }
 		    /// \brief Runs %BFSVisit algorithm to visit all nodes in the digraph.
 		    ///
 		    /// This method runs the %BFS algorithm in order to
 		    /// compute the %BFS path to each node. The algorithm computes
 		    /// - The %BFS tree.
 		    /// - The distance of each node from the root in the %BFS tree.
 		    ///
 		    ///\note b.run() is just a shortcut of the following code.
 		    ///\code
 		    ///  b.init();
 		    ///  for (NodeIt it(digraph); it != INVALID; ++it) {
 		    ///    if (!b.reached(it)) {
 		    ///      b.addSource(it);
 		    ///      b.start();
 		    ///    }
 		    ///  }
 		    ///\endcode
 		    void run() {
 		      init();
 		      for (NodeIt it(*_digraph); it != INVALID; ++it) {
 		        if (!reached(it)) {
 		          addSource(it);
 		          start();
+		        }
+		      }
+		    }
 		    ///@}
 		    /// \name Query Functions
 		    /// The result of the %BFS algorithm can be obtained using these
 		    /// functions.\n
 		    /// Before the use of these functions,
 		    /// either run() or start() must be called.
 		    ///@{
 		    /// \brief Checks if a node is reachable from the root.
 		    ///
 		    /// Returns \c true if \c v is reachable from the root(s).
 		    /// \warning The source nodes are inditated as unreachable.
 		    /// \pre Either \ref run() or \ref start()
 		    /// must be called before using this function.
 		    ///
 		    bool reached(Node v) { return (*_reached)[v]; }
 		    ///@}
 		  };
 		} //END OF NAMESPACE LEMON
 		#endif

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/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;
-		      /// The value type of the map. (The type of objects associated with the keys).
+		      /// \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;
-		      /// The value type of the map. (The type of objects associated with the keys).
+		      /// \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;
-		      /// The value type of the map. (The type of objects associated with the keys).
+		      /// \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;
-		      /// The value type of the map. (The type of objects associated with the keys).
+		      /// \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/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/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
 		    ///\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;
+		    }
 		  public:
 		    ///\name Execution control
 		    ///The simplest way to execute the algorithm is to use
 		    ///one of the member functions called \c run(...).
 		    ///\n
 		    ///If you need more control on the execution,
 		    ///first you must call \ref init(), then you can add a source node
 		    ///with \ref addSource().
 		    ///Finally \ref start() will perform the actual path
 		    ///computation.
 		    ///@{
 		    ///Initializes the internal data structures.
 		    ///Initializes the internal data structures.
 		    ///
 		    void init()
+		    {
 		      create_maps();
 		      _stack.resize(countNodes(*G));
 		      _stack_head=-1;
 		      for ( NodeIt u(*G) ; u!=INVALID ; ++u ) {
 		        _pred->set(u,INVALID);
 		        // _predNode->set(u,INVALID);
 		        _reached->set(u,false);
 		        _processed->set(u,false);
+		      }
+		    }
 		    ///Adds a new source node.
 		    ///Adds a new source node to the set of nodes to be processed.
 		    ///
 		    ///\warning dists are wrong (or at least strange)
 		    ///in case of multiple sources.
 		    void addSource(Node s)
+		    {
 		      if(!(*_reached)[s])
+		        {
 		          _reached->set(s,true);
 		          _pred->set(s,INVALID);
 		          OutArcIt e(*G,s);
 		          if(e!=INVALID) {
 		            _stack[++_stack_head]=e;
 		            _dist->set(s,_stack_head);
+		          }
 		          else {
 		            _processed->set(s,true);
 		            _dist->set(s,0);
+		          }
+		        }
+		    }
 		    ///Processes the next arc.
 		    ///Processes the next arc.
 		    ///
 		    ///\return The processed arc.
 		    ///
 		    ///\pre The stack must not be empty!
 		    Arc processNextArc()
+		    {
 		      Node m;
 		      Arc e=_stack[_stack_head];
 		      if(!(*_reached)[m=G->target(e)]) {
 		        _pred->set(m,e);
 		        _reached->set(m,true);
 		        ++_stack_head;
 		        _stack[_stack_head] = OutArcIt(*G, m);
 		        _dist->set(m,_stack_head);
+		      }
 		      else {
 		        m=G->source(e);
 		        ++_stack[_stack_head];
+		      }
 		      while(_stack_head>=0 && _stack[_stack_head]==INVALID) {
 		        _processed->set(m,true);
 		        --_stack_head;
 		        if(_stack_head>=0) {
 		          m=G->source(_stack[_stack_head]);
 		          ++_stack[_stack_head];
+		        }
+		      }
 		      return e;
+		    }
 		    ///Next arc to be processed.
 		    ///Next arc to be processed.
 		    ///
 		    ///\return The next arc to be processed or INVALID if the stack is
 		    /// empty.
 		    OutArcIt nextArc()
+		    {
 		      return _stack_head>=0?_stack[_stack_head]:INVALID;
+		    }
 		    ///\brief Returns \c false if there are nodes
 		    ///to be processed in the queue
 		    ///
 		    ///Returns \c false if there are nodes
 		    ///to be processed in the queue
 		    bool emptyQueue() { return _stack_head<0; }
 		    ///Returns the number of the nodes to be processed.
 		    ///Returns the number of the nodes to be processed in the queue.
 		    int queueSize() { return _stack_head+1; }
 		    ///Executes the algorithm.
 		    ///Executes the algorithm.
 		    ///
 		    ///\pre init() must be called and at least one node should be added
 		    ///with addSource() before using this function.
 		    ///
 		    ///This method runs the %DFS algorithm from the root node(s)
 		    ///in order to
 		    ///compute the
 		    ///%DFS path to each node. The algorithm computes
 		    ///- The %DFS tree.
 		    ///- The distance of each node from the root(s) in the %DFS tree.
 		    ///
 		    void start()
+		    {
 		      while ( !emptyQueue() ) processNextArc();
+		    }
 		    ///Executes the algorithm until \c dest is reached.
 		    ///Executes the algorithm until \c dest is reached.
 		    ///
 		    ///\pre init() must be called and at least one node should be added
 		    ///with addSource() before using this function.
 		    ///
 		    ///This method runs the %DFS algorithm from the root node(s)
 		    ///in order to
 		    ///compute the
 		    ///%DFS path to \c dest. The algorithm computes
 		    ///- The %DFS path to \c  dest.
 		    ///- The distance of \c dest from the root(s) in the %DFS tree.
 		    ///
 		    void start(Node dest)
+		    {
 		      while ( !emptyQueue() && G->target(_stack[_stack_head])!=dest )
 		        processNextArc();
+		    }
 		    ///Executes the algorithm until a condition is met.
 		    ///Executes the algorithm until a condition is met.
 		    ///
 		    ///\pre init() must be called and at least one node should be added
 		    ///with addSource() before using this function.
 		    ///
 		    ///\param em must be a bool (or convertible) arc map. The algorithm
 		    ///will stop when it reaches an arc \c e with <tt>em[e]</tt> true.
 		    ///
 		    ///\return The reached arc \c e with <tt>em[e]</tt> true or
 		    ///\c INVALID if no such arc was found.
 		    ///
 		    ///\warning Contrary to \ref Bfs and \ref Dijkstra, \c em is an arc map,
 		    ///not a node map.
 		    template<class EM>
 		    Arc start(const EM &em)
+		    {
 		      while ( !emptyQueue() && !em[_stack[_stack_head]] )
 		        processNextArc();
 		      return emptyQueue() ? INVALID : _stack[_stack_head];
+		    }
 		    ///Runs %DFS algorithm to visit all nodes in the digraph.
 		    ///This method runs the %DFS algorithm in order to
 		    ///compute the
 		    ///%DFS path to each node. The algorithm computes
 		    ///- The %DFS tree.
 		    ///- The distance of each node from the root in the %DFS tree.
 		    ///
 		    ///\note d.run() is just a shortcut of the following code.
 		    ///\code
 		    ///  d.init();
 		    ///  for (NodeIt it(digraph); it != INVALID; ++it) {
 		    ///    if (!d.reached(it)) {
 		    ///      d.addSource(it);
 		    ///      d.start();
 		    ///    }
 		    ///  }
 		    ///\endcode
 		    void run() {
 		      init();
 		      for (NodeIt it(*G); it != INVALID; ++it) {
 		        if (!reached(it)) {
 		          addSource(it);
 		          start();
+		        }
+		      }
+		    }
 		    ///Runs %DFS algorithm from node \c s.
 		    ///This method runs the %DFS algorithm from a root node \c s
 		    ///in order to
 		    ///compute the
 		    ///%DFS path to each node. The algorithm computes
 		    ///- The %DFS tree.
 		    ///- The distance of each node from the root in the %DFS tree.
 		    ///
 		    ///\note d.run(s) is just a shortcut of the following code.
 		    ///\code
 		    ///  d.init();
 		    ///  d.addSource(s);
 		    ///  d.start();
 		    ///\endcode
 		    void run(Node s) {
 		      init();
 		      addSource(s);
 		      start();
+		    }
 		    ///Finds the %DFS path between \c s and \c t.
 		    ///Finds the %DFS path between \c s and \c t.
 		    ///
 		    ///\return The length of the %DFS s---t path if there exists one,
 		    ///0 otherwise.
 		    ///\note Apart from the return value, d.run(s,t) is
 		    ///just a shortcut of the following code.
 		    ///\code
 		    ///  d.init();
 		    ///  d.addSource(s);
 		    ///  d.start(t);
 		    ///\endcode
 		    int run(Node s,Node t) {
 		      init();
 		      addSource(s);
 		      start(t);
 		      return reached(t)?_stack_head+1:0;
+		    }
 		    ///@}
 		    ///\name Query Functions
 		    ///The result of the %DFS algorithm can be obtained using these
 		    ///functions.\n
 		    ///Before the use of these functions,
 		    ///either run() or start() must be called.
 		    ///@{
 		    typedef PredMapPath<Digraph, PredMap> Path;
 		    ///Gives back the shortest path.
 		    ///Gives back the shortest path.
 		    ///\pre The \c t should be reachable from the source.
 		    Path path(Node t)
+		    {
 		      return Path(*G, *_pred, t);
+		    }
 		    ///The distance of a node from the root(s).
 		    ///Returns the distance of a node from the root(s).
 		    ///\pre \ref run() must be called before using this function.
 		    ///\warning If node \c v is unreachable from the root(s) then the return
 		    ///value of this funcion is undefined.
 		    int dist(Node v) const { return (*_dist)[v]; }
 		    ///Returns the 'previous arc' of the %DFS tree.
 		    ///For a node \c v it returns the 'previous arc'
 		    ///of the %DFS path,
 		    ///i.e. it returns the last arc of a %DFS path from the root(s) to \c
 		    ///v. It is \ref INVALID
 		    ///if \c v is unreachable from the root(s) or \c v is a root. The
 		    ///%DFS tree used here is equal to the %DFS tree used in
 		    ///\ref predNode().
 		    ///\pre Either \ref run() or \ref start() must be called before using
 		    ///this function.
 		    Arc predArc(Node v) const { return (*_pred)[v];}
 		    ///Returns the 'previous node' of the %DFS tree.
 		    ///For a node \c v it returns the 'previous node'
 		    ///of the %DFS tree,
 		    ///i.e. it returns the last but one node from a %DFS path from the
 		    ///root(s) to \c v.
 		    ///It is INVALID if \c v is unreachable from the root(s) or
 		    ///if \c v itself a root.
 		    ///The %DFS tree used here is equal to the %DFS
 		    ///tree used in \ref predArc().
 		    ///\pre Either \ref run() or \ref start() must be called before
 		    ///using this function.
 		    Node predNode(Node v) const { return (*_pred)[v]==INVALID ? INVALID:
 		                                  G->source((*_pred)[v]); }
 		    ///Returns a reference to the NodeMap of distances.
 		    ///Returns a reference to the NodeMap of distances.
 		    ///\pre Either \ref run() or \ref init() must
 		    ///be called before using this function.
 		    const DistMap &distMap() const { return *_dist;}
 		    ///Returns a reference to the %DFS arc-tree map.
 		    ///Returns a reference to the NodeMap of the arcs of the
 		    ///%DFS tree.
 		    ///\pre Either \ref run() or \ref init()
 		    ///must be called before using this function.
 		    const PredMap &predMap() const { return *_pred;}
 		    ///Checks if a node is reachable from the root.
 		    ///Returns \c true if \c v is reachable from the root(s).
 		    ///\warning The source nodes are inditated as unreachable.
 		    ///\pre Either \ref run() or \ref start()
 		    ///must be called before using this function.
 		    ///
 		    bool reached(Node v) { return (*_reached)[v]; }
 		    ///@}
 		  };
 		  ///Default traits class of Dfs function.
 		  ///Default traits class of Dfs function.
 		  ///\tparam GR Digraph type.
 		  template<class GR>
 		  struct DfsWizardDefaultTraits
+		  {
 		    ///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 NullMap<typename Digraph::Node,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
 		#ifdef DOXYGEN
 		    static PredMap *createPredMap(const GR &g)
 		#else
 		    static PredMap *createPredMap(const GR &)
 		#endif
+		    {
 		      return new PredMap();
+		    }
 		    ///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 NullMap<typename Digraph::Node,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
 		    ///\param g is the digraph, to which we would like to define
 		    ///the \ref DistMap
 		#ifdef DOXYGEN
 		    static DistMap *createDistMap(const GR &g)
 		#else
 		    static DistMap *createDistMap(const GR &)
 		#endif
+		    {
 		      return new DistMap();
+		    }
 		  };
 		  /// Default traits used by \ref DfsWizard
 		  /// To make it easier to use Dfs algorithm
 		  ///we have created a wizard class.
 		  /// This \ref DfsWizard class needs default traits,
 		  ///as well as the \ref Dfs class.
 		  /// The \ref DfsWizardBase is a class to be the default traits of the
 		  /// \ref DfsWizard class.
 		  template<class GR>
 		  class DfsWizardBase : public DfsWizardDefaultTraits<GR>
+		  {
 		    typedef DfsWizardDefaultTraits<GR> Base;
 		  protected:
 		    /// Type of the nodes in the digraph.
 		    typedef typename Base::Digraph::Node Node;
 		    /// Pointer to the underlying digraph.
 		    void *_g;
 		    ///Pointer to the map of reached nodes.
 		    void *_reached;
 		    ///Pointer to the map of processed nodes.
 		    void *_processed;
 		    ///Pointer to the map of predecessors arcs.
 		    void *_pred;
 		    ///Pointer to the map of distances.
 		    void *_dist;
 		    ///Pointer to the source node.
 		    Node _source;
 		    public:
 		    /// Constructor.
 		    /// This constructor does not require parameters, therefore it initiates
 		    /// all of the attributes to default values (0, INVALID).
 		    DfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0),
 		                           _dist(0), _source(INVALID) {}
 		    /// Constructor.
 		    /// This constructor requires some parameters,
 		    /// listed in the parameters list.
 		    /// Others are initiated to 0.
 		    /// \param g is the initial value of  \ref _g
 		    /// \param s is the initial value of  \ref _source
 		    DfsWizardBase(const GR &g, Node s=INVALID) :
 		      _g(reinterpret_cast<void*>(const_cast<GR*>(&g))),
 		      _reached(0), _processed(0), _pred(0), _dist(0), _source(s) {}
 		  };
 		  /// A class to make the usage of the Dfs algorithm easier
 		  /// This class is created to make it easier to use the Dfs algorithm.
 		  /// It uses the functions and features of the plain \ref Dfs,
 		  /// but it is much simpler to use it.
 		  ///
 		  /// Simplicity means that the way to change the types defined
 		  /// in the traits class is based on functions that returns the new class
 		  /// and not on templatable built-in classes.
 		  /// When using the plain \ref Dfs
 		  /// the new class with the modified type comes from
 		  /// the original class by using the ::
 		  /// operator. In the case of \ref DfsWizard only
 		  /// a function have to be called and it will
 		  /// return the needed class.
 		  ///
 		  /// It does not have own \ref run method. When its \ref run method is called
 		  /// it initiates a plain \ref Dfs object, and calls the \ref Dfs::run
 		  /// method of it.
 		  template<class TR>
 		  class DfsWizard : public TR
+		  {
 		    typedef TR Base;
 		    ///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 reached nodes
 		    typedef typename TR::ReachedMap ReachedMap;
 		    ///\brief The type of the map that stores
 		    ///the processed nodes
 		    typedef typename TR::ProcessedMap ProcessedMap;
 		    ///\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 that stores the distances of the nodes.
 		    typedef typename TR::DistMap DistMap;
 		  public:
 		    /// Constructor.
 		    DfsWizard() : TR() {}
 		    /// Constructor that requires parameters.
 		    /// Constructor that requires parameters.
 		    /// These parameters will be the default values for the traits class.
 		    DfsWizard(const Digraph &g, Node s=INVALID) :
 		      TR(g,s) {}
 		    ///Copy constructor
 		    DfsWizard(const TR &b) : TR(b) {}
 		    ~DfsWizard() {}
 		    ///Runs Dfs algorithm from a given node.
 		    ///Runs Dfs algorithm from a given node.
 		    ///The node can be given by the \ref source function.
 		    void run()
+		    {
 		      if(Base::_source==INVALID) throw UninitializedParameter();
 		      Dfs<Digraph,TR> alg(*reinterpret_cast<const Digraph*>(Base::_g));
 		      if(Base::_reached)
 		        alg.reachedMap(*reinterpret_cast<ReachedMap*>(Base::_reached));
 		      if(Base::_processed)
 		        alg.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));
 		      if(Base::_pred)
 		        alg.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
 		      if(Base::_dist)
 		        alg.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
 		      alg.run(Base::_source);
+		    }
 		    ///Runs Dfs algorithm from the given node.
 		    ///Runs Dfs algorithm from the given node.
 		    ///\param s is the given source.
 		    void run(Node s)
+		    {
 		      Base::_source=s;
 		      run();
+		    }
 		    template<class T>
 		    struct DefPredMapBase : public Base {
 		      typedef T PredMap;
 		      static PredMap *createPredMap(const Digraph &) { return 0; };
 		      DefPredMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-templ-param "Named parameter"
 		    ///function for setting PredMap type
 		    ///
 		    /// \ref named-templ-param "Named parameter"
 		    ///function for setting PredMap type
 		    ///
 		    template<class T>
 		    DfsWizard<DefPredMapBase<T> > predMap(const T &t)
+		    {
 		      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
 		      return DfsWizard<DefPredMapBase<T> >(*this);
+		    }
 		    template<class T>
 		    struct DefReachedMapBase : public Base {
 		      typedef T ReachedMap;
 		      static ReachedMap *createReachedMap(const Digraph &) { return 0; };
 		      DefReachedMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-templ-param "Named parameter"
 		    ///function for setting ReachedMap
 		    ///
 		    /// \ref named-templ-param "Named parameter"
 		    ///function for setting ReachedMap
 		    ///
 		    template<class T>
 		    DfsWizard<DefReachedMapBase<T> > reachedMap(const T &t)
+		    {
 		      Base::_reached=reinterpret_cast<void*>(const_cast<T*>(&t));
 		      return DfsWizard<DefReachedMapBase<T> >(*this);
+		    }
 		    template<class T>
 		    struct DefProcessedMapBase : public Base {
 		      typedef T ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &) { return 0; };
 		      DefProcessedMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-templ-param "Named parameter"
 		    ///function for setting ProcessedMap
 		    ///
 		    /// \ref named-templ-param "Named parameter"
 		    ///function for setting ProcessedMap
 		    ///
 		    template<class T>
 		    DfsWizard<DefProcessedMapBase<T> > processedMap(const T &t)
+		    {
 		      Base::_processed=reinterpret_cast<void*>(const_cast<T*>(&t));
 		      return DfsWizard<DefProcessedMapBase<T> >(*this);
+		    }
 		    template<class T>
 		    struct DefDistMapBase : public Base {
 		      typedef T DistMap;
 		      static DistMap *createDistMap(const Digraph &) { return 0; };
 		      DefDistMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-templ-param "Named parameter"
 		    ///function for setting DistMap type
 		    ///
 		    /// \ref named-templ-param "Named parameter"
 		    ///function for setting DistMap type
 		    ///
 		    template<class T>
 		    DfsWizard<DefDistMapBase<T> > distMap(const T &t)
+		    {
 		      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
 		      return DfsWizard<DefDistMapBase<T> >(*this);
+		    }
 		    /// Sets the source node, from which the Dfs algorithm runs.
 		    /// Sets the source node, from which the Dfs algorithm runs.
 		    /// \param s is the source node.
 		    DfsWizard<TR> &source(Node s)
+		    {
 		      Base::_source=s;
 		      return *this;
+		    }
 		  };
 		  ///Function type interface for Dfs algorithm.
 		  ///\ingroup search
 		  ///Function type interface for Dfs algorithm.
 		  ///
 		  ///This function also has several
 		  ///\ref named-templ-func-param "named parameters",
 		  ///they are declared as the members of class \ref DfsWizard.
 		  ///The following
 		  ///example shows how to use these parameters.
 		  ///\code
 		  ///  dfs(g,source).predMap(preds).run();
 		  ///\endcode
 		  ///\warning Don't forget to put the \ref DfsWizard::run() "run()"
 		  ///to the end of the parameter list.
 		  ///\sa DfsWizard
 		  ///\sa Dfs
 		  template<class GR>
 		  DfsWizard<DfsWizardBase<GR> >
 		  dfs(const GR &g,typename GR::Node s=INVALID)
+		  {
 		    return DfsWizard<DfsWizardBase<GR> >(g,s);
+		  }
 		#ifdef DOXYGEN
 		  /// \brief Visitor class for dfs.
 		  ///
 		  /// It gives a simple interface for a functional interface for dfs
 		  /// traversal. The traversal on a linear data structure.
 		  template <typename _Digraph>
 		  struct DfsVisitor {
 		    typedef _Digraph Digraph;
 		    typedef typename Digraph::Arc Arc;
 		    typedef typename Digraph::Node Node;
 		    /// \brief Called when the arc reach a node.
 		    ///
 		    /// It is called when the dfs find an arc which target is not
 		    /// reached yet.
 		    void discover(const Arc& arc) {}
 		    /// \brief Called when the node reached first time.
 		    ///
 		    /// It is Called when the node reached first time.
 		    void reach(const Node& node) {}
 		    /// \brief Called when we step back on an arc.
 		    ///
 		    /// It is called when the dfs should step back on the arc.
 		    void backtrack(const Arc& arc) {}
 		    /// \brief Called when we step back from the node.
 		    ///
 		    /// It is called when we step back from the node.
 		    void leave(const Node& node) {}
 		    /// \brief Called when the arc examined but target of the arc
 		    /// already discovered.
 		    ///
 		    /// It called when the arc examined but the target of the arc
 		    /// already discovered.
 		    void examine(const Arc& arc) {}
 		    /// \brief Called for the source node of the dfs.
 		    ///
 		    /// It is called for the source node of the dfs.
 		    void start(const Node& node) {}
 		    /// \brief Called when we leave the source node of the dfs.
 		    ///
 		    /// It is called when we leave the source node of the dfs.
 		    void stop(const Node& node) {}
 		  };
 		#else
 		  template <typename _Digraph>
 		  struct DfsVisitor {
 		    typedef _Digraph Digraph;
 		    typedef typename Digraph::Arc Arc;
 		    typedef typename Digraph::Node Node;
 		    void discover(const Arc&) {}
 		    void reach(const Node&) {}
 		    void backtrack(const Arc&) {}
 		    void leave(const Node&) {}
 		    void examine(const Arc&) {}
 		    void start(const Node&) {}
 		    void stop(const Node&) {}
 		    template <typename _Visitor>
 		    struct Constraints {
 		      void constraints() {
 		        Arc arc;
 		        Node node;
 		        visitor.discover(arc);
 		        visitor.reach(node);
 		        visitor.backtrack(arc);
 		        visitor.leave(node);
 		        visitor.examine(arc);
 		        visitor.start(node);
 		        visitor.stop(arc);
+		      }
 		      _Visitor& visitor;
 		    };
 		  };
 		#endif
 		  /// \brief Default traits class of DfsVisit class.
 		  ///
 		  /// Default traits class of DfsVisit class.
 		  /// \tparam _Digraph Digraph type.
 		  template<class _Digraph>
 		  struct DfsVisitDefaultTraits {
 		    /// \brief The digraph type the algorithm runs on.
 		    typedef _Digraph Digraph;
 		    /// \brief 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;
 		    /// \brief Instantiates a ReachedMap.
 		    ///
 		    /// This function instantiates a \ref ReachedMap.
 		    /// \param digraph is the digraph, to which
 		    /// we would like to define the \ref ReachedMap.
 		    static ReachedMap *createReachedMap(const Digraph &digraph) {
 		      return new ReachedMap(digraph);
+		    }
 		  };
 		  /// %DFS Visit algorithm class.
 		  /// \ingroup search
 		  /// This class provides an efficient implementation of the %DFS algorithm
 		  /// with visitor interface.
 		  ///
 		  /// The %DfsVisit class provides an alternative interface to the Dfs
 		  /// class. It works with callback mechanism, the DfsVisit object calls
 		  /// on every dfs event the \c Visitor class member functions.
 		  ///
-		  /// \tparam _Digraph The digraph type the algorithm runs on. The default value is
 		  /// \tparam _Digraph The digraph type the algorithm runs on.
 		  /// The default value is
 		  /// \ref ListDigraph. The value of _Digraph is not used directly by Dfs, it
 		  /// is only passed to \ref DfsDefaultTraits.
 		  /// \tparam _Visitor The Visitor object for the algorithm. The
 		  /// \ref DfsVisitor "DfsVisitor<_Digraph>" is an empty Visitor which
 		  /// does not observe the Dfs events. If you want to observe the dfs
 		  /// events you should implement your own Visitor class.
 		  /// \tparam _Traits Traits class to set various data types used by the
 		  /// algorithm. The default traits class is
 		  /// \ref DfsVisitDefaultTraits "DfsVisitDefaultTraits<_Digraph>".
 		  /// See \ref DfsVisitDefaultTraits for the documentation of
 		  /// a Dfs visit traits class.
 		  ///
 		  /// \author Jacint Szabo, Alpar Juttner and Balazs Dezso
 		#ifdef DOXYGEN
 		  template <typename _Digraph, typename _Visitor, typename _Traits>
 		#else
 		  template <typename _Digraph = ListDigraph,
 		            typename _Visitor = DfsVisitor<_Digraph>,
 		            typename _Traits = DfsDefaultTraits<_Digraph> >
 		#endif
 		  class DfsVisit {
 		  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::DfsVisit::UninitializedParameter";
+		      }
 		    };
 		    typedef _Traits Traits;
 		    typedef typename Traits::Digraph Digraph;
 		    typedef _Visitor Visitor;
 		    ///The type of the map indicating which nodes are reached.
 		    typedef typename Traits::ReachedMap ReachedMap;
 		  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 *_digraph;
 		    /// Pointer to the visitor object.
 		    Visitor *_visitor;
 		    ///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;
 		    std::vector<typename Digraph::Arc> _stack;
 		    int _stack_head;
 		    /// \brief Creates the maps if necessary.
 		    ///
 		    /// Creates the maps if necessary.
 		    void create_maps() {
 		      if(!_reached) {
 		        local_reached = true;
 		        _reached = Traits::createReachedMap(*_digraph);
+		      }
+		    }
 		  protected:
 		    DfsVisit() {}
 		  public:
 		    typedef DfsVisit Create;
 		    /// \name Named template parameters
 		    ///@{
 		    template <class T>
 		    struct DefReachedMapTraits : public Traits {
 		      typedef T ReachedMap;
 		      static ReachedMap *createReachedMap(const Digraph &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 DfsVisit< Digraph, Visitor,
 		                                            DefReachedMapTraits<T> > {
 		      typedef DfsVisit< Digraph, Visitor, DefReachedMapTraits<T> > Create;
 		    };
 		    ///@}
 		  public:
 		    /// \brief Constructor.
 		    ///
 		    /// Constructor.
 		    ///
 		    /// \param digraph the digraph the algorithm will run on.
 		    /// \param visitor The visitor of the algorithm.
 		    ///
 		    DfsVisit(const Digraph& digraph, Visitor& visitor)
 		      : _digraph(&digraph), _visitor(&visitor),
 		        _reached(0), local_reached(false) {}
 		    /// \brief Destructor.
 		    ///
 		    /// Destructor.
 		    ~DfsVisit() {
 		      if(local_reached) delete _reached;
+		    }
 		    /// \brief 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>
 		    DfsVisit &reachedMap(ReachedMap &m) {
 		      if(local_reached) {
 		        delete _reached;
 		        local_reached=false;
+		      }
 		      _reached = &m;
 		      return *this;
+		    }
 		  public:
 		    /// \name Execution control
 		    /// The simplest way to execute the algorithm is to use
 		    /// one of the member functions called \c run(...).
 		    /// \n
 		    /// If you need more control on the execution,
 		    /// first you must call \ref init(), then you can adda source node
 		    /// with \ref addSource().
 		    /// Finally \ref start() will perform the actual path
 		    /// computation.
 		    /// @{
 		    /// \brief Initializes the internal data structures.
 		    ///
 		    /// Initializes the internal data structures.
 		    ///
 		    void init() {
 		      create_maps();
 		      _stack.resize(countNodes(*_digraph));
 		      _stack_head = -1;
 		      for (NodeIt u(*_digraph) ; u != INVALID ; ++u) {
 		        _reached->set(u, false);
+		      }
+		    }
 		    /// \brief Adds a new source node.
 		    ///
 		    /// Adds a new source node to the set of nodes to be processed.
 		    void addSource(Node s) {
 		      if(!(*_reached)[s]) {
 		          _reached->set(s,true);
 		          _visitor->start(s);
 		          _visitor->reach(s);
 		          Arc e;
 		          _digraph->firstOut(e, s);
 		          if (e != INVALID) {
 		            _stack[++_stack_head] = e;
 		          } else {
 		            _visitor->leave(s);
+		          }
+		        }
+		    }
 		    /// \brief Processes the next arc.
 		    ///
 		    /// Processes the next arc.
 		    ///
 		    /// \return The processed arc.
 		    ///
 		    /// \pre The stack must not be empty!
 		    Arc processNextArc() {
 		      Arc e = _stack[_stack_head];
 		      Node m = _digraph->target(e);
 		      if(!(*_reached)[m]) {
 		        _visitor->discover(e);
 		        _visitor->reach(m);
 		        _reached->set(m, true);
 		        _digraph->firstOut(_stack[++_stack_head], m);
 		      } else {
 		        _visitor->examine(e);
 		        m = _digraph->source(e);
 		        _digraph->nextOut(_stack[_stack_head]);
+		      }
 		      while (_stack_head>=0 && _stack[_stack_head] == INVALID) {
 		        _visitor->leave(m);
 		        --_stack_head;
 		        if (_stack_head >= 0) {
 		          _visitor->backtrack(_stack[_stack_head]);
 		          m = _digraph->source(_stack[_stack_head]);
 		          _digraph->nextOut(_stack[_stack_head]);
 		        } else {
 		          _visitor->stop(m);
+		        }
+		      }
 		      return e;
+		    }
 		    /// \brief Next arc to be processed.
 		    ///
 		    /// Next arc to be processed.
 		    ///
 		    /// \return The next arc to be processed or INVALID if the stack is
 		    /// empty.
 		    Arc nextArc() {
 		      return _stack_head >= 0 ? _stack[_stack_head] : INVALID;
+		    }
 		    /// \brief Returns \c false if there are nodes
 		    /// to be processed in the queue
 		    ///
 		    /// Returns \c false if there are nodes
 		    /// to be processed in the queue
 		    bool emptyQueue() { return _stack_head < 0; }
 		    /// \brief Returns the number of the nodes to be processed.
 		    ///
 		    /// Returns the number of the nodes to be processed in the queue.
 		    int queueSize() { return _stack_head + 1; }
 		    /// \brief Executes the algorithm.
 		    ///
 		    /// Executes the algorithm.
 		    ///
 		    /// \pre init() must be called and at least one node should be added
 		    /// with addSource() before using this function.
 		    void start() {
 		      while ( !emptyQueue() ) processNextArc();
+		    }
 		    /// \brief Executes the algorithm until \c dest is reached.
 		    ///
 		    /// Executes the algorithm until \c dest is reached.
 		    ///
 		    /// \pre init() must be called and at least one node should be added
 		    /// with addSource() before using this function.
 		    void start(Node dest) {
 		      while ( !emptyQueue() && _digraph->target(_stack[_stack_head]) != dest )
 		        processNextArc();
+		    }
 		    /// \brief Executes the algorithm until a condition is met.
 		    ///
 		    /// Executes the algorithm until a condition is met.
 		    ///
 		    /// \pre init() must be called and at least one node should be added
 		    /// with addSource() before using this function.
 		    ///
 		    /// \param em must be a bool (or convertible) arc map. The algorithm
 		    /// will stop when it reaches an arc \c e with <tt>em[e]</tt> true.
 		    ///
 		    ///\return The reached arc \c e with <tt>em[e]</tt> true or
 		    ///\c INVALID if no such arc was found.
 		    ///
 		    /// \warning Contrary to \ref Bfs and \ref Dijkstra, \c em is an arc map,
 		    /// not a node map.
 		    template <typename EM>
 		    Arc start(const EM &em) {
 		      while ( !emptyQueue() && !em[_stack[_stack_head]] )
 		        processNextArc();
 		      return emptyQueue() ? INVALID : _stack[_stack_head];
+		    }
 		    /// \brief Runs %DFSVisit algorithm from node \c s.
 		    ///
 		    /// This method runs the %DFS algorithm from a root node \c s.
 		    /// \note d.run(s) is just a shortcut of the following code.
 		    ///\code
 		    ///   d.init();
 		    ///   d.addSource(s);
 		    ///   d.start();
 		    ///\endcode
 		    void run(Node s) {
 		      init();
 		      addSource(s);
 		      start();
+		    }
 		    /// \brief Runs %DFSVisit algorithm to visit all nodes in the digraph.
 		    /// This method runs the %DFS algorithm in order to
 		    /// compute the %DFS path to each node. The algorithm computes
 		    /// - The %DFS tree.
 		    /// - The distance of each node from the root in the %DFS tree.
 		    ///
 		    ///\note d.run() is just a shortcut of the following code.
 		    ///\code
 		    ///  d.init();
 		    ///  for (NodeIt it(digraph); it != INVALID; ++it) {
 		    ///    if (!d.reached(it)) {
 		    ///      d.addSource(it);
 		    ///      d.start();
 		    ///    }
 		    ///  }
 		    ///\endcode
 		    void run() {
 		      init();
 		      for (NodeIt it(*_digraph); it != INVALID; ++it) {
 		        if (!reached(it)) {
 		          addSource(it);
 		          start();
+		        }
+		      }
+		    }
 		    ///@}
 		    /// \name Query Functions
 		    /// The result of the %DFS algorithm can be obtained using these
 		    /// functions.\n
 		    /// Before the use of these functions,
 		    /// either run() or start() must be called.
 		    ///@{
 		    /// \brief Checks if a node is reachable from the root.
 		    ///
 		    /// Returns \c true if \c v is reachable from the root(s).
 		    /// \warning The source nodes are inditated as unreachable.
 		    /// \pre Either \ref run() or \ref start()
 		    /// must be called before using this function.
 		    ///
 		    bool reached(Node v) { return (*_reached)[v]; }
 		    ///@}
 		  };
 		} //END OF NAMESPACE LEMON
 		#endif

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/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
 		    ///\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;
 		      : 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;
 		      : 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;
 		      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
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting heap and cross
 		    ///reference type
 		    ///
 		    template <class H, class CR = typename Digraph::template NodeMap<int> >
 		    struct DefHeap
 		      : public Dijkstra< Digraph,        LengthMap, DefHeapTraits<H, CR> > {
 		      typedef Dijkstra< Digraph,        LengthMap, DefHeapTraits<H, CR> > Create;
 		      : public Dijkstra< Digraph, LengthMap, DefHeapTraits<H, CR> > {
 		      typedef Dijkstra< Digraph, LengthMap, DefHeapTraits<H, CR> > Create;
 		    };
 		    template <class H, class CR>
 		    struct DefStandardHeapTraits : public Traits {
 		      typedef CR HeapCrossRef;
 		      typedef H Heap;
 		      static HeapCrossRef *createHeapCrossRef(const Digraph &G) {
 		        return new HeapCrossRef(G);
+		      }
 		      static Heap *createHeap(HeapCrossRef &R)
+		      {
 		        return new Heap(R);
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///heap and cross reference type with automatic allocation
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting heap and cross
 		    ///reference type. It can allocate the heap and the cross reference
 		    ///object if the cross reference's constructor waits for the digraph as
 		    ///parameter and the heap's constructor waits for the cross reference.
 		    template <class H, class CR = typename Digraph::template NodeMap<int> >
 		    struct DefStandardHeap
 		      : public Dijkstra< Digraph,        LengthMap, DefStandardHeapTraits<H, CR> > {
 		      typedef Dijkstra< Digraph,        LengthMap, DefStandardHeapTraits<H, CR> >
 		      : public Dijkstra< Digraph, LengthMap, DefStandardHeapTraits<H, CR> > {
 		      typedef Dijkstra< Digraph, LengthMap, DefStandardHeapTraits<H, CR> >
 		      Create;
 		    };
 		    template <class T>
 		    struct DefOperationTraitsTraits : public Traits {
 		      typedef T OperationTraits;
 		    };
 		    /// \brief \ref named-templ-param "Named parameter" for setting
 		    /// OperationTraits type
 		    ///
 		    /// \ref named-templ-param "Named parameter" for setting OperationTraits
 		    /// type
 		    template <class T>
 		    struct DefOperationTraits
 		      : public Dijkstra<Digraph, LengthMap, DefOperationTraitsTraits<T> > {
 		      typedef Dijkstra<Digraph, LengthMap, DefOperationTraitsTraits<T> >
 		      Create;
 		    };
 		    ///@}
 		  protected:
 		    Dijkstra() {}
 		  public:
 		    ///Constructor.
 		    ///\param _G the digraph the algorithm will run on.
 		    ///\param _length the length map used by the algorithm.
 		    Dijkstra(const Digraph& _G, const LengthMap& _length) :
 		      G(&_G), length(&_length),
 		      _pred(NULL), local_pred(false),
 		      _dist(NULL), local_dist(false),
 		      _processed(NULL), local_processed(false),
 		      _heap_cross_ref(NULL), local_heap_cross_ref(false),
 		      _heap(NULL), local_heap(false)
 		    { }
 		    ///Destructor.
 		    ~Dijkstra()
+		    {
 		      if(local_pred) delete _pred;
 		      if(local_dist) delete _dist;
 		      if(local_processed) delete _processed;
 		      if(local_heap_cross_ref) delete _heap_cross_ref;
 		      if(local_heap) delete _heap;
+		    }
 		    ///Sets the length map.
 		    ///Sets the length map.
 		    ///\return <tt> (*this) </tt>
 		    Dijkstra &lengthMap(const LengthMap &m)
+		    {
 		      length = &m;
 		      return *this;
+		    }
 		    ///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>
 		    Dijkstra &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>
 		    Dijkstra &distMap(DistMap &m)
+		    {
 		      if(local_dist) {
 		        delete _dist;
 		        local_dist=false;
+		      }
 		      _dist = &m;
 		      return *this;
+		    }
 		    ///Sets the heap and the cross reference used by algorithm.
 		    ///Sets the heap and the cross reference used by algorithm.
 		    ///If you don't use this function before calling \ref run(),
 		    ///it will allocate one. The destuctor deallocates this
 		    ///automatically allocated heap and cross reference, of course.
 		    ///\return <tt> (*this) </tt>
 		    Dijkstra &heap(Heap& hp, HeapCrossRef &cr)
+		    {
 		      if(local_heap_cross_ref) {
 		        delete _heap_cross_ref;
 		        local_heap_cross_ref=false;
+		      }
 		      _heap_cross_ref = &cr;
 		      if(local_heap) {
 		        delete _heap;
 		        local_heap=false;
+		      }
 		      _heap = &hp;
 		      return *this;
+		    }
 		  private:
 		    void finalizeNodeData(Node v,Value dst)
+		    {
 		      _processed->set(v,true);
 		      _dist->set(v, dst);
+		    }
 		  public:
 		    typedef PredMapPath<Digraph, PredMap> Path;
 		    ///\name Execution control
 		    ///The simplest way to execute the algorithm is to use
 		    ///one of the member functions called \c run(...).
 		    ///\n
 		    ///If you need more control on the execution,
 		    ///first you must call \ref init(), then you can add several source nodes
 		    ///with \ref addSource().
 		    ///Finally \ref start() will perform the actual path
 		    ///computation.
 		    ///@{
 		    ///Initializes the internal data structures.
 		    ///Initializes the internal data structures.
 		    ///
 		    void init()
+		    {
 		      create_maps();
 		      _heap->clear();
 		      for ( NodeIt u(*G) ; u!=INVALID ; ++u ) {
 		        _pred->set(u,INVALID);
 		        _processed->set(u,false);
 		        _heap_cross_ref->set(u,Heap::PRE_HEAP);
+		      }
+		    }
 		    ///Adds a new source node.
 		    ///Adds a new source node to the priority heap.
 		    ///
 		    ///The optional second parameter is the initial distance of the node.
 		    ///
 		    ///It checks if the node has already been added to the heap and
 		    ///it is pushed to the heap only if either it was not in the heap
 		    ///or the shortest path found till then is shorter than \c dst.
 		    void addSource(Node s,Value dst=OperationTraits::zero())
+		    {
 		      if(_heap->state(s) != Heap::IN_HEAP) {
 		        _heap->push(s,dst);
 		      } else if(OperationTraits::less((*_heap)[s], dst)) {
 		        _heap->set(s,dst);
 		        _pred->set(s,INVALID);
+		      }
+		    }
 		    ///Processes the next node in the priority heap
 		    ///Processes the next node in the priority heap.
 		    ///
 		    ///\return The processed node.
 		    ///
 		    ///\warning The priority heap must not be empty!
 		    Node processNextNode()
+		    {
 		      Node v=_heap->top();
 		      Value oldvalue=_heap->prio();
 		      _heap->pop();
 		      finalizeNodeData(v,oldvalue);
 		      for(OutArcIt e(*G,v); e!=INVALID; ++e) {
 		        Node w=G->target(e);
 		        switch(_heap->state(w)) {
 		        case Heap::PRE_HEAP:
 		          _heap->push(w,OperationTraits::plus(oldvalue, (*length)[e]));
 		          _pred->set(w,e);
 		          break;
 		        case Heap::IN_HEAP:
+		          {
 		            Value newvalue = OperationTraits::plus(oldvalue, (*length)[e]);
 		            if ( OperationTraits::less(newvalue, (*_heap)[w]) ) {
 		              _heap->decrease(w, newvalue);
 		              _pred->set(w,e);
+		            }
+		          }
 		          break;
 		        case Heap::POST_HEAP:
 		          break;
+		        }
+		      }
 		      return v;
+		    }
 		    ///Next node to be processed.
 		    ///Next node to be processed.
 		    ///
 		    ///\return The next node to be processed or INVALID if the priority heap
 		    /// is empty.
 		    Node nextNode()
+		    {
 		      return !_heap->empty()?_heap->top():INVALID;
+		    }
 		    ///\brief Returns \c false if there are nodes
 		    ///to be processed in the priority heap
 		    ///
 		    ///Returns \c false if there are nodes
 		    ///to be processed in the priority heap
 		    bool emptyQueue() { return _heap->empty(); }
 		    ///Returns the number of the nodes to be processed in the priority heap
 		    ///Returns the number of the nodes to be processed in the priority heap
 		    ///
 		    int queueSize() { return _heap->size(); }
 		    ///Executes the algorithm.
 		    ///Executes the algorithm.
 		    ///
 		    ///\pre init() must be called and at least one node should be added
 		    ///with addSource() before using this function.
 		    ///
 		    ///This method runs the %Dijkstra algorithm from the root node(s)
 		    ///in order to
 		    ///compute the
 		    ///shortest path to each node. The algorithm computes
 		    ///- The shortest path tree.
 		    ///- The distance of each node from the root(s).
 		    ///
 		    void start()
+		    {
 		      while ( !_heap->empty() ) processNextNode();
+		    }
 		    ///Executes the algorithm until \c dest is reached.
 		    ///Executes the algorithm until \c dest is reached.
 		    ///
 		    ///\pre init() must be called and at least one node should be added
 		    ///with addSource() before using this function.
 		    ///
 		    ///This method runs the %Dijkstra algorithm from the root node(s)
 		    ///in order to
 		    ///compute the
 		    ///shortest path to \c dest. The algorithm computes
 		    ///- The shortest path to \c  dest.
 		    ///- The distance of \c dest from the root(s).
 		    ///
 		    void start(Node dest)
+		    {
 		      while ( !_heap->empty() && _heap->top()!=dest ) processNextNode();
 		      if ( !_heap->empty() ) finalizeNodeData(_heap->top(),_heap->prio());
+		    }
 		    ///Executes the algorithm until a condition is met.
 		    ///Executes the algorithm until a condition is met.
 		    ///
 		    ///\pre init() must be called and at least one node should be added
 		    ///with addSource() before using this function.
 		    ///
 		    ///\param nm must be a bool (or convertible) node map. The algorithm
 		    ///will stop when it reaches a node \c v with <tt>nm[v]</tt> true.
 		    ///
 		    ///\return The reached node \c v with <tt>nm[v]</tt> true or
 		    ///\c INVALID if no such node was found.
 		    template<class NodeBoolMap>
 		    Node start(const NodeBoolMap &nm)
+		    {
 		      while ( !_heap->empty() && !nm[_heap->top()] ) processNextNode();
 		      if ( _heap->empty() ) return INVALID;
 		      finalizeNodeData(_heap->top(),_heap->prio());
 		      return _heap->top();
+		    }
 		    ///Runs %Dijkstra algorithm from node \c s.
 		    ///This method runs the %Dijkstra algorithm from a root node \c s
 		    ///in order to
 		    ///compute the
 		    ///shortest path to each node. The algorithm computes
 		    ///- The shortest path tree.
 		    ///- The distance of each node from the root.
 		    ///
 		    ///\note d.run(s) is just a shortcut of the following code.
 		    ///\code
 		    ///  d.init();
 		    ///  d.addSource(s);
 		    ///  d.start();
 		    ///\endcode
 		    void run(Node s) {
 		      init();
 		      addSource(s);
 		      start();
+		    }
 		    ///Finds the shortest path between \c s and \c t.
 		    ///Finds the shortest path between \c s and \c t.
 		    ///
 		    ///\return The length of the shortest s---t path if there exists one,
 		    ///0 otherwise.
 		    ///\note Apart from the return value, d.run(s) is
 		    ///just a shortcut of the following code.
 		    ///\code
 		    ///  d.init();
 		    ///  d.addSource(s);
 		    ///  d.start(t);
 		    ///\endcode
 		    Value run(Node s,Node t) {
 		      init();
 		      addSource(s);
 		      start(t);
 		      return (*_pred)[t]==INVALID?OperationTraits::zero():(*_dist)[t];
+		    }
 		    ///@}
 		    ///\name Query Functions
 		    ///The result of the %Dijkstra algorithm can be obtained using these
 		    ///functions.\n
 		    ///Before the use of these functions,
 		    ///either run() or start() must be called.
 		    ///@{
 		    ///Gives back the shortest path.
 		    ///Gives back the shortest path.
 		    ///\pre The \c t should be reachable from the source.
 		    Path path(Node t)
+		    {
 		      return Path(*G, *_pred, t);
+		    }
 		    ///The distance of a node from the root.
 		    ///Returns the distance of a node from the root.
 		    ///\pre \ref run() must be called before using this function.
 		    ///\warning If node \c v in unreachable from the root the return value
 		    ///of this funcion is undefined.
 		    Value dist(Node v) const { return (*_dist)[v]; }
 		    ///The current distance of a node from the root.
 		    ///Returns the current distance of a node from the root.
 		    ///It may be decreased in the following processes.
 		    ///\pre \c node should be reached but not processed
 		    Value currentDist(Node v) const { return (*_heap)[v]; }
 		    ///Returns the 'previous arc' of the shortest path tree.
 		    ///For a node \c v it returns the 'previous arc' of the shortest path tree,
 		    ///i.e. it returns the last arc of a shortest path from the root to \c
 		    ///v. It is \ref INVALID
 		    ///if \c v is unreachable from the root or if \c v=s. The
 		    ///shortest path tree used here is equal to the shortest path tree used in
 		    ///\ref predNode().  \pre \ref run() must be called before using
 		    ///this function.
 		    Arc predArc(Node v) const { return (*_pred)[v]; }
 		    ///Returns the 'previous node' of the shortest path tree.
 		    ///For a node \c v it returns the 'previous node' of the shortest path tree,
 		    ///i.e. it returns the last but one node from a shortest path from the
 		    ///root to \c /v. It is INVALID if \c v is unreachable from the root or if
 		    ///\c v=s. The shortest path tree used here is equal to the shortest path
 		    ///tree used in \ref predArc().  \pre \ref run() must be called before
 		    ///using this function.
 		    Node predNode(Node v) const { return (*_pred)[v]==INVALID ? INVALID:
 		                                  G->source((*_pred)[v]); }
 		    ///Returns a reference to the NodeMap of distances.
 		    ///Returns a reference to the NodeMap of distances. \pre \ref run() must
 		    ///be called before using this function.
 		    const DistMap &distMap() const { return *_dist;}
 		    ///Returns a reference to the shortest path tree map.
 		    ///Returns a reference to the NodeMap of the arcs of the
 		    ///shortest path tree.
 		    ///\pre \ref run() must be called before using this function.
 		    const PredMap &predMap() const { return *_pred;}
 		    ///Checks if a node is reachable from the root.
 		    ///Returns \c true if \c v is reachable from the root.
 		    ///\warning The source nodes are inditated as unreached.
 		    ///\pre \ref run() must be called before using this function.
 		    ///
 		    bool reached(Node v) { return (*_heap_cross_ref)[v] != Heap::PRE_HEAP; }
 		    ///Checks if a node is processed.
 		    ///Returns \c true if \c v is processed, i.e. the shortest
 		    ///path to \c v has already found.
 		    ///\pre \ref run() must be called before using this function.
 		    ///
 		    bool processed(Node v) { return (*_heap_cross_ref)[v] == Heap::POST_HEAP; }
 		    ///@}
 		  };
 		  ///Default traits class of Dijkstra function.
 		  ///Default traits class of Dijkstra function.
 		  ///\tparam GR Digraph type.
 		  ///\tparam LM Type of length map.
 		  template<class GR, class LM>
 		  struct DijkstraWizardDefaultTraits
+		  {
 		    ///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 heap type used by Dijkstra algorithm.
 		    /// 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 \ref HeapCrossRef.
 		    /// \param G is the digraph, to which we would like to define the
 		    /// HeapCrossRef.
 		    /// \todo The digraph alone may be insufficient for the initialization
 		    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, typename GR::template NodeMap<int>,
 		                    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 NullMap <typename GR::Node,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 for the initialization
 		#ifdef DOXYGEN
 		    static PredMap *createPredMap(const GR &g)
 		#else
 		    static PredMap *createPredMap(const GR &)
 		#endif
+		    {
 		      return new PredMap();
+		    }
 		    ///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 \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 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 NullMap<typename Digraph::Node,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
 		    ///\param g is the digraph, to which we would like to define
 		    ///the \ref DistMap
 		#ifdef DOXYGEN
 		    static DistMap *createDistMap(const GR &g)
 		#else
 		    static DistMap *createDistMap(const GR &)
 		#endif
+		    {
 		      return new DistMap();
+		    }
 		  };
 		  /// Default traits used by \ref DijkstraWizard
 		  /// To make it easier to use Dijkstra algorithm
 		  ///we have created a wizard class.
 		  /// This \ref DijkstraWizard class needs default traits,
 		  ///as well as the \ref Dijkstra class.
 		  /// The \ref DijkstraWizardBase is a class to be the default traits of the
 		  /// \ref DijkstraWizard class.
 		  /// \todo More named parameters are required...
 		  template<class GR,class LM>
 		  class DijkstraWizardBase : public DijkstraWizardDefaultTraits<GR,LM>
+		  {
 		    typedef DijkstraWizardDefaultTraits<GR,LM> Base;
 		  protected:
 		    /// Type of the nodes in the digraph.
 		    typedef typename Base::Digraph::Node Node;
 		    /// Pointer to the underlying digraph.
 		    void *_g;
 		    /// Pointer to the length map
 		    void *_length;
 		    ///Pointer to the map of predecessors arcs.
 		    void *_pred;
 		    ///Pointer to the map of distances.
 		    void *_dist;
 		    ///Pointer to the source node.
 		    Node _source;
 		    public:
 		    /// Constructor.
 		    /// This constructor does not require parameters, therefore it initiates
 		    /// all of the attributes to default values (0, INVALID).
 		    DijkstraWizardBase() : _g(0), _length(0), _pred(0),
 		                           _dist(0), _source(INVALID) {}
 		    /// Constructor.
 		    /// This constructor requires some parameters,
 		    /// listed in the parameters list.
 		    /// Others are initiated to 0.
 		    /// \param g is the initial value of  \ref _g
 		    /// \param l is the initial value of  \ref _length
 		    /// \param s is the initial value of  \ref _source
 		    DijkstraWizardBase(const GR &g,const LM &l, Node s=INVALID) :
 		      _g(reinterpret_cast<void*>(const_cast<GR*>(&g))),
 		      _length(reinterpret_cast<void*>(const_cast<LM*>(&l))),
 		      _pred(0), _dist(0), _source(s) {}
 		  };
 		  /// A class to make the usage of Dijkstra algorithm easier
 		  /// This class is created to make it easier to use Dijkstra algorithm.
 		  /// It uses the functions and features of the plain \ref Dijkstra,
 		  /// but it is much simpler to use it.
 		  ///
 		  /// Simplicity means that the way to change the types defined
 		  /// in the traits class is based on functions that returns the new class
 		  /// and not on templatable built-in classes.
 		  /// When using the plain \ref Dijkstra
 		  /// the new class with the modified type comes from
 		  /// the original class by using the ::
 		  /// operator. In the case of \ref DijkstraWizard only
 		  /// a function have to be called and it will
 		  /// return the needed class.
 		  ///
 		  /// It does not have own \ref run method. When its \ref run method is called
 		  /// it initiates a plain \ref Dijkstra class, and calls the \ref
 		  /// Dijkstra::run method of it.
 		  template<class TR>
 		  class DijkstraWizard : public TR
+		  {
 		    typedef TR Base;
 		    ///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 map that stores the arc lengths.
 		    typedef typename TR::LengthMap LengthMap;
 		    ///The type of the length of the arcs.
 		    typedef typename LengthMap::Value Value;
 		    ///\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 that stores the dists of the nodes.
 		    typedef typename TR::DistMap DistMap;
 		    ///The heap type used by the dijkstra algorithm.
 		    typedef typename TR::Heap Heap;
 		  public:
 		    /// Constructor.
 		    DijkstraWizard() : TR() {}
 		    /// Constructor that requires parameters.
 		    /// Constructor that requires parameters.
 		    /// These parameters will be the default values for the traits class.
 		    DijkstraWizard(const Digraph &g,const LengthMap &l, Node s=INVALID) :
 		      TR(g,l,s) {}
 		    ///Copy constructor
 		    DijkstraWizard(const TR &b) : TR(b) {}
 		    ~DijkstraWizard() {}
 		    ///Runs Dijkstra algorithm from a given node.
 		    ///Runs Dijkstra algorithm from a given node.
 		    ///The node can be given by the \ref source function.
 		    void run()
+		    {
 		      if(Base::_source==INVALID) throw UninitializedParameter();
 		      Dijkstra<Digraph,LengthMap,TR>
 		        dij(*reinterpret_cast<const Digraph*>(Base::_g),
 		            *reinterpret_cast<const LengthMap*>(Base::_length));
 		      if(Base::_pred) dij.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
 		      if(Base::_dist) dij.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
 		      dij.run(Base::_source);
+		    }
 		    ///Runs Dijkstra algorithm from the given node.
 		    ///Runs Dijkstra algorithm from the given node.
 		    ///\param s is the given source.
 		    void run(Node s)
+		    {
 		      Base::_source=s;
 		      run();
+		    }
 		    template<class T>
 		    struct DefPredMapBase : public Base {
 		      typedef T PredMap;
 		      static PredMap *createPredMap(const Digraph &) { return 0; };
 		      DefPredMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-templ-param "Named parameter"
 		    ///function for setting PredMap type
 		    ///
 		    /// \ref named-templ-param "Named parameter"
 		    ///function for setting PredMap type
 		    ///
 		    template<class T>
 		    DijkstraWizard<DefPredMapBase<T> > predMap(const T &t)
+		    {
 		      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
 		      return DijkstraWizard<DefPredMapBase<T> >(*this);
+		    }
 		    template<class T>
 		    struct DefDistMapBase : public Base {
 		      typedef T DistMap;
 		      static DistMap *createDistMap(const Digraph &) { return 0; };
 		      DefDistMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-templ-param "Named parameter"
 		    ///function for setting DistMap type
 		    ///
 		    /// \ref named-templ-param "Named parameter"
 		    ///function for setting DistMap type
 		    ///
 		    template<class T>
 		    DijkstraWizard<DefDistMapBase<T> > distMap(const T &t)
+		    {
 		      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
 		      return DijkstraWizard<DefDistMapBase<T> >(*this);
+		    }
 		    /// Sets the source node, from which the Dijkstra algorithm runs.
 		    /// Sets the source node, from which the Dijkstra algorithm runs.
 		    /// \param s is the source node.
 		    DijkstraWizard<TR> &source(Node s)
+		    {
 		      Base::_source=s;
 		      return *this;
+		    }
 		  };
 		  ///Function type interface for Dijkstra algorithm.
 		  /// \ingroup shortest_path
 		  ///Function type interface for Dijkstra algorithm.
 		  ///
 		  ///This function also has several
 		  ///\ref named-templ-func-param "named parameters",
 		  ///they are declared as the members of class \ref DijkstraWizard.
 		  ///The following
 		  ///example shows how to use these parameters.
 		  ///\code
 		  ///  dijkstra(g,length,source).predMap(preds).run();
 		  ///\endcode
 		  ///\warning Don't forget to put the \ref DijkstraWizard::run() "run()"
 		  ///to the end of the parameter list.
 		  ///\sa DijkstraWizard
 		  ///\sa Dijkstra
 		  template<class GR, class LM>
 		  DijkstraWizard<DijkstraWizardBase<GR,LM> >
 		  dijkstra(const GR &g,const LM &l,typename GR::Node s=INVALID)
+		  {
 		    return DijkstraWizard<DijkstraWizardBase<GR,LM> >(g,l,s);
+		  }
 		} //END OF NAMESPACE LEMON
 		#endif

lemon/graph_to_eps.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-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_GRAPH_TO_EPS_H
 		#define LEMON_GRAPH_TO_EPS_H
 		#include<iostream>
 		#include<fstream>
 		#include<sstream>
 		#include<algorithm>
 		#include<vector>
 		#ifndef WIN32
 		#include<sys/time.h>
 		#include<ctime>
 		#else
 		#define WIN32_LEAN_AND_MEAN
 		#define NOMINMAX
 		#include<windows.h>
 		#endif
 		#include<lemon/math.h>
 		#include<lemon/bits/invalid.h>
 		#include<lemon/dim2.h>
 		#include<lemon/maps.h>
 		#include<lemon/color.h>
 		#include<lemon/bits/bezier.h>
 		///\ingroup eps_io
 		///\file
 		///\brief A well configurable tool for visualizing graphs
 		namespace lemon {
 		  namespace _graph_to_eps_bits {
 		    template<class MT>
 		    class _NegY {
 		    public:
 		      typedef typename MT::Key Key;
 		      typedef typename MT::Value Value;
 		      const MT &map;
 		      int yscale;
 		      _NegY(const MT &m,bool b) : map(m), yscale(1-b*2) {}
 		      Value operator[](Key n) { return Value(map[n].x,map[n].y*yscale);}
 		    };
+		  }
 		///Default traits class of \ref GraphToEps
 		///Default traits class of \ref GraphToEps.
 		///
 		///\c G is the type of the underlying graph.
 		template<class G>
 		struct DefaultGraphToEpsTraits
+		{
 		  typedef G Graph;
 		  typedef typename Graph::Node Node;
 		  typedef typename Graph::NodeIt NodeIt;
 		  typedef typename Graph::Arc Arc;
 		  typedef typename Graph::ArcIt ArcIt;
 		  typedef typename Graph::InArcIt InArcIt;
 		  typedef typename Graph::OutArcIt OutArcIt;
 		  const Graph &g;
 		  std::ostream& os;
 		  typedef ConstMap<typename Graph::Node,dim2::Point<double> > CoordsMapType;
 		  CoordsMapType _coords;
 		  ConstMap<typename Graph::Node,double > _nodeSizes;
 		  ConstMap<typename Graph::Node,int > _nodeShapes;
 		  ConstMap<typename Graph::Node,Color > _nodeColors;
 		  ConstMap<typename Graph::Arc,Color > _arcColors;
 		  ConstMap<typename Graph::Arc,double > _arcWidths;
 		  double _arcWidthScale;
 		  double _nodeScale;
 		  double _xBorder, _yBorder;
 		  double _scale;
 		  double _nodeBorderQuotient;
 		  bool _drawArrows;
 		  double _arrowLength, _arrowWidth;
 		  bool _showNodes, _showArcs;
 		  bool _enableParallel;
 		  double _parArcDist;
 		  bool _showNodeText;
 		  ConstMap<typename Graph::Node,bool > _nodeTexts;
 		  double _nodeTextSize;
 		  bool _showNodePsText;
 		  ConstMap<typename Graph::Node,bool > _nodePsTexts;
 		  char *_nodePsTextsPreamble;
 		  bool _undirected;
 		  bool _pleaseRemoveOsStream;
 		  bool _scaleToA4;
 		  std::string _title;
 		  std::string _copyright;
 		  enum NodeTextColorType
 		    { DIST_COL=0, DIST_BW=1, CUST_COL=2, SAME_COL=3 } _nodeTextColorType;
 		  ConstMap<typename Graph::Node,Color > _nodeTextColors;
 		  bool _autoNodeScale;
 		  bool _autoArcWidthScale;
 		  bool _absoluteNodeSizes;
 		  bool _absoluteArcWidths;
 		  bool _negY;
 		  bool _preScale;
 		  ///Constructor
 		  ///Constructor
 		  ///\param _g  Reference to the graph to be printed.
 		  ///\param _os Reference to the output stream.
-		  ///\param _os Reference to the output stream. By default it is <tt>std::cout</tt>.
 		  ///\param _os Reference to the output stream.
 		  ///By default it is <tt>std::cout</tt>.
 		  ///\param _pros If it is \c true, then the \c ostream referenced by \c _os
 		  ///will be explicitly deallocated by the destructor.
 		  DefaultGraphToEpsTraits(const G &_g,std::ostream& _os=std::cout,
 		                          bool _pros=false) :
 		    g(_g), os(_os),
 		    _coords(dim2::Point<double>(1,1)), _nodeSizes(1), _nodeShapes(0),
 		    _nodeColors(WHITE), _arcColors(BLACK),
 		    _arcWidths(1.0), _arcWidthScale(0.003),
 		    _nodeScale(.01), _xBorder(10), _yBorder(10), _scale(1.0),
 		    _nodeBorderQuotient(.1),
 		    _drawArrows(false), _arrowLength(1), _arrowWidth(0.3),
 		    _showNodes(true), _showArcs(true),
 		    _enableParallel(false), _parArcDist(1),
 		    _showNodeText(false), _nodeTexts(false), _nodeTextSize(1),
 		    _showNodePsText(false), _nodePsTexts(false), _nodePsTextsPreamble(0),
 		    _undirected(lemon::UndirectedTagIndicator<G>::value),
 		    _pleaseRemoveOsStream(_pros), _scaleToA4(false),
 		    _nodeTextColorType(SAME_COL), _nodeTextColors(BLACK),
 		    _autoNodeScale(false),
 		    _autoArcWidthScale(false),
 		    _absoluteNodeSizes(false),
 		    _absoluteArcWidths(false),
 		    _negY(false),
 		    _preScale(true)
 		  {}
 		};
 		///Auxiliary class to implement the named parameters of \ref graphToEps()
 		///Auxiliary class to implement the named parameters of \ref graphToEps().
 		///
 		///For detailed examples see the \ref graph_to_eps_demo.cc demo file.
 		template<class T> class GraphToEps : public T
+		{
 		  // Can't believe it is required by the C++ standard
 		  using T::g;
 		  using T::os;
 		  using T::_coords;
 		  using T::_nodeSizes;
 		  using T::_nodeShapes;
 		  using T::_nodeColors;
 		  using T::_arcColors;
 		  using T::_arcWidths;
 		  using T::_arcWidthScale;
 		  using T::_nodeScale;
 		  using T::_xBorder;
 		  using T::_yBorder;
 		  using T::_scale;
 		  using T::_nodeBorderQuotient;
 		  using T::_drawArrows;
 		  using T::_arrowLength;
 		  using T::_arrowWidth;
 		  using T::_showNodes;
 		  using T::_showArcs;
 		  using T::_enableParallel;
 		  using T::_parArcDist;
 		  using T::_showNodeText;
 		  using T::_nodeTexts;
 		  using T::_nodeTextSize;
 		  using T::_showNodePsText;
 		  using T::_nodePsTexts;
 		  using T::_nodePsTextsPreamble;
 		  using T::_undirected;
 		  using T::_pleaseRemoveOsStream;
 		  using T::_scaleToA4;
 		  using T::_title;
 		  using T::_copyright;
 		  using T::NodeTextColorType;
 		  using T::CUST_COL;
 		  using T::DIST_COL;
 		  using T::DIST_BW;
 		  using T::_nodeTextColorType;
 		  using T::_nodeTextColors;
 		  using T::_autoNodeScale;
 		  using T::_autoArcWidthScale;
 		  using T::_absoluteNodeSizes;
 		  using T::_absoluteArcWidths;
 		  using T::_negY;
 		  using T::_preScale;
 		  // dradnats ++C eht yb deriuqer si ti eveileb t'naC
 		  typedef typename T::Graph Graph;
 		  typedef typename Graph::Node Node;
 		  typedef typename Graph::NodeIt NodeIt;
 		  typedef typename Graph::Arc Arc;
 		  typedef typename Graph::ArcIt ArcIt;
 		  typedef typename Graph::InArcIt InArcIt;
 		  typedef typename Graph::OutArcIt OutArcIt;
 		  static const int INTERPOL_PREC;
 		  static const double A4HEIGHT;
 		  static const double A4WIDTH;
 		  static const double A4BORDER;
 		  bool dontPrint;
 		public:
 		  ///Node shapes
 		  ///Node shapes.
 		  ///
 		  enum NodeShapes {
 		    /// = 0
 		    ///\image html nodeshape_0.png
 		    ///\image latex nodeshape_0.eps "CIRCLE shape (0)" width=2cm
 		    CIRCLE=0,
 		    /// = 1
 		    ///\image html nodeshape_1.png
 		    ///\image latex nodeshape_1.eps "SQUARE shape (1)" width=2cm
 		    ///
 		    SQUARE=1,
 		    /// = 2
 		    ///\image html nodeshape_2.png
 		    ///\image latex nodeshape_2.eps "DIAMOND shape (2)" width=2cm
 		    ///
 		    DIAMOND=2,
 		    /// = 3
 		    ///\image html nodeshape_3.png
 		    ///\image latex nodeshape_2.eps "MALE shape (4)" width=2cm
 		    ///
 		    MALE=3,
 		    /// = 4
 		    ///\image html nodeshape_4.png
 		    ///\image latex nodeshape_2.eps "FEMALE shape (4)" width=2cm
 		    ///
 		    FEMALE=4
 		  };
 		private:
 		  class arcLess {
 		    const Graph &g;
 		  public:
 		    arcLess(const Graph &_g) : g(_g) {}
 		    bool operator()(Arc a,Arc b) const
+		    {
 		      Node ai=std::min(g.source(a),g.target(a));
 		      Node aa=std::max(g.source(a),g.target(a));
 		      Node bi=std::min(g.source(b),g.target(b));
 		      Node ba=std::max(g.source(b),g.target(b));
 		      return ai<bi ||
 		        (ai==bi && (aa < ba ||
 		                    (aa==ba && ai==g.source(a) && bi==g.target(b))));
+		    }
 		  };
 		  bool isParallel(Arc e,Arc f) const
+		  {
 		    return (g.source(e)==g.source(f)&&
 		            g.target(e)==g.target(f)) ||
 		      (g.source(e)==g.target(f)&&
 		       g.target(e)==g.source(f));
+		  }
 		  template<class TT>
 		  static std::string psOut(const dim2::Point<TT> &p)
+		    {
 		      std::ostringstream os;
 		      os << p.x << ' ' << p.y;
 		      return os.str();
+		    }
 		  static std::string psOut(const Color &c)
+		    {
 		      std::ostringstream os;
 		      os << c.red() << ' ' << c.green() << ' ' << c.blue();
 		      return os.str();
+		    }
 		public:
 		  GraphToEps(const T &t) : T(t), dontPrint(false) {};
 		  template<class X> struct CoordsTraits : public T {
 		  typedef X CoordsMapType;
 		    const X &_coords;
 		    CoordsTraits(const T &t,const X &x) : T(t), _coords(x) {}
 		  };
 		  ///Sets the map of the node coordinates
 		  ///Sets the map of the node coordinates.
 		  ///\param x must be a node map with \ref dim2::Point "dim2::Point<double>" or
 		  ///\ref dim2::Point "dim2::Point<int>" values.
 		  template<class X> GraphToEps<CoordsTraits<X> > coords(const X &x) {
 		    dontPrint=true;
 		    return GraphToEps<CoordsTraits<X> >(CoordsTraits<X>(*this,x));
+		  }
 		  template<class X> struct NodeSizesTraits : public T {
 		    const X &_nodeSizes;
 		    NodeSizesTraits(const T &t,const X &x) : T(t), _nodeSizes(x) {}
 		  };
 		  ///Sets the map of the node sizes
 		  ///Sets the map of the node sizes.
 		  ///\param x must be a node map with \c double (or convertible) values.
 		  template<class X> GraphToEps<NodeSizesTraits<X> > nodeSizes(const X &x)
+		  {
 		    dontPrint=true;
 		    return GraphToEps<NodeSizesTraits<X> >(NodeSizesTraits<X>(*this,x));
+		  }
 		  template<class X> struct NodeShapesTraits : public T {
 		    const X &_nodeShapes;
 		    NodeShapesTraits(const T &t,const X &x) : T(t), _nodeShapes(x) {}
 		  };
 		  ///Sets the map of the node shapes
 		  ///Sets the map of the node shapes.
 		  ///The available shape values
 		  ///can be found in \ref NodeShapes "enum NodeShapes".
 		  ///\param x must be a node map with \c int (or convertible) values.
 		  ///\sa NodeShapes
 		  template<class X> GraphToEps<NodeShapesTraits<X> > nodeShapes(const X &x)
+		  {
 		    dontPrint=true;
 		    return GraphToEps<NodeShapesTraits<X> >(NodeShapesTraits<X>(*this,x));
+		  }
 		  template<class X> struct NodeTextsTraits : public T {
 		    const X &_nodeTexts;
 		    NodeTextsTraits(const T &t,const X &x) : T(t), _nodeTexts(x) {}
 		  };
 		  ///Sets the text printed on the nodes
 		  ///Sets the text printed on the nodes.
 		  ///\param x must be a node map with type that can be pushed to a standard
 		  ///\c ostream.
 		  template<class X> GraphToEps<NodeTextsTraits<X> > nodeTexts(const X &x)
+		  {
 		    dontPrint=true;
 		    _showNodeText=true;
 		    return GraphToEps<NodeTextsTraits<X> >(NodeTextsTraits<X>(*this,x));
+		  }
 		  template<class X> struct NodePsTextsTraits : public T {
 		    const X &_nodePsTexts;
 		    NodePsTextsTraits(const T &t,const X &x) : T(t), _nodePsTexts(x) {}
 		  };
 		  ///Inserts a PostScript block to the nodes
 		  ///With this command it is possible to insert a verbatim PostScript
 		  ///block to the nodes.
 		  ///The PS current point will be moved to the center of the node before
 		  ///the PostScript block inserted.
 		  ///
 		  ///Before and after the block a newline character is inserted so you
 		  ///don't have to bother with the separators.
 		  ///
 		  ///\param x must be a node map with type that can be pushed to a standard
 		  ///\c ostream.
 		  ///
 		  ///\sa nodePsTextsPreamble()
 		  template<class X> GraphToEps<NodePsTextsTraits<X> > nodePsTexts(const X &x)
+		  {
 		    dontPrint=true;
 		    _showNodePsText=true;
 		    return GraphToEps<NodePsTextsTraits<X> >(NodePsTextsTraits<X>(*this,x));
+		  }
 		  template<class X> struct ArcWidthsTraits : public T {
 		    const X &_arcWidths;
 		    ArcWidthsTraits(const T &t,const X &x) : T(t), _arcWidths(x) {}
 		  };
 		  ///Sets the map of the arc widths
 		  ///Sets the map of the arc widths.
 		  ///\param x must be an arc map with \c double (or convertible) values.
 		  template<class X> GraphToEps<ArcWidthsTraits<X> > arcWidths(const X &x)
+		  {
 		    dontPrint=true;
 		    return GraphToEps<ArcWidthsTraits<X> >(ArcWidthsTraits<X>(*this,x));
+		  }
 		  template<class X> struct NodeColorsTraits : public T {
 		    const X &_nodeColors;
 		    NodeColorsTraits(const T &t,const X &x) : T(t), _nodeColors(x) {}
 		  };
 		  ///Sets the map of the node colors
 		  ///Sets the map of the node colors.
 		  ///\param x must be a node map with \ref Color values.
 		  ///
 		  ///\sa Palette
 		  template<class X> GraphToEps<NodeColorsTraits<X> >
 		  nodeColors(const X &x)
+		  {
 		    dontPrint=true;
 		    return GraphToEps<NodeColorsTraits<X> >(NodeColorsTraits<X>(*this,x));
+		  }
 		  template<class X> struct NodeTextColorsTraits : public T {
 		    const X &_nodeTextColors;
 		    NodeTextColorsTraits(const T &t,const X &x) : T(t), _nodeTextColors(x) {}
 		  };
 		  ///Sets the map of the node text colors
 		  ///Sets the map of the node text colors.
 		  ///\param x must be a node map with \ref Color values.
 		  ///
 		  ///\sa Palette
 		  template<class X> GraphToEps<NodeTextColorsTraits<X> >
 		  nodeTextColors(const X &x)
+		  {
 		    dontPrint=true;
 		    _nodeTextColorType=CUST_COL;
 		    return GraphToEps<NodeTextColorsTraits<X> >
 		      (NodeTextColorsTraits<X>(*this,x));
+		  }
 		  template<class X> struct ArcColorsTraits : public T {
 		    const X &_arcColors;
 		    ArcColorsTraits(const T &t,const X &x) : T(t), _arcColors(x) {}
 		  };
 		  ///Sets the map of the arc colors
 		  ///Sets the map of the arc colors.
 		  ///\param x must be an arc map with \ref Color values.
 		  ///
 		  ///\sa Palette
 		  template<class X> GraphToEps<ArcColorsTraits<X> >
 		  arcColors(const X &x)
+		  {
 		    dontPrint=true;
 		    return GraphToEps<ArcColorsTraits<X> >(ArcColorsTraits<X>(*this,x));
+		  }
 		  ///Sets a global scale factor for node sizes
 		  ///Sets a global scale factor for node sizes.
 		  ///
 		  /// If nodeSizes() is not given, this function simply sets the node
 		  /// sizes to \c d.  If nodeSizes() is given, but
 		  /// autoNodeScale() is not, then the node size given by
 		  /// nodeSizes() will be multiplied by the value \c d.
 		  /// If both nodeSizes() and autoNodeScale() are used, then the
 		  /// node sizes will be scaled in such a way that the greatest size will be
 		  /// equal to \c d.
 		  /// \sa nodeSizes()
 		  /// \sa autoNodeScale()
 		  GraphToEps<T> &nodeScale(double d=.01) {_nodeScale=d;return *this;}
 		  ///Turns on/off the automatic node size scaling.
 		  ///Turns on/off the automatic node size scaling.
 		  ///
 		  ///\sa nodeScale()
 		  ///
 		  GraphToEps<T> &autoNodeScale(bool b=true) {
 		    _autoNodeScale=b;return *this;
+		  }
 		  ///Turns on/off the absolutematic node size scaling.
 		  ///Turns on/off the absolutematic node size scaling.
 		  ///
 		  ///\sa nodeScale()
 		  ///
 		  GraphToEps<T> &absoluteNodeSizes(bool b=true) {
 		    _absoluteNodeSizes=b;return *this;
+		  }
 		  ///Negates the Y coordinates.
 		  GraphToEps<T> &negateY(bool b=true) {
 		    _negY=b;return *this;
+		  }
 		  ///Turn on/off pre-scaling
 		  ///By default graphToEps() rescales the whole image in order to avoid
 		  ///very big or very small bounding boxes.
 		  ///
 		  ///This (p)rescaling can be turned off with this function.
 		  ///
 		  GraphToEps<T> &preScale(bool b=true) {
 		    _preScale=b;return *this;
+		  }
 		  ///Sets a global scale factor for arc widths
 		  /// Sets a global scale factor for arc widths.
 		  ///
 		  /// If arcWidths() is not given, this function simply sets the arc
 		  /// widths to \c d.  If arcWidths() is given, but
 		  /// autoArcWidthScale() is not, then the arc withs given by
 		  /// arcWidths() will be multiplied by the value \c d.
 		  /// If both arcWidths() and autoArcWidthScale() are used, then the
 		  /// arc withs will be scaled in such a way that the greatest width will be
 		  /// equal to \c d.
 		  GraphToEps<T> &arcWidthScale(double d=.003) {_arcWidthScale=d;return *this;}
 		  ///Turns on/off the automatic arc width scaling.
 		  ///Turns on/off the automatic arc width scaling.
 		  ///
 		  ///\sa arcWidthScale()
 		  ///
 		  GraphToEps<T> &autoArcWidthScale(bool b=true) {
 		    _autoArcWidthScale=b;return *this;
+		  }
 		  ///Turns on/off the absolutematic arc width scaling.
 		  ///Turns on/off the absolutematic arc width scaling.
 		  ///
 		  ///\sa arcWidthScale()
 		  ///
 		  GraphToEps<T> &absoluteArcWidths(bool b=true) {
 		    _absoluteArcWidths=b;return *this;
+		  }
 		  ///Sets a global scale factor for the whole picture
 		  GraphToEps<T> &scale(double d) {_scale=d;return *this;}
 		  ///Sets the width of the border around the picture
 		  GraphToEps<T> &border(double b=10) {_xBorder=_yBorder=b;return *this;}
 		  ///Sets the width of the border around the picture
 		  GraphToEps<T> &border(double x, double y) {
 		    _xBorder=x;_yBorder=y;return *this;
+		  }
 		  ///Sets whether to draw arrows
 		  GraphToEps<T> &drawArrows(bool b=true) {_drawArrows=b;return *this;}
 		  ///Sets the length of the arrowheads
 		  GraphToEps<T> &arrowLength(double d=1.0) {_arrowLength*=d;return *this;}
 		  ///Sets the width of the arrowheads
 		  GraphToEps<T> &arrowWidth(double d=.3) {_arrowWidth*=d;return *this;}
 		  ///Scales the drawing to fit to A4 page
 		  GraphToEps<T> &scaleToA4() {_scaleToA4=true;return *this;}
 		  ///Enables parallel arcs
 		  GraphToEps<T> &enableParallel(bool b=true) {_enableParallel=b;return *this;}
 		  ///Sets the distance between parallel arcs
 		  GraphToEps<T> &parArcDist(double d) {_parArcDist*=d;return *this;}
 		  ///Hides the arcs
 		  GraphToEps<T> &hideArcs(bool b=true) {_showArcs=!b;return *this;}
 		  ///Hides the nodes
 		  GraphToEps<T> &hideNodes(bool b=true) {_showNodes=!b;return *this;}
 		  ///Sets the size of the node texts
 		  GraphToEps<T> &nodeTextSize(double d) {_nodeTextSize=d;return *this;}
 		  ///Sets the color of the node texts to be different from the node color
 		  ///Sets the color of the node texts to be as different from the node color
 		  ///as it is possible.
 		  GraphToEps<T> &distantColorNodeTexts()
 		  {_nodeTextColorType=DIST_COL;return *this;}
 		  ///Sets the color of the node texts to be black or white and always visible.
 		  ///Sets the color of the node texts to be black or white according to
 		  ///which is more different from the node color.
 		  GraphToEps<T> &distantBWNodeTexts()
 		  {_nodeTextColorType=DIST_BW;return *this;}
 		  ///Gives a preamble block for node Postscript block.
 		  ///Gives a preamble block for node Postscript block.
 		  ///
 		  ///\sa nodePsTexts()
 		  GraphToEps<T> & nodePsTextsPreamble(const char *str) {
 		    _nodePsTextsPreamble=str ;return *this;
+		  }
 		  ///Sets whether the graph is undirected
 		  ///Sets whether the graph is undirected.
 		  ///
 		  ///This setting is the default for undirected graphs.
 		  ///
 		  ///\sa directed()
 		   GraphToEps<T> &undirected(bool b=true) {_undirected=b;return *this;}
 		  ///Sets whether the graph is directed
 		  ///Sets whether the graph is directed.
 		  ///Use it to show the edges as a pair of directed ones.
 		  ///
 		  ///This setting is the default for digraphs.
 		  ///
 		  ///\sa undirected()
 		  GraphToEps<T> &directed(bool b=true) {_undirected=!b;return *this;}
 		  ///Sets the title.
 		  ///Sets the title of the generated image,
 		  ///namely it inserts a <tt>%%Title:</tt> DSC field to the header of
 		  ///the EPS file.
 		  GraphToEps<T> &title(const std::string &t) {_title=t;return *this;}
 		  ///Sets the copyright statement.
 		  ///Sets the copyright statement of the generated image,
 		  ///namely it inserts a <tt>%%Copyright:</tt> DSC field to the header of
 		  ///the EPS file.
 		  GraphToEps<T> &copyright(const std::string &t) {_copyright=t;return *this;}
 		protected:
 		  bool isInsideNode(dim2::Point<double> p, double r,int t)
+		  {
 		    switch(t) {
 		    case CIRCLE:
 		    case MALE:
 		    case FEMALE:
 		      return p.normSquare()<=r*r;
 		    case SQUARE:
 		      return p.x<=r&&p.x>=-r&&p.y<=r&&p.y>=-r;
 		    case DIAMOND:
 		      return p.x+p.y<=r && p.x-p.y<=r && -p.x+p.y<=r && -p.x-p.y<=r;
+		    }
 		    return false;
+		  }
 		public:
 		  ~GraphToEps() { }
 		  ///Draws the graph.
 		  ///Like other functions using
 		  ///\ref named-templ-func-param "named template parameters",
 		  ///this function calls the algorithm itself, i.e. in this case
 		  ///it draws the graph.
 		  void run() {
 		    //\todo better 'epsilon' would be nice here.
 		    const double EPSILON=1e-9;
 		    if(dontPrint) return;
 		    _graph_to_eps_bits::_NegY<typename T::CoordsMapType>
 		      mycoords(_coords,_negY);
 		    os << "%!PS-Adobe-2.0 EPSF-2.0\n";
 		    if(_title.size()>0) os << "%%Title: " << _title << '\n';
 		     if(_copyright.size()>0) os << "%%Copyright: " << _copyright << '\n';
 		    os << "%%Creator: LEMON, graphToEps()\n";
+		    {
 		#ifndef WIN32
 		      timeval tv;
 		      gettimeofday(&tv, 0);
 		      char cbuf[26];
 		      ctime_r(&tv.tv_sec,cbuf);
 		      os << "%%CreationDate: " << cbuf;
 		#else
 		      SYSTEMTIME time;
 		      char buf1[11], buf2[9], buf3[5];
 		      GetSystemTime(&time);
 		      if (GetDateFormat(LOCALE_USER_DEFAULT, 0, &time,
 		                        "ddd MMM dd", buf1, 11) &&
 		          GetTimeFormat(LOCALE_USER_DEFAULT, 0, &time,
 		                        "HH':'mm':'ss", buf2, 9) &&
 		          GetDateFormat(LOCALE_USER_DEFAULT, 0, &time,
 		                                "yyyy", buf3, 5)) {
 		        os << "%%CreationDate: " << buf1 << ' '
 		           << buf2 << ' ' << buf3 << std::endl;
+		      }
 		#endif
+		    }
 		    if (_autoArcWidthScale) {
 		      double max_w=0;
 		      for(ArcIt e(g);e!=INVALID;++e)
 		        max_w=std::max(double(_arcWidths[e]),max_w);
 		      //\todo better 'epsilon' would be nice here.
 		      if(max_w>EPSILON) {
 		        _arcWidthScale/=max_w;
+		      }
+		    }
 		    if (_autoNodeScale) {
 		      double max_s=0;
 		      for(NodeIt n(g);n!=INVALID;++n)
 		        max_s=std::max(double(_nodeSizes[n]),max_s);
 		      //\todo better 'epsilon' would be nice here.
 		      if(max_s>EPSILON) {
 		        _nodeScale/=max_s;
+		      }
+		    }
 		    double diag_len = 1;
 		    if(!(_absoluteNodeSizes&&_absoluteArcWidths)) {
 		      dim2::BoundingBox<double> bb;
 		      for(NodeIt n(g);n!=INVALID;++n) bb.add(mycoords[n]);
 		      if (bb.empty()) {
 		        bb = dim2::BoundingBox<double>(dim2::Point<double>(0,0));
+		      }
 		      diag_len = std::sqrt((bb.bottomLeft()-bb.topRight()).normSquare());
 		      if(diag_len<EPSILON) diag_len = 1;
 		      if(!_absoluteNodeSizes) _nodeScale*=diag_len;
 		      if(!_absoluteArcWidths) _arcWidthScale*=diag_len;
+		    }
 		    dim2::BoundingBox<double> bb;
 		    for(NodeIt n(g);n!=INVALID;++n) {
 		      double ns=_nodeSizes[n]*_nodeScale;
 		      dim2::Point<double> p(ns,ns);
 		      switch(_nodeShapes[n]) {
 		      case CIRCLE:
 		      case SQUARE:
 		      case DIAMOND:
 		        bb.add(p+mycoords[n]);
 		        bb.add(-p+mycoords[n]);
 		        break;
 		      case MALE:
 		        bb.add(-p+mycoords[n]);
 		        bb.add(dim2::Point<double>(1.5*ns,1.5*std::sqrt(3.0)*ns)+mycoords[n]);
 		        break;
 		      case FEMALE:
 		        bb.add(p+mycoords[n]);
 		        bb.add(dim2::Point<double>(-ns,-3.01*ns)+mycoords[n]);
 		        break;
+		      }
+		    }
 		    if (bb.empty()) {
 		      bb = dim2::BoundingBox<double>(dim2::Point<double>(0,0));
+		    }
 		    if(_scaleToA4)
 		      os <<"%%BoundingBox: 0 0 596 842\n%%DocumentPaperSizes: a4\n";
 		    else {
 		      if(_preScale) {
 		        //Rescale so that BoundingBox won't be neither to big nor too small.
 		        while(bb.height()*_scale>1000||bb.width()*_scale>1000) _scale/=10;
 		        while(bb.height()*_scale<100||bb.width()*_scale<100) _scale*=10;
+		      }
 		      os << "%%BoundingBox: "
 		         << int(floor(bb.left()   * _scale - _xBorder)) << ' '
 		         << int(floor(bb.bottom() * _scale - _yBorder)) << ' '
 		         << int(ceil(bb.right()  * _scale + _xBorder)) << ' '
 		         << int(ceil(bb.top()    * _scale + _yBorder)) << '\n';
+		    }
 		    os << "%%EndComments\n";
 		    //x1 y1 x2 y2 x3 y3 cr cg cb w
 		    os << "/lb { setlinewidth setrgbcolor newpath moveto\n"
 		       << "      4 2 roll 1 index 1 index curveto stroke } bind def\n";
-		    os << "/l { setlinewidth setrgbcolor newpath moveto lineto stroke } bind def\n";
 		    os << "/l { setlinewidth setrgbcolor newpath moveto lineto stroke }"
 		       << " bind def\n";
 		    //x y r
-		    os << "/c { newpath dup 3 index add 2 index moveto 0 360 arc closepath } bind def\n";
 		    os << "/c { newpath dup 3 index add 2 index moveto 0 360 arc closepath }"
 		       << " bind def\n";
 		    //x y r
 		    os << "/sq { newpath 2 index 1 index add 2 index 2 index add moveto\n"
 		       << "      2 index 1 index sub 2 index 2 index add lineto\n"
 		       << "      2 index 1 index sub 2 index 2 index sub lineto\n"
 		       << "      2 index 1 index add 2 index 2 index sub lineto\n"
 		       << "      closepath pop pop pop} bind def\n";
 		    //x y r
 		    os << "/di { newpath 2 index 1 index add 2 index moveto\n"
 		       << "      2 index             2 index 2 index add lineto\n"
 		       << "      2 index 1 index sub 2 index             lineto\n"
 		       << "      2 index             2 index 2 index sub lineto\n"
 		       << "      closepath pop pop pop} bind def\n";
 		    // x y r cr cg cb
 		    os << "/nc { 0 0 0 setrgbcolor 5 index 5 index 5 index c fill\n"
 		       << "     setrgbcolor " << 1+_nodeBorderQuotient << " div c fill\n"
 		       << "   } bind def\n";
 		    os << "/nsq { 0 0 0 setrgbcolor 5 index 5 index 5 index sq fill\n"
 		       << "     setrgbcolor " << 1+_nodeBorderQuotient << " div sq fill\n"
 		       << "   } bind def\n";
 		    os << "/ndi { 0 0 0 setrgbcolor 5 index 5 index 5 index di fill\n"
 		       << "     setrgbcolor " << 1+_nodeBorderQuotient << " div di fill\n"
 		       << "   } bind def\n";
 		    os << "/nfemale { 0 0 0 setrgbcolor 3 index "
 		       << _nodeBorderQuotient/(1+_nodeBorderQuotient)
 		       << " 1.5 mul mul setlinewidth\n"
 		       << "  newpath 5 index 5 index moveto "
 		       << "5 index 5 index 5 index 3.01 mul sub\n"
 		       << "  lineto 5 index 4 index .7 mul sub 5 index 5 index 2.2 mul sub moveto\n"
 		       << "  5 index 4 index .7 mul add 5 index 5 index 2.2 mul sub lineto stroke\n"
 		       << "  lineto 5 index 4 index .7 mul sub 5 index 5 index 2.2 mul sub"
 		       << " moveto\n"
 		       << "  5 index 4 index .7 mul add 5 index 5 index 2.2 mul sub lineto "
 		       << "stroke\n"
 		       << "  5 index 5 index 5 index c fill\n"
 		       << "  setrgbcolor " << 1+_nodeBorderQuotient << " div c fill\n"
 		       << "  } bind def\n";
 		    os << "/nmale {\n"
 		       << "  0 0 0 setrgbcolor 3 index "
 		       << _nodeBorderQuotient/(1+_nodeBorderQuotient)
 		       <<" 1.5 mul mul setlinewidth\n"
 		       << "  newpath 5 index 5 index moveto\n"
 		       << "  5 index 4 index 1 mul 1.5 mul add\n"
 		       << "  5 index 5 index 3 sqrt 1.5 mul mul add\n"
 		       << "  1 index 1 index lineto\n"
 		       << "  1 index 1 index 7 index sub moveto\n"
 		       << "  1 index 1 index lineto\n"
-		       << "  exch 5 index 3 sqrt .5 mul mul sub exch 5 index .5 mul sub lineto\n"
 		       << "  exch 5 index 3 sqrt .5 mul mul sub exch 5 index .5 mul sub"
 		       << " lineto\n"
 		       << "  stroke\n"
 		       << "  5 index 5 index 5 index c fill\n"
 		       << "  setrgbcolor " << 1+_nodeBorderQuotient << " div c fill\n"
 		       << "  } bind def\n";
 		    os << "/arrl " << _arrowLength << " def\n";
 		    os << "/arrw " << _arrowWidth << " def\n";
 		    // l dx_norm dy_norm
 		    os << "/lrl { 2 index mul exch 2 index mul exch rlineto pop} bind def\n";
 		    //len w dx_norm dy_norm x1 y1 cr cg cb
-		    os << "/arr { setrgbcolor /y1 exch def /x1 exch def /dy exch def /dx exch def\n"
 		    os << "/arr { setrgbcolor /y1 exch def /x1 exch def /dy exch def /dx "
 		       << "exch def\n"
 		       << "       /w exch def /len exch def\n"
-		      //         << "       0.1 setlinewidth x1 y1 moveto dx len mul dy len mul rlineto stroke"
 		      //<< "0.1 setlinewidth x1 y1 moveto dx len mul dy len mul rlineto stroke"
 		       << "       newpath x1 dy w 2 div mul add y1 dx w 2 div mul sub moveto\n"
 		       << "       len w sub arrl sub dx dy lrl\n"
 		       << "       arrw dy dx neg lrl\n"
 		       << "       dx arrl w add mul dy w 2 div arrw add mul sub\n"
 		       << "       dy arrl w add mul dx w 2 div arrw add mul add rlineto\n"
 		       << "       dx arrl w add mul neg dy w 2 div arrw add mul sub\n"
 		       << "       dy arrl w add mul neg dx w 2 div arrw add mul add rlineto\n"
 		       << "       arrw dy dx neg lrl\n"
 		       << "       len w sub arrl sub neg dx dy lrl\n"
 		       << "       closepath fill } bind def\n";
 		    os << "/cshow { 2 index 2 index moveto dup stringwidth pop\n"
 		       << "         neg 2 div fosi .35 mul neg rmoveto show pop pop} def\n";
 		    os << "\ngsave\n";
 		    if(_scaleToA4)
 		      if(bb.height()>bb.width()) {
 		        double sc= std::min((A4HEIGHT-2*A4BORDER)/bb.height(),
 		                  (A4WIDTH-2*A4BORDER)/bb.width());
 		        os << ((A4WIDTH -2*A4BORDER)-sc*bb.width())/2 + A4BORDER << ' '
 		           << ((A4HEIGHT-2*A4BORDER)-sc*bb.height())/2 + A4BORDER
 		           << " translate\n"
 		           << sc << " dup scale\n"
 		           << -bb.left() << ' ' << -bb.bottom() << " translate\n";
+		      }
 		      else {
 		        //\todo Verify centering
 		        double sc= std::min((A4HEIGHT-2*A4BORDER)/bb.width(),
 		                  (A4WIDTH-2*A4BORDER)/bb.height());
 		        os << ((A4WIDTH -2*A4BORDER)-sc*bb.height())/2 + A4BORDER << ' '
 		           << ((A4HEIGHT-2*A4BORDER)-sc*bb.width())/2 + A4BORDER
 		           << " translate\n"
 		           << sc << " dup scale\n90 rotate\n"
 		           << -bb.left() << ' ' << -bb.top() << " translate\n";
+		        }
 		    else if(_scale!=1.0) os << _scale << " dup scale\n";
 		    if(_showArcs) {
 		      os << "%Arcs:\ngsave\n";
 		      if(_enableParallel) {
 		        std::vector<Arc> el;
 		        for(ArcIt e(g);e!=INVALID;++e)
 		          if((!_undirected||g.source(e)<g.target(e))&&_arcWidths[e]>0
 		             &&g.source(e)!=g.target(e))
 		            el.push_back(e);
 		        std::sort(el.begin(),el.end(),arcLess(g));
 		        typename std::vector<Arc>::iterator j;
 		        for(typename std::vector<Arc>::iterator i=el.begin();i!=el.end();i=j) {
 		          for(j=i+1;j!=el.end()&&isParallel(*i,*j);++j) ;
 		          double sw=0;
 		          for(typename std::vector<Arc>::iterator e=i;e!=j;++e)
 		            sw+=_arcWidths[*e]*_arcWidthScale+_parArcDist;
 		          sw-=_parArcDist;
 		          sw/=-2.0;
 		          dim2::Point<double>
 		            dvec(mycoords[g.target(*i)]-mycoords[g.source(*i)]);
 		          double l=std::sqrt(dvec.normSquare());
 		          //\todo better 'epsilon' would be nice here.
 		          dim2::Point<double> d(dvec/std::max(l,EPSILON));
 		           dim2::Point<double> m;
-		//           m=dim2::Point<double>(mycoords[g.target(*i)]+mycoords[g.source(*i)])/2.0;
 		//           m=dim2::Point<double>(mycoords[g.target(*i)]+
 		//                                 mycoords[g.source(*i)])/2.0;
 		//            m=dim2::Point<double>(mycoords[g.source(*i)])+
 		//             dvec*(double(_nodeSizes[g.source(*i)])/
 		//                (_nodeSizes[g.source(*i)]+_nodeSizes[g.target(*i)]));
 		           m=dim2::Point<double>(mycoords[g.source(*i)])+
 		            d*(l+_nodeSizes[g.source(*i)]-_nodeSizes[g.target(*i)])/2.0;
 		          for(typename std::vector<Arc>::iterator e=i;e!=j;++e) {
 		            sw+=_arcWidths[*e]*_arcWidthScale/2.0;
 		            dim2::Point<double> mm=m+rot90(d)*sw/.75;
 		            if(_drawArrows) {
 		              int node_shape;
 		              dim2::Point<double> s=mycoords[g.source(*e)];
 		              dim2::Point<double> t=mycoords[g.target(*e)];
 		              double rn=_nodeSizes[g.target(*e)]*_nodeScale;
 		              node_shape=_nodeShapes[g.target(*e)];
 		              dim2::Bezier3 bez(s,mm,mm,t);
 		              double t1=0,t2=1;
 		              for(int ii=0;ii<INTERPOL_PREC;++ii)
 		                if(isInsideNode(bez((t1+t2)/2)-t,rn,node_shape)) t2=(t1+t2)/2;
 		                else t1=(t1+t2)/2;
 		              dim2::Point<double> apoint=bez((t1+t2)/2);
 		              rn = _arrowLength+_arcWidths[*e]*_arcWidthScale;
 		              rn*=rn;
 		              t2=(t1+t2)/2;t1=0;
 		              for(int ii=0;ii<INTERPOL_PREC;++ii)
 		                if((bez((t1+t2)/2)-apoint).normSquare()>rn) t1=(t1+t2)/2;
 		                else t2=(t1+t2)/2;
 		              dim2::Point<double> linend=bez((t1+t2)/2);
 		              bez=bez.before((t1+t2)/2);
 		//               rn=_nodeSizes[g.source(*e)]*_nodeScale;
 		//               node_shape=_nodeShapes[g.source(*e)];
 		//               t1=0;t2=1;
 		//               for(int i=0;i<INTERPOL_PREC;++i)
-		//                 if(isInsideNode(bez((t1+t2)/2)-t,rn,node_shape)) t1=(t1+t2)/2;
 		//                 if(isInsideNode(bez((t1+t2)/2)-t,rn,node_shape))
 		//                   t1=(t1+t2)/2;
 		//                 else t2=(t1+t2)/2;
 		//               bez=bez.after((t1+t2)/2);
 		              os << _arcWidths[*e]*_arcWidthScale << " setlinewidth "
 		                 << _arcColors[*e].red() << ' '
 		                 << _arcColors[*e].green() << ' '
 		                 << _arcColors[*e].blue() << " setrgbcolor newpath\n"
 		                 << bez.p1.x << ' ' <<  bez.p1.y << " moveto\n"
 		                 << bez.p2.x << ' ' << bez.p2.y << ' '
 		                 << bez.p3.x << ' ' << bez.p3.y << ' '
 		                 << bez.p4.x << ' ' << bez.p4.y << " curveto stroke\n";
 		              dim2::Point<double> dd(rot90(linend-apoint));
 		              dd*=(.5*_arcWidths[*e]*_arcWidthScale+_arrowWidth)/
 		                std::sqrt(dd.normSquare());
 		              os << "newpath " << psOut(apoint) << " moveto "
 		                 << psOut(linend+dd) << " lineto "
 		                 << psOut(linend-dd) << " lineto closepath fill\n";
+		            }
 		            else {
 		              os << mycoords[g.source(*e)].x << ' '
 		                 << mycoords[g.source(*e)].y << ' '
 		                 << mm.x << ' ' << mm.y << ' '
 		                 << mycoords[g.target(*e)].x << ' '
 		                 << mycoords[g.target(*e)].y << ' '
 		                 << _arcColors[*e].red() << ' '
 		                 << _arcColors[*e].green() << ' '
 		                 << _arcColors[*e].blue() << ' '
 		                 << _arcWidths[*e]*_arcWidthScale << " lb\n";
+		            }
 		            sw+=_arcWidths[*e]*_arcWidthScale/2.0+_parArcDist;
+		          }
+		        }
+		      }
 		      else for(ArcIt e(g);e!=INVALID;++e)
 		        if((!_undirected||g.source(e)<g.target(e))&&_arcWidths[e]>0
 		           &&g.source(e)!=g.target(e)) {
 		          if(_drawArrows) {
 		            dim2::Point<double> d(mycoords[g.target(e)]-mycoords[g.source(e)]);
 		            double rn=_nodeSizes[g.target(e)]*_nodeScale;
 		            int node_shape=_nodeShapes[g.target(e)];
 		            double t1=0,t2=1;
 		            for(int i=0;i<INTERPOL_PREC;++i)
 		              if(isInsideNode((-(t1+t2)/2)*d,rn,node_shape)) t1=(t1+t2)/2;
 		              else t2=(t1+t2)/2;
 		            double l=std::sqrt(d.normSquare());
 		            d/=l;
 		            os << l*(1-(t1+t2)/2) << ' '
 		               << _arcWidths[e]*_arcWidthScale << ' '
 		               << d.x << ' ' << d.y << ' '
 		               << mycoords[g.source(e)].x << ' '
 		               << mycoords[g.source(e)].y << ' '
 		               << _arcColors[e].red() << ' '
 		               << _arcColors[e].green() << ' '
 		               << _arcColors[e].blue() << " arr\n";
+		          }
 		          else os << mycoords[g.source(e)].x << ' '
 		                  << mycoords[g.source(e)].y << ' '
 		                  << mycoords[g.target(e)].x << ' '
 		                  << mycoords[g.target(e)].y << ' '
 		                  << _arcColors[e].red() << ' '
 		                  << _arcColors[e].green() << ' '
 		                  << _arcColors[e].blue() << ' '
 		                  << _arcWidths[e]*_arcWidthScale << " l\n";
+		        }
 		      os << "grestore\n";
+		    }
 		    if(_showNodes) {
 		      os << "%Nodes:\ngsave\n";
 		      for(NodeIt n(g);n!=INVALID;++n) {
 		        os << mycoords[n].x << ' ' << mycoords[n].y << ' '
 		           << _nodeSizes[n]*_nodeScale << ' '
 		           << _nodeColors[n].red() << ' '
 		           << _nodeColors[n].green() << ' '
 		           << _nodeColors[n].blue() << ' ';
 		        switch(_nodeShapes[n]) {
 		        case CIRCLE:
 		          os<< "nc";break;
 		        case SQUARE:
 		          os<< "nsq";break;
 		        case DIAMOND:
 		          os<< "ndi";break;
 		        case MALE:
 		          os<< "nmale";break;
 		        case FEMALE:
 		          os<< "nfemale";break;
+		        }
 		        os<<'\n';
+		      }
 		      os << "grestore\n";
+		    }
 		    if(_showNodeText) {
 		      os << "%Node texts:\ngsave\n";
 		      os << "/fosi " << _nodeTextSize << " def\n";
 		      os << "(Helvetica) findfont fosi scalefont setfont\n";
 		      for(NodeIt n(g);n!=INVALID;++n) {
 		        switch(_nodeTextColorType) {
 		        case DIST_COL:
 		          os << psOut(distantColor(_nodeColors[n])) << " setrgbcolor\n";
 		          break;
 		        case DIST_BW:
 		          os << psOut(distantBW(_nodeColors[n])) << " setrgbcolor\n";
 		          break;
 		        case CUST_COL:
 		          os << psOut(distantColor(_nodeTextColors[n])) << " setrgbcolor\n";
 		          break;
 		        default:
 		          os << "0 0 0 setrgbcolor\n";
+		        }
 		        os << mycoords[n].x << ' ' << mycoords[n].y
 		           << " (" << _nodeTexts[n] << ") cshow\n";
+		      }
 		      os << "grestore\n";
+		    }
 		    if(_showNodePsText) {
 		      os << "%Node PS blocks:\ngsave\n";
 		      for(NodeIt n(g);n!=INVALID;++n)
 		        os << mycoords[n].x << ' ' << mycoords[n].y
 		           << " moveto\n" << _nodePsTexts[n] << "\n";
 		      os << "grestore\n";
+		    }
 		    os << "grestore\nshowpage\n";
 		    //CleanUp:
 		    if(_pleaseRemoveOsStream) {delete &os;}
+		  }
 		  ///\name Aliases
 		  ///These are just some aliases to other parameter setting functions.
 		  ///@{
 		  ///An alias for arcWidths()
 		  template<class X> GraphToEps<ArcWidthsTraits<X> > edgeWidths(const X &x)
+		  {
 		    return arcWidths(x);
+		  }
 		  ///An alias for arcColors()
 		  template<class X> GraphToEps<ArcColorsTraits<X> >
 		  edgeColors(const X &x)
+		  {
 		    return arcColors(x);
+		  }
 		  ///An alias for arcWidthScale()
 		  GraphToEps<T> &edgeWidthScale(double d) {return arcWidthScale(d);}
 		  ///An alias for autoArcWidthScale()
 		  GraphToEps<T> &autoEdgeWidthScale(bool b=true)
+		  {
 		    return autoArcWidthScale(b);
+		  }
 		  ///An alias for absoluteArcWidths()
 		  GraphToEps<T> &absoluteEdgeWidths(bool b=true)
+		  {
 		    return absoluteArcWidths(b);
+		  }
 		  ///An alias for parArcDist()
 		  GraphToEps<T> &parEdgeDist(double d) {return parArcDist(d);}
 		  ///An alias for hideArcs()
 		  GraphToEps<T> &hideEdges(bool b=true) {return hideArcs(b);}
 		  ///@}
 		};
 		template<class T>
 		const int GraphToEps<T>::INTERPOL_PREC = 20;
 		template<class T>
 		const double GraphToEps<T>::A4HEIGHT = 841.8897637795276;
 		template<class T>
 		const double GraphToEps<T>::A4WIDTH  = 595.275590551181;
 		template<class T>
 		const double GraphToEps<T>::A4BORDER = 15;
 		///Generates an EPS file from a graph
 		///\ingroup eps_io
 		///Generates an EPS file from a graph.
 		///\param g Reference to the graph to be printed.
 		///\param os Reference to the output stream.
 		///By default it is <tt>std::cout</tt>.
 		///
 		///This function also has a lot of
 		///\ref named-templ-func-param "named parameters",
 		///they are declared as the members of class \ref GraphToEps. The following
 		///example shows how to use these parameters.
 		///\code
 		/// graphToEps(g,os).scale(10).coords(coords)
 		///              .nodeScale(2).nodeSizes(sizes)
 		///              .arcWidthScale(.4).run();
 		///\endcode
 		///
 		///For more detailed examples see the \ref graph_to_eps_demo.cc demo file.
 		///
 		///\warning Don't forget to put the \ref GraphToEps::run() "run()"
 		///to the end of the parameter list.
 		///\sa GraphToEps
 		///\sa graphToEps(G &g, const char *file_name)
 		template<class G>
 		GraphToEps<DefaultGraphToEpsTraits<G> >
 		graphToEps(G &g, std::ostream& os=std::cout)
+		{
 		  return
 		    GraphToEps<DefaultGraphToEpsTraits<G> >(DefaultGraphToEpsTraits<G>(g,os));
+		}
 		///Generates an EPS file from a graph
 		///\ingroup eps_io
 		///This function does the same as
 		///\ref graphToEps(G &g,std::ostream& os)
 		///but it writes its output into the file \c file_name
 		///instead of a stream.
 		///\sa graphToEps(G &g, std::ostream& os)
 		template<class G>
 		GraphToEps<DefaultGraphToEpsTraits<G> >
 		graphToEps(G &g,const char *file_name)
+		{
 		  return GraphToEps<DefaultGraphToEpsTraits<G> >
 		    (DefaultGraphToEpsTraits<G>(g,*new std::ofstream(file_name),true));
+		}
 		///Generates an EPS file from a graph
 		///\ingroup eps_io
 		///This function does the same as
 		///\ref graphToEps(G &g,std::ostream& os)
 		///but it writes its output into the file \c file_name
 		///instead of a stream.
 		///\sa graphToEps(G &g, std::ostream& os)
 		template<class G>
 		GraphToEps<DefaultGraphToEpsTraits<G> >
 		graphToEps(G &g,const std::string& file_name)
+		{
 		  return GraphToEps<DefaultGraphToEpsTraits<G> >
 		    (DefaultGraphToEpsTraits<G>(g,*new std::ofstream(file_name.c_str()),true));
+		}
 		} //END OF NAMESPACE LEMON
 		#endif // LEMON_GRAPH_TO_EPS_H

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