LEMON/LEMON-official Changeset - r1078:c59bdcc8e33e

Repositories » LEMON » LEMON-official

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

Changeset - r1078:c59bdcc8e33e

« 1077:8276e0

1079:a1d8d1 »

r1078:c59bdcc8e33e

Fri, 05 Aug 2011 00:17:29

[Not Reviewed]

0 comments (0 inline)

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

Unify sources

0 24 0

r1.0.7 1.0

24 files changed:

doc/dirs.dox

doc/groups.dox

doc/lgf.dox

lemon/base.cc

lemon/bits/default_map.h

lemon/bits/map_extender.h

lemon/bits/path_dump.h

lemon/bits/windows.cc

lemon/core.h

lemon/dfs.h

lemon/graph_to_eps.h

lemon/lgf_reader.h

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

↑ Collapse diff ↑

doc/dirs.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
+		 * Copyright (C) 2003-2011
 		 * 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.
+		 *
 		 */
 		/**
 		\dir demo
 		\brief A collection of demo applications.
 		This directory contains several simple demo applications, mainly
 		for educational purposes.
 		*/
 		/**
 		\dir doc
 		\brief Auxiliary (and the whole generated) documentation.
 		This directory contains some auxiliary pages and the whole generated
 		documentation.
 		*/
 		/**
 		\dir test
 		\brief Test programs.
 		This directory contains several test programs that check the consistency
 		of the code.
 		*/
 		/**
 		\dir tools
 		\brief Some useful executables.
 		This directory contains the sources of some useful complete executables.
 		*/
 		/**
 		\dir lemon
 		\brief Base include directory of LEMON.
 		This is the base directory of LEMON includes, so each include file must be
 		prefixed with this, e.g.
 		\code
 		#include<lemon/list_graph.h>
 		#include<lemon/dijkstra.h>
 		\endcode
 		*/
 		/**
 		\dir concepts
 		\brief Concept descriptors and checking classes.
 		This directory contains the concept descriptors and concept checking tools.
 		For more information see the \ref concept "Concepts" module.
 		*/
 		/**
 		\dir bits
 		\brief Auxiliary tools for implementation.
-		This directory contains some auxiliary classes for implementing graphs,
 		This directory contains some auxiliary classes for implementing graphs,
 		maps and some other classes.
 		As a user you typically don't have to deal with these files.
 		*/

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
+		 * Copyright (C) 2003-2011
 		 * 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.
 		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 structure.
 		<b>See also:</b> \ref graph_concepts "Graph Structure Concepts".
 		*/
 		/**
 		@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 and map adaptors that e.g. combine
 		new maps from existing ones.
 		<b>See also:</b> \ref map_concepts "Map Concepts".
 		*/
 		/**
 		@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 graphToEps() 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);
 		  graphToEps(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
 		\c nodeColor() function. The \c composeMap() compose the \c 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 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 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 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 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
 		and the encapsulated postscript (EPS) format.
 		postscript (EPS) format.
 		*/
 		/**
 		@defgroup lemon_io LEMON Input-Output
 		@ingroup io_group
 		\brief Reading and writing 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.
 		*/
 		/**
 		@defgroup map_concepts Map Concepts
 		@ingroup concept
 		\brief Skeleton and concept checking classes for maps
 		This group describes the skeletons and concept checking classes of maps.
 		*/
 		/**
 		\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.
 		*/

doc/lgf.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
+		 * Copyright (C) 2003-2011
 		 * 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.
+		 *
 		 */
 		namespace lemon {
 		/*!
 		\page lgf-format LEMON Graph Format (LGF)
 		The \e LGF is a <em>column oriented</em>
 		file format for storing graphs and associated data like
 		node and edge maps.
 		Each line with \c '#' first non-whitespace
 		character is considered as a comment line.
 		Otherwise the file consists of sections starting with
 		a header line. The header lines starts with an \c '@' character followed by the
 		type of section. The standard section types are \c \@nodes, \c
 		\@arcs and \c \@edges
 		and \@attributes. Each header line may also have an optional
 		\e name, which can be use to distinguish the sections of the same
 		type.
 		The standard sections are column oriented, each line consists of
 		<em>token</em>s separated by whitespaces. A token can be \e plain or
 		\e quoted. A plain token is just a sequence of non-whitespace characters,
 		while a quoted token is a
 		character sequence surrounded by double quotes, and it can also
 		contain whitespaces and escape sequences.
 		The \c \@nodes section describes a set of nodes and associated
 		maps. The first is a header line, its columns are the names of the
 		maps appearing in the following lines.
 		One of the maps must be called \c
 		"label", which plays special role in the file.
 		The following
 		non-empty lines until the next section describes nodes of the
 		graph. Each line contains the values of the node maps
 		associated to the current node.
 		\code
 		 @nodes
 		 label  coordinates  size    title
 (10,20)      10      "First node"
 (80,80)      8       "Second node"
 (40,10)      10      "Third node"
 		\endcode
 		The \c \@arcs section is very similar to the \c \@nodes section, it
 		again starts with a header line describing the names of the maps, but
 		the \c "label" map is not obligatory here. The following lines
 		describe the arcs. The first two tokens of each line are the source
 		and the target node of the arc, respectively, then come the map
 		values. The source and target tokens must be node labels.
 		\code
 		 @arcs
 		         capacity
 2   16
 3   12
 3   18
 		\endcode
 		If there is no map in the \c \@arcs section at all, then it must be
 		indicated by a sole '-' sign in the first line.
 		\code
 		 @arcs
+		         -
 2
 3
 3
 		\endcode
 		The \c \@edges is just a synonym of \c \@arcs. The \@arcs section can
 		also store the edge set of an undirected graph. In such case there is
 		a conventional method for store arc maps in the file, if two columns
 		have the same caption with \c '+' and \c '-' prefix, then these columns
 		can be regarded as the values of an arc map.
 		The \c \@attributes section contains key-value pairs, each line
 		consists of two tokens, an attribute name, and then an attribute
 		value. The value of the attribute could be also a label value of a
 		node or an edge, or even an edge label prefixed with \c '+' or \c '-',
 		which regards to the forward or backward directed arc of the
 		corresponding edge.
 		\code
 		 @attributes
 		 source 1
 		 target 3
 		 caption "LEMON test digraph"
 		\endcode
 		The \e LGF can contain extra sections, but there is no restriction on
 		the format of such sections.
 		*/
+		}
 		//  LocalWords:  whitespace whitespaces

lemon/base.cc

Show inline comments

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

lemon/bits/default_map.h

Show inline comments

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

lemon/bits/map_extender.h

Show inline comments

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

lemon/bits/path_dump.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
+		 * Copyright (C) 2003-2011
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_BITS_PRED_MAP_PATH_H
 		#define LEMON_BITS_PRED_MAP_PATH_H
 		namespace lemon {
 		  template <typename _Digraph, typename _PredMap>
 		  class PredMapPath {
 		  public:
 		    typedef True RevPathTag;
 		    typedef _Digraph Digraph;
 		    typedef typename Digraph::Arc Arc;
 		    typedef _PredMap PredMap;
 		    PredMapPath(const Digraph& _digraph, const PredMap& _predMap,
 		                typename Digraph::Node _target)
 		      : digraph(_digraph), predMap(_predMap), target(_target) {}
 		    int length() const {
 		      int len = 0;
 		      typename Digraph::Node node = target;
 		      typename Digraph::Arc arc;
 		      while ((arc = predMap[node]) != INVALID) {
 		        node = digraph.source(arc);
 		        ++len;
+		      }
 		      return len;
+		    }
 		    bool empty() const {
 		      return predMap[target] == INVALID;
+		    }
 		    class RevArcIt {
 		    public:
 		      RevArcIt() {}
 		      RevArcIt(Invalid) : path(0), current(INVALID) {}
 		      RevArcIt(const PredMapPath& _path)
 		        : path(&_path), current(_path.target) {
 		        if (path->predMap[current] == INVALID) current = INVALID;
+		      }
 		      operator const typename Digraph::Arc() const {
 		        return path->predMap[current];
+		      }
 		      RevArcIt& operator++() {
 		        current = path->digraph.source(path->predMap[current]);
 		        if (path->predMap[current] == INVALID) current = INVALID;
 		        return *this;
+		      }
 		      bool operator==(const RevArcIt& e) const {
 		        return current == e.current;
+		      }
 		      bool operator!=(const RevArcIt& e) const {
 		        return current != e.current;
+		      }
 		      bool operator<(const RevArcIt& e) const {
 		        return current < e.current;
+		      }
 		    private:
 		      const PredMapPath* path;
 		      typename Digraph::Node current;
 		    };
 		  private:
 		    const Digraph& digraph;
 		    const PredMap& predMap;
 		    typename Digraph::Node target;
 		  };
 		  template <typename _Digraph, typename _PredMatrixMap>
 		  class PredMatrixMapPath {
 		  public:
 		    typedef True RevPathTag;
 		    typedef _Digraph Digraph;
 		    typedef typename Digraph::Arc Arc;
 		    typedef _PredMatrixMap PredMatrixMap;
 		    PredMatrixMapPath(const Digraph& _digraph,
 		                      const PredMatrixMap& _predMatrixMap,
 		                      typename Digraph::Node _source,
 		                      typename Digraph::Node _target)
 		      : digraph(_digraph), predMatrixMap(_predMatrixMap),
 		        source(_source), target(_target) {}
 		    int length() const {
 		      int len = 0;
 		      typename Digraph::Node node = target;
 		      typename Digraph::Arc arc;
 		      while ((arc = predMatrixMap(source, node)) != INVALID) {
 		        node = digraph.source(arc);
 		        ++len;
+		      }
 		      return len;
+		    }
 		    bool empty() const {
 		      return predMatrixMap(source, target) == INVALID;
+		    }
 		    class RevArcIt {
 		    public:
 		      RevArcIt() {}
 		      RevArcIt(Invalid) : path(0), current(INVALID) {}
 		      RevArcIt(const PredMatrixMapPath& _path)
 		        : path(&_path), current(_path.target) {
 		        if (path->predMatrixMap(path->source, current) == INVALID)
 		          current = INVALID;
+		      }
 		      operator const typename Digraph::Arc() const {
 		        return path->predMatrixMap(path->source, current);
+		      }
 		      RevArcIt& operator++() {
 		        current =
 		          path->digraph.source(path->predMatrixMap(path->source, current));
 		        if (path->predMatrixMap(path->source, current) == INVALID)
 		          current = INVALID;
 		        return *this;
+		      }
 		      bool operator==(const RevArcIt& e) const {
 		        return current == e.current;
+		      }
 		      bool operator!=(const RevArcIt& e) const {
 		        return current != e.current;
+		      }
 		      bool operator<(const RevArcIt& e) const {
 		        return current < e.current;
+		      }
 		    private:
 		      const PredMatrixMapPath* path;
 		      typename Digraph::Node current;
 		    };
 		  private:
 		    const Digraph& digraph;
 		    const PredMatrixMap& predMatrixMap;
 		    typename Digraph::Node source;
 		    typename Digraph::Node target;
 		  };
+		}
 		#endif

lemon/bits/windows.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-2009
+		 * Copyright (C) 2003-2011
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		///\file
 		///\brief Some basic non-inline functions and static global data.
 		#include<lemon/bits/windows.h>
 		#ifdef WIN32
 		#ifndef WIN32_LEAN_AND_MEAN
 		#define WIN32_LEAN_AND_MEAN
 		#endif
 		#ifndef NOMINMAX
 		#define NOMINMAX
 		#endif
 		#ifdef UNICODE
 		#undef UNICODE
 		#endif
 		#include <windows.h>
 		#ifdef LOCALE_INVARIANT
 		#define MY_LOCALE LOCALE_INVARIANT
 		#else
 		#define MY_LOCALE LOCALE_NEUTRAL
 		#endif
 		#else
 		#include <unistd.h>
 		#include <ctime>
 		#include <sys/times.h>
 		#include <sys/time.h>
 		#endif
 		#include <cmath>
 		#include <sstream>
 		namespace lemon {
 		  namespace bits {
 		    void getWinProcTimes(double &rtime,
 		                         double &utime, double &stime,
 		                         double &cutime, double &cstime)
+		    {
 		#ifdef WIN32
 		      static const double ch = 4294967296.0e-7;
 		      static const double cl = 1.0e-7;
 		      FILETIME system;
 		      GetSystemTimeAsFileTime(&system);
 		      rtime = ch * system.dwHighDateTime + cl * system.dwLowDateTime;
 		      FILETIME create, exit, kernel, user;
 		      if (GetProcessTimes(GetCurrentProcess(),&create, &exit, &kernel, &user)) {
 		        utime = ch * user.dwHighDateTime + cl * user.dwLowDateTime;
 		        stime = ch * kernel.dwHighDateTime + cl * kernel.dwLowDateTime;
 		        cutime = 0;
 		        cstime = 0;
 		      } else {
 		        rtime = 0;
 		        utime = 0;
 		        stime = 0;
 		        cutime = 0;
 		        cstime = 0;
+		      }
 		#else
 		      timeval tv;
 		      gettimeofday(&tv, 0);
 		      rtime=tv.tv_sec+double(tv.tv_usec)/1e6;
 		      tms ts;
 		      double tck=sysconf(_SC_CLK_TCK);
 		      times(&ts);
 		      utime=ts.tms_utime/tck;
 		      stime=ts.tms_stime/tck;
 		      cutime=ts.tms_cutime/tck;
 		      cstime=ts.tms_cstime/tck;
 		#endif
+		    }
 		    std::string getWinFormattedDate()
+		    {
 		      std::ostringstream os;
 		#ifdef WIN32
 		      SYSTEMTIME time;
 		      GetSystemTime(&time);
 		      char buf1[11], buf2[9], buf3[5];
-			  if (GetDateFormat(MY_LOCALE, 0, &time,
+		          if (GetDateFormat(MY_LOCALE, 0, &time,
 		                        ("ddd MMM dd"), buf1, 11) &&
 		          GetTimeFormat(MY_LOCALE, 0, &time,
 		                        ("HH':'mm':'ss"), buf2, 9) &&
 		          GetDateFormat(MY_LOCALE, 0, &time,
 		                        ("yyyy"), buf3, 5)) {
 		        os << buf1 << ' ' << buf2 << ' ' << buf3;
+		      }
 		      else os << "unknown";
 		#else
 		      timeval tv;
 		      gettimeofday(&tv, 0);
 		      char cbuf[26];
 		      ctime_r(&tv.tv_sec,cbuf);
 		      os << cbuf;
 		#endif
 		      return os.str();
+		    }
 		    int getWinRndSeed()
+		    {
 		#ifdef WIN32
 		      FILETIME time;
 		      GetSystemTimeAsFileTime(&time);
 		      return GetCurrentProcessId() + time.dwHighDateTime + time.dwLowDateTime;
 		#else
 		      timeval tv;
 		      gettimeofday(&tv, 0);
 		      return getpid() + tv.tv_sec + tv.tv_usec;
 		#endif
+		    }
+		  }
+		}

lemon/core.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
-		 * Copyright (C) 2003-2008
+		 * Copyright (C) 2003-2011
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_CORE_H
 		#define LEMON_CORE_H
 		#include <vector>
 		#include <algorithm>
 		#include <lemon/config.h>
 		#include <lemon/bits/enable_if.h>
 		#include <lemon/bits/traits.h>
 		#include <lemon/assert.h>
 		///\file
 		///\brief LEMON core utilities.
 		///
 		///This header file contains core utilities for LEMON.
 		///It is automatically included by all graph types, therefore it usually
 		///do not have to be included directly.
 		namespace lemon {
 		  /// \brief Dummy type to make it easier to create invalid iterators.
 		  ///
 		  /// Dummy type to make it easier to create invalid iterators.
 		  /// See \ref INVALID for the usage.
 		  struct Invalid {
 		  public:
 		    bool operator==(Invalid) { return true;  }
 		    bool operator!=(Invalid) { return false; }
 		    bool operator< (Invalid) { return false; }
 		  };
 		  /// \brief Invalid iterators.
 		  ///
 		  /// \ref Invalid is a global type that converts to each iterator
 		  /// in such a way that the value of the target iterator will be invalid.
 		#ifdef LEMON_ONLY_TEMPLATES
 		  const Invalid INVALID = Invalid();
 		#else
 		  extern const Invalid INVALID;
 		#endif
 		  /// \addtogroup gutils
 		  /// @{
 		  ///Create convenience typedefs for the digraph types and iterators
 		  ///This \c \#define creates convenient type definitions for the following
 		  ///types of \c Digraph: \c Node,  \c NodeIt, \c Arc, \c ArcIt, \c InArcIt,
 		  ///\c OutArcIt, \c BoolNodeMap, \c IntNodeMap, \c DoubleNodeMap,
 		  ///\c BoolArcMap, \c IntArcMap, \c DoubleArcMap.
 		  ///
 		  ///\note If the graph type is a dependent type, ie. the graph type depend
 		  ///on a template parameter, then use \c TEMPLATE_DIGRAPH_TYPEDEFS()
 		  ///macro.
 		#define DIGRAPH_TYPEDEFS(Digraph)                                       \
 		  typedef Digraph::Node Node;                                           \
 		  typedef Digraph::NodeIt NodeIt;                                       \
 		  typedef Digraph::Arc Arc;                                             \
 		  typedef Digraph::ArcIt ArcIt;                                         \
 		  typedef Digraph::InArcIt InArcIt;                                     \
 		  typedef Digraph::OutArcIt OutArcIt;                                   \
 		  typedef Digraph::NodeMap<bool> BoolNodeMap;                           \
 		  typedef Digraph::NodeMap<int> IntNodeMap;                             \
 		  typedef Digraph::NodeMap<double> DoubleNodeMap;                       \
 		  typedef Digraph::ArcMap<bool> BoolArcMap;                             \
 		  typedef Digraph::ArcMap<int> IntArcMap;                               \
 		  typedef Digraph::ArcMap<double> DoubleArcMap
 		  ///Create convenience typedefs for the digraph types and iterators
 		  ///\see DIGRAPH_TYPEDEFS
 		  ///
 		  ///\note Use this macro, if the graph type is a dependent type,
 		  ///ie. the graph type depend on a template parameter.
 		#define TEMPLATE_DIGRAPH_TYPEDEFS(Digraph)                              \
 		  typedef typename Digraph::Node Node;                                  \
 		  typedef typename Digraph::NodeIt NodeIt;                              \
 		  typedef typename Digraph::Arc Arc;                                    \
 		  typedef typename Digraph::ArcIt ArcIt;                                \
 		  typedef typename Digraph::InArcIt InArcIt;                            \
 		  typedef typename Digraph::OutArcIt OutArcIt;                          \
 		  typedef typename Digraph::template NodeMap<bool> BoolNodeMap;         \
 		  typedef typename Digraph::template NodeMap<int> IntNodeMap;           \
 		  typedef typename Digraph::template NodeMap<double> DoubleNodeMap;     \
 		  typedef typename Digraph::template ArcMap<bool> BoolArcMap;           \
 		  typedef typename Digraph::template ArcMap<int> IntArcMap;             \
 		  typedef typename Digraph::template ArcMap<double> DoubleArcMap
 		  ///Create convenience typedefs for the graph types and iterators
 		  ///This \c \#define creates the same convenient type definitions as defined
 		  ///by \ref DIGRAPH_TYPEDEFS(Graph) and six more, namely it creates
 		  ///\c Edge, \c EdgeIt, \c IncEdgeIt, \c BoolEdgeMap, \c IntEdgeMap,
 		  ///\c DoubleEdgeMap.
 		  ///
 		  ///\note If the graph type is a dependent type, ie. the graph type depend
 		  ///on a template parameter, then use \c TEMPLATE_GRAPH_TYPEDEFS()
 		  ///macro.
 		#define GRAPH_TYPEDEFS(Graph)                                           \
 		  DIGRAPH_TYPEDEFS(Graph);                                              \
 		  typedef Graph::Edge Edge;                                             \
 		  typedef Graph::EdgeIt EdgeIt;                                         \
 		  typedef Graph::IncEdgeIt IncEdgeIt;                                   \
 		  typedef Graph::EdgeMap<bool> BoolEdgeMap;                             \
 		  typedef Graph::EdgeMap<int> IntEdgeMap;                               \
 		  typedef Graph::EdgeMap<double> DoubleEdgeMap
 		  ///Create convenience typedefs for the graph types and iterators
 		  ///\see GRAPH_TYPEDEFS
 		  ///
 		  ///\note Use this macro, if the graph type is a dependent type,
 		  ///ie. the graph type depend on a template parameter.
 		#define TEMPLATE_GRAPH_TYPEDEFS(Graph)                                  \
 		  TEMPLATE_DIGRAPH_TYPEDEFS(Graph);                                     \
 		  typedef typename Graph::Edge Edge;                                    \
 		  typedef typename Graph::EdgeIt EdgeIt;                                \
 		  typedef typename Graph::IncEdgeIt IncEdgeIt;                          \
 		  typedef typename Graph::template EdgeMap<bool> BoolEdgeMap;           \
 		  typedef typename Graph::template EdgeMap<int> IntEdgeMap;             \
 		  typedef typename Graph::template EdgeMap<double> DoubleEdgeMap
 		  /// \brief Function to count the items in a graph.
 		  ///
 		  /// This function counts the items (nodes, arcs etc.) in a graph.
 		  /// The complexity of the function is linear because
 		  /// it iterates on all of the items.
 		  template <typename Graph, typename Item>
 		  inline int countItems(const Graph& g) {
 		    typedef typename ItemSetTraits<Graph, Item>::ItemIt ItemIt;
 		    int num = 0;
 		    for (ItemIt it(g); it != INVALID; ++it) {
 		      ++num;
+		    }
 		    return num;
+		  }
 		  // Node counting:
 		  namespace _core_bits {
 		    template <typename Graph, typename Enable = void>
 		    struct CountNodesSelector {
 		      static int count(const Graph &g) {
 		        return countItems<Graph, typename Graph::Node>(g);
+		      }
 		    };
 		    template <typename Graph>
 		    struct CountNodesSelector<
 		      Graph, typename
 		      enable_if<typename Graph::NodeNumTag, void>::type>
+		    {
 		      static int count(const Graph &g) {
 		        return g.nodeNum();
+		      }
 		    };
+		  }
 		  /// \brief Function to count the nodes in the graph.
 		  ///
 		  /// This function counts the nodes in the graph.
 		  /// The complexity of the function is <em>O</em>(<em>n</em>), but for some
 		  /// graph structures it is specialized to run in <em>O</em>(1).
 		  ///
 		  /// \note If the graph contains a \c nodeNum() member function and a
 		  /// \c NodeNumTag tag then this function calls directly the member
 		  /// function to query the cardinality of the node set.
 		  template <typename Graph>
 		  inline int countNodes(const Graph& g) {
 		    return _core_bits::CountNodesSelector<Graph>::count(g);
+		  }
 		  // Arc counting:
 		  namespace _core_bits {
 		    template <typename Graph, typename Enable = void>
 		    struct CountArcsSelector {
 		      static int count(const Graph &g) {
 		        return countItems<Graph, typename Graph::Arc>(g);
+		      }
 		    };
 		    template <typename Graph>
 		    struct CountArcsSelector<
 		      Graph,
 		      typename enable_if<typename Graph::ArcNumTag, void>::type>
+		    {
 		      static int count(const Graph &g) {
 		        return g.arcNum();
+		      }
 		    };
+		  }
 		  /// \brief Function to count the arcs in the graph.
 		  ///
 		  /// This function counts the arcs in the graph.
 		  /// The complexity of the function is <em>O</em>(<em>m</em>), but for some
 		  /// graph structures it is specialized to run in <em>O</em>(1).
 		  ///
 		  /// \note If the graph contains a \c arcNum() member function and a
 		  /// \c ArcNumTag tag then this function calls directly the member
 		  /// function to query the cardinality of the arc set.
 		  template <typename Graph>
 		  inline int countArcs(const Graph& g) {
 		    return _core_bits::CountArcsSelector<Graph>::count(g);
+		  }
 		  // Edge counting:
 		  namespace _core_bits {
 		    template <typename Graph, typename Enable = void>
 		    struct CountEdgesSelector {
 		      static int count(const Graph &g) {
 		        return countItems<Graph, typename Graph::Edge>(g);
+		      }
 		    };
 		    template <typename Graph>
 		    struct CountEdgesSelector<
 		      Graph,
 		      typename enable_if<typename Graph::EdgeNumTag, void>::type>
+		    {
 		      static int count(const Graph &g) {
 		        return g.edgeNum();
+		      }
 		    };
+		  }
 		  /// \brief Function to count the edges in the graph.
 		  ///
 		  /// This function counts the edges in the graph.
 		  /// The complexity of the function is <em>O</em>(<em>m</em>), but for some
 		  /// graph structures it is specialized to run in <em>O</em>(1).
 		  ///
 		  /// \note If the graph contains a \c edgeNum() member function and a
 		  /// \c EdgeNumTag tag then this function calls directly the member
 		  /// function to query the cardinality of the edge set.
 		  template <typename Graph>
 		  inline int countEdges(const Graph& g) {
 		    return _core_bits::CountEdgesSelector<Graph>::count(g);
+		  }
 		  template <typename Graph, typename DegIt>
 		  inline int countNodeDegree(const Graph& _g, const typename Graph::Node& _n) {
 		    int num = 0;
 		    for (DegIt it(_g, _n); it != INVALID; ++it) {
 		      ++num;
+		    }
 		    return num;
+		  }
 		  /// \brief Function to count the number of the out-arcs from node \c n.
 		  ///
 		  /// This function counts the number of the out-arcs from node \c n
 		  /// in the graph \c g.
 		  template <typename Graph>
 		  inline int countOutArcs(const Graph& g,  const typename Graph::Node& n) {
 		    return countNodeDegree<Graph, typename Graph::OutArcIt>(g, n);
+		  }
 		  /// \brief Function to count the number of the in-arcs to node \c n.
 		  ///
 		  /// This function counts the number of the in-arcs to node \c n
 		  /// in the graph \c g.
 		  template <typename Graph>
 		  inline int countInArcs(const Graph& g,  const typename Graph::Node& n) {
 		    return countNodeDegree<Graph, typename Graph::InArcIt>(g, n);
+		  }
 		  /// \brief Function to count the number of the inc-edges to node \c n.
 		  ///
 		  /// This function counts the number of the inc-edges to node \c n
 		  /// in the undirected graph \c g.
 		  template <typename Graph>
 		  inline int countIncEdges(const Graph& g,  const typename Graph::Node& n) {
 		    return countNodeDegree<Graph, typename Graph::IncEdgeIt>(g, n);
+		  }
 		  namespace _core_bits {
 		    template <typename Digraph, typename Item, typename RefMap>
 		    class MapCopyBase {
 		    public:
 		      virtual void copy(const Digraph& from, const RefMap& refMap) = 0;
 		      virtual ~MapCopyBase() {}
 		    };
 		    template <typename Digraph, typename Item, typename RefMap,
 		              typename FromMap, typename ToMap>
 		    class MapCopy : public MapCopyBase<Digraph, Item, RefMap> {
 		    public:
 		      MapCopy(const FromMap& map, ToMap& tmap)
 		        : _map(map), _tmap(tmap) {}
 		      virtual void copy(const Digraph& digraph, const RefMap& refMap) {
 		        typedef typename ItemSetTraits<Digraph, Item>::ItemIt ItemIt;
 		        for (ItemIt it(digraph); it != INVALID; ++it) {
 		          _tmap.set(refMap[it], _map[it]);
+		        }
+		      }
 		    private:
 		      const FromMap& _map;
 		      ToMap& _tmap;
 		    };
 		    template <typename Digraph, typename Item, typename RefMap, typename It>
 		    class ItemCopy : public MapCopyBase<Digraph, Item, RefMap> {
 		    public:
 		      ItemCopy(const Item& item, It& it) : _item(item), _it(it) {}
 		      virtual void copy(const Digraph&, const RefMap& refMap) {
 		        _it = refMap[_item];
+		      }
 		    private:
 		      Item _item;
 		      It& _it;
 		    };
 		    template <typename Digraph, typename Item, typename RefMap, typename Ref>
 		    class RefCopy : public MapCopyBase<Digraph, Item, RefMap> {
 		    public:
 		      RefCopy(Ref& map) : _map(map) {}
 		      virtual void copy(const Digraph& digraph, const RefMap& refMap) {
 		        typedef typename ItemSetTraits<Digraph, Item>::ItemIt ItemIt;
 		        for (ItemIt it(digraph); it != INVALID; ++it) {
 		          _map.set(it, refMap[it]);
+		        }
+		      }
 		    private:
 		      Ref& _map;
 		    };
 		    template <typename Digraph, typename Item, typename RefMap,
 		              typename CrossRef>
 		    class CrossRefCopy : public MapCopyBase<Digraph, Item, RefMap> {
 		    public:
 		      CrossRefCopy(CrossRef& cmap) : _cmap(cmap) {}
 		      virtual void copy(const Digraph& digraph, const RefMap& refMap) {
 		        typedef typename ItemSetTraits<Digraph, Item>::ItemIt ItemIt;
 		        for (ItemIt it(digraph); it != INVALID; ++it) {
 		          _cmap.set(refMap[it], it);
+		        }
+		      }
 		    private:
 		      CrossRef& _cmap;
 		    };
 		    template <typename Digraph, typename Enable = void>
 		    struct DigraphCopySelector {
 		      template <typename From, typename NodeRefMap, typename ArcRefMap>
 		      static void copy(const From& from, Digraph &to,
 		                       NodeRefMap& nodeRefMap, ArcRefMap& arcRefMap) {
 		        to.clear();
 		        for (typename From::NodeIt it(from); it != INVALID; ++it) {
 		          nodeRefMap[it] = to.addNode();
+		        }
 		        for (typename From::ArcIt it(from); it != INVALID; ++it) {
 		          arcRefMap[it] = to.addArc(nodeRefMap[from.source(it)],
 		                                    nodeRefMap[from.target(it)]);
+		        }
+		      }
 		    };
 		    template <typename Digraph>
 		    struct DigraphCopySelector<
 		      Digraph,
 		      typename enable_if<typename Digraph::BuildTag, void>::type>
+		    {
 		      template <typename From, typename NodeRefMap, typename ArcRefMap>
 		      static void copy(const From& from, Digraph &to,
 		                       NodeRefMap& nodeRefMap, ArcRefMap& arcRefMap) {
 		        to.build(from, nodeRefMap, arcRefMap);
+		      }
 		    };
 		    template <typename Graph, typename Enable = void>
 		    struct GraphCopySelector {
 		      template <typename From, typename NodeRefMap, typename EdgeRefMap>
 		      static void copy(const From& from, Graph &to,
 		                       NodeRefMap& nodeRefMap, EdgeRefMap& edgeRefMap) {
 		        to.clear();
 		        for (typename From::NodeIt it(from); it != INVALID; ++it) {
 		          nodeRefMap[it] = to.addNode();
+		        }
 		        for (typename From::EdgeIt it(from); it != INVALID; ++it) {
 		          edgeRefMap[it] = to.addEdge(nodeRefMap[from.u(it)],
 		                                      nodeRefMap[from.v(it)]);
+		        }
+		      }
 		    };
 		    template <typename Graph>
 		    struct GraphCopySelector<
 		      Graph,
 		      typename enable_if<typename Graph::BuildTag, void>::type>
+		    {
 		      template <typename From, typename NodeRefMap, typename EdgeRefMap>
 		      static void copy(const From& from, Graph &to,
 		                       NodeRefMap& nodeRefMap, EdgeRefMap& edgeRefMap) {
 		        to.build(from, nodeRefMap, edgeRefMap);
+		      }
 		    };
+		  }
 		  /// \brief Class to copy a digraph.
 		  ///
 		  /// Class to copy a digraph to another digraph (duplicate a digraph). The
 		  /// simplest way of using it is through the \c digraphCopy() function.
 		  ///
 		  /// This class not only make a copy of a digraph, but it can create
 		  /// references and cross references between the nodes and arcs of
 		  /// the two digraphs, and it can copy maps to use with the newly created
 		  /// digraph.
 		  ///
 		  /// To make a copy from a digraph, first an instance of DigraphCopy
 		  /// should be created, then the data belongs to the digraph should
 		  /// assigned to copy. In the end, the \c run() member should be
 		  /// called.
 		  ///
 		  /// The next code copies a digraph with several data:
 		  ///\code
 		  ///  DigraphCopy<OrigGraph, NewGraph> cg(orig_graph, new_graph);
 		  ///  // Create references for the nodes
 		  ///  OrigGraph::NodeMap<NewGraph::Node> nr(orig_graph);
 		  ///  cg.nodeRef(nr);
 		  ///  // Create cross references (inverse) for the arcs
 		  ///  NewGraph::ArcMap<OrigGraph::Arc> acr(new_graph);
 		  ///  cg.arcCrossRef(acr);
 		  ///  // Copy an arc map
 		  ///  OrigGraph::ArcMap<double> oamap(orig_graph);
 		  ///  NewGraph::ArcMap<double> namap(new_graph);
 		  ///  cg.arcMap(oamap, namap);
 		  ///  // Copy a node
 		  ///  OrigGraph::Node on;
 		  ///  NewGraph::Node nn;
 		  ///  cg.node(on, nn);
 		  ///  // Execute copying
 		  ///  cg.run();
 		  ///\endcode
 		  template <typename From, typename To>
 		  class DigraphCopy {
 		  private:
 		    typedef typename From::Node Node;
 		    typedef typename From::NodeIt NodeIt;
 		    typedef typename From::Arc Arc;
 		    typedef typename From::ArcIt ArcIt;
 		    typedef typename To::Node TNode;
 		    typedef typename To::Arc TArc;
 		    typedef typename From::template NodeMap<TNode> NodeRefMap;
 		    typedef typename From::template ArcMap<TArc> ArcRefMap;
 		  public:
 		    /// \brief Constructor of DigraphCopy.
 		    ///
 		    /// Constructor of DigraphCopy for copying the content of the
 		    /// \c from digraph into the \c to digraph.
 		    DigraphCopy(const From& from, To& to)
 		      : _from(from), _to(to) {}
 		    /// \brief Destructor of DigraphCopy
 		    ///
 		    /// Destructor of DigraphCopy.
 		    ~DigraphCopy() {
 		      for (int i = 0; i < int(_node_maps.size()); ++i) {
 		        delete _node_maps[i];
+		      }
 		      for (int i = 0; i < int(_arc_maps.size()); ++i) {
 		        delete _arc_maps[i];
+		      }
+		    }
 		    /// \brief Copy the node references into the given map.
 		    ///
 		    /// This function copies the node references into the given map.
 		    /// The parameter should be a map, whose key type is the Node type of
 		    /// the source digraph, while the value type is the Node type of the
 		    /// destination digraph.
 		    template <typename NodeRef>
 		    DigraphCopy& nodeRef(NodeRef& map) {
 		      _node_maps.push_back(new _core_bits::RefCopy<From, Node,
 		                           NodeRefMap, NodeRef>(map));
 		      return *this;
+		    }
 		    /// \brief Copy the node cross references into the given map.
 		    ///
 		    /// This function copies the node cross references (reverse references)
 		    /// into the given map. The parameter should be a map, whose key type
 		    /// is the Node type of the destination digraph, while the value type is
 		    /// the Node type of the source digraph.
 		    template <typename NodeCrossRef>
 		    DigraphCopy& nodeCrossRef(NodeCrossRef& map) {
 		      _node_maps.push_back(new _core_bits::CrossRefCopy<From, Node,
 		                           NodeRefMap, NodeCrossRef>(map));
 		      return *this;
+		    }
 		    /// \brief Make a copy of the given node map.
 		    ///
 		    /// This function makes a copy of the given node map for the newly
 		    /// created digraph.
 		    /// The key type of the new map \c tmap should be the Node type of the
 		    /// destination digraph, and the key type of the original map \c map
 		    /// should be the Node type of the source digraph.
 		    template <typename FromMap, typename ToMap>
 		    DigraphCopy& nodeMap(const FromMap& map, ToMap& tmap) {
 		      _node_maps.push_back(new _core_bits::MapCopy<From, Node,
 		                           NodeRefMap, FromMap, ToMap>(map, tmap));
 		      return *this;
+		    }
 		    /// \brief Make a copy of the given node.
 		    ///
 		    /// This function makes a copy of the given node.
 		    DigraphCopy& node(const Node& node, TNode& tnode) {
 		      _node_maps.push_back(new _core_bits::ItemCopy<From, Node,
 		                           NodeRefMap, TNode>(node, tnode));
 		      return *this;
+		    }
 		    /// \brief Copy the arc references into the given map.
 		    ///
 		    /// This function copies the arc references into the given map.
 		    /// The parameter should be a map, whose key type is the Arc type of
 		    /// the source digraph, while the value type is the Arc type of the
 		    /// destination digraph.
 		    template <typename ArcRef>
 		    DigraphCopy& arcRef(ArcRef& map) {
 		      _arc_maps.push_back(new _core_bits::RefCopy<From, Arc,
 		                          ArcRefMap, ArcRef>(map));
 		      return *this;
+		    }
 		    /// \brief Copy the arc cross references into the given map.
 		    ///
 		    /// This function copies the arc cross references (reverse references)
 		    /// into the given map. The parameter should be a map, whose key type
 		    /// is the Arc type of the destination digraph, while the value type is
 		    /// the Arc type of the source digraph.
 		    template <typename ArcCrossRef>
 		    DigraphCopy& arcCrossRef(ArcCrossRef& map) {
 		      _arc_maps.push_back(new _core_bits::CrossRefCopy<From, Arc,
 		                          ArcRefMap, ArcCrossRef>(map));
 		      return *this;
+		    }
 		    /// \brief Make a copy of the given arc map.
 		    ///
 		    /// This function makes a copy of the given arc map for the newly
 		    /// created digraph.
 		    /// The key type of the new map \c tmap should be the Arc type of the
 		    /// destination digraph, and the key type of the original map \c map
 		    /// should be the Arc type of the source digraph.
 		    template <typename FromMap, typename ToMap>
 		    DigraphCopy& arcMap(const FromMap& map, ToMap& tmap) {
 		      _arc_maps.push_back(new _core_bits::MapCopy<From, Arc,
 		                          ArcRefMap, FromMap, ToMap>(map, tmap));
 		      return *this;
+		    }
 		    /// \brief Make a copy of the given arc.
 		    ///
 		    /// This function makes a copy of the given arc.
 		    DigraphCopy& arc(const Arc& arc, TArc& tarc) {
 		      _arc_maps.push_back(new _core_bits::ItemCopy<From, Arc,
 		                          ArcRefMap, TArc>(arc, tarc));
 		      return *this;
+		    }
 		    /// \brief Execute copying.
 		    ///
 		    /// This function executes the copying of the digraph along with the
 		    /// copying of the assigned data.
 		    void run() {
 		      NodeRefMap nodeRefMap(_from);
 		      ArcRefMap arcRefMap(_from);
 		      _core_bits::DigraphCopySelector<To>::
 		        copy(_from, _to, nodeRefMap, arcRefMap);
 		      for (int i = 0; i < int(_node_maps.size()); ++i) {
 		        _node_maps[i]->copy(_from, nodeRefMap);
+		      }
 		      for (int i = 0; i < int(_arc_maps.size()); ++i) {
 		        _arc_maps[i]->copy(_from, arcRefMap);
+		      }
+		    }
 		  protected:
 		    const From& _from;
 		    To& _to;
 		    std::vector<_core_bits::MapCopyBase<From, Node, NodeRefMap>* >
 		      _node_maps;
 		    std::vector<_core_bits::MapCopyBase<From, Arc, ArcRefMap>* >
 		      _arc_maps;
 		  };
 		  /// \brief Copy a digraph to another digraph.
 		  ///
 		  /// This function copies a digraph to another digraph.
 		  /// The complete usage of it is detailed in the DigraphCopy class, but
 		  /// a short example shows a basic work:
 		  ///\code
 		  /// digraphCopy(src, trg).nodeRef(nr).arcCrossRef(acr).run();
 		  ///\endcode
 		  ///
 		  /// After the copy the \c nr map will contain the mapping from the
 		  /// nodes of the \c from digraph to the nodes of the \c to digraph and
 		  /// \c acr will contain the mapping from the arcs of the \c to digraph
 		  /// to the arcs of the \c from digraph.
 		  ///
 		  /// \see DigraphCopy
 		  template <typename From, typename To>
 		  DigraphCopy<From, To> digraphCopy(const From& from, To& to) {
 		    return DigraphCopy<From, To>(from, to);
+		  }
 		  /// \brief Class to copy a graph.
 		  ///
 		  /// Class to copy a graph to another graph (duplicate a graph). The
 		  /// simplest way of using it is through the \c graphCopy() function.
 		  ///
 		  /// This class not only make a copy of a graph, but it can create
 		  /// references and cross references between the nodes, edges and arcs of
 		  /// the two graphs, and it can copy maps for using with the newly created
 		  /// graph.
 		  ///
 		  /// To make a copy from a graph, first an instance of GraphCopy
 		  /// should be created, then the data belongs to the graph should
 		  /// assigned to copy. In the end, the \c run() member should be
 		  /// called.
 		  ///
 		  /// The next code copies a graph with several data:
 		  ///\code
 		  ///  GraphCopy<OrigGraph, NewGraph> cg(orig_graph, new_graph);
 		  ///  // Create references for the nodes
 		  ///  OrigGraph::NodeMap<NewGraph::Node> nr(orig_graph);
 		  ///  cg.nodeRef(nr);
 		  ///  // Create cross references (inverse) for the edges
 		  ///  NewGraph::EdgeMap<OrigGraph::Edge> ecr(new_graph);
 		  ///  cg.edgeCrossRef(ecr);
 		  ///  // Copy an edge map
 		  ///  OrigGraph::EdgeMap<double> oemap(orig_graph);
 		  ///  NewGraph::EdgeMap<double> nemap(new_graph);
 		  ///  cg.edgeMap(oemap, nemap);
 		  ///  // Copy a node
 		  ///  OrigGraph::Node on;
 		  ///  NewGraph::Node nn;
 		  ///  cg.node(on, nn);
 		  ///  // Execute copying
 		  ///  cg.run();
 		  ///\endcode
 		  template <typename From, typename To>
 		  class GraphCopy {
 		  private:
 		    typedef typename From::Node Node;
 		    typedef typename From::NodeIt NodeIt;
 		    typedef typename From::Arc Arc;
 		    typedef typename From::ArcIt ArcIt;
 		    typedef typename From::Edge Edge;
 		    typedef typename From::EdgeIt EdgeIt;
 		    typedef typename To::Node TNode;
 		    typedef typename To::Arc TArc;
 		    typedef typename To::Edge TEdge;
 		    typedef typename From::template NodeMap<TNode> NodeRefMap;
 		    typedef typename From::template EdgeMap<TEdge> EdgeRefMap;
 		    struct ArcRefMap {
 		      ArcRefMap(const From& from, const To& to,
 		                const EdgeRefMap& edge_ref, const NodeRefMap& node_ref)
 		        : _from(from), _to(to),
 		          _edge_ref(edge_ref), _node_ref(node_ref) {}
 		      typedef typename From::Arc Key;
 		      typedef typename To::Arc Value;
 		      Value operator[](const Key& key) const {
 		        bool forward = _from.u(key) != _from.v(key) ?
 		          _node_ref[_from.source(key)] ==
 		          _to.source(_to.direct(_edge_ref[key], true)) :
 		          _from.direction(key);
 		        return _to.direct(_edge_ref[key], forward);
+		      }
 		      const From& _from;
 		      const To& _to;
 		      const EdgeRefMap& _edge_ref;
 		      const NodeRefMap& _node_ref;
 		    };
 		  public:
 		    /// \brief Constructor of GraphCopy.
 		    ///
 		    /// Constructor of GraphCopy for copying the content of the
 		    /// \c from graph into the \c to graph.
 		    GraphCopy(const From& from, To& to)
 		      : _from(from), _to(to) {}
 		    /// \brief Destructor of GraphCopy
 		    ///
 		    /// Destructor of GraphCopy.
 		    ~GraphCopy() {
 		      for (int i = 0; i < int(_node_maps.size()); ++i) {
 		        delete _node_maps[i];
+		      }
 		      for (int i = 0; i < int(_arc_maps.size()); ++i) {
 		        delete _arc_maps[i];
+		      }
 		      for (int i = 0; i < int(_edge_maps.size()); ++i) {
 		        delete _edge_maps[i];
+		      }
+		    }
 		    /// \brief Copy the node references into the given map.
 		    ///
 		    /// This function copies the node references into the given map.
 		    /// The parameter should be a map, whose key type is the Node type of
 		    /// the source graph, while the value type is the Node type of the
 		    /// destination graph.
 		    template <typename NodeRef>
 		    GraphCopy& nodeRef(NodeRef& map) {
 		      _node_maps.push_back(new _core_bits::RefCopy<From, Node,
 		                           NodeRefMap, NodeRef>(map));
 		      return *this;
+		    }
 		    /// \brief Copy the node cross references into the given map.
 		    ///
 		    /// This function copies the node cross references (reverse references)
 		    /// into the given map. The parameter should be a map, whose key type
 		    /// is the Node type of the destination graph, while the value type is
 		    /// the Node type of the source graph.
 		    template <typename NodeCrossRef>
 		    GraphCopy& nodeCrossRef(NodeCrossRef& map) {
 		      _node_maps.push_back(new _core_bits::CrossRefCopy<From, Node,
 		                           NodeRefMap, NodeCrossRef>(map));
 		      return *this;
+		    }
 		    /// \brief Make a copy of the given node map.
 		    ///
 		    /// This function makes a copy of the given node map for the newly
 		    /// created graph.
 		    /// The key type of the new map \c tmap should be the Node type of the
 		    /// destination graph, and the key type of the original map \c map
 		    /// should be the Node type of the source graph.
 		    template <typename FromMap, typename ToMap>
 		    GraphCopy& nodeMap(const FromMap& map, ToMap& tmap) {
 		      _node_maps.push_back(new _core_bits::MapCopy<From, Node,
 		                           NodeRefMap, FromMap, ToMap>(map, tmap));
 		      return *this;
+		    }
 		    /// \brief Make a copy of the given node.
 		    ///
 		    /// This function makes a copy of the given node.
 		    GraphCopy& node(const Node& node, TNode& tnode) {
 		      _node_maps.push_back(new _core_bits::ItemCopy<From, Node,
 		                           NodeRefMap, TNode>(node, tnode));
 		      return *this;
+		    }
 		    /// \brief Copy the arc references into the given map.
 		    ///
 		    /// This function copies the arc references into the given map.
 		    /// The parameter should be a map, whose key type is the Arc type of
 		    /// the source graph, while the value type is the Arc type of the
 		    /// destination graph.
 		    template <typename ArcRef>
 		    GraphCopy& arcRef(ArcRef& map) {
 		      _arc_maps.push_back(new _core_bits::RefCopy<From, Arc,
 		                          ArcRefMap, ArcRef>(map));
 		      return *this;
+		    }
 		    /// \brief Copy the arc cross references into the given map.
 		    ///
 		    /// This function copies the arc cross references (reverse references)
 		    /// into the given map. The parameter should be a map, whose key type
 		    /// is the Arc type of the destination graph, while the value type is
 		    /// the Arc type of the source graph.
 		    template <typename ArcCrossRef>
 		    GraphCopy& arcCrossRef(ArcCrossRef& map) {
 		      _arc_maps.push_back(new _core_bits::CrossRefCopy<From, Arc,
 		                          ArcRefMap, ArcCrossRef>(map));
 		      return *this;
+		    }
 		    /// \brief Make a copy of the given arc map.
 		    ///
 		    /// This function makes a copy of the given arc map for the newly
 		    /// created graph.
 		    /// The key type of the new map \c tmap should be the Arc type of the
 		    /// destination graph, and the key type of the original map \c map
 		    /// should be the Arc type of the source graph.
 		    template <typename FromMap, typename ToMap>
 		    GraphCopy& arcMap(const FromMap& map, ToMap& tmap) {
 		      _arc_maps.push_back(new _core_bits::MapCopy<From, Arc,
 		                          ArcRefMap, FromMap, ToMap>(map, tmap));
 		      return *this;
+		    }
 		    /// \brief Make a copy of the given arc.
 		    ///
 		    /// This function makes a copy of the given arc.
 		    GraphCopy& arc(const Arc& arc, TArc& tarc) {
 		      _arc_maps.push_back(new _core_bits::ItemCopy<From, Arc,
 		                          ArcRefMap, TArc>(arc, tarc));
 		      return *this;
+		    }
 		    /// \brief Copy the edge references into the given map.
 		    ///
 		    /// This function copies the edge references into the given map.
 		    /// The parameter should be a map, whose key type is the Edge type of
 		    /// the source graph, while the value type is the Edge type of the
 		    /// destination graph.
 		    template <typename EdgeRef>
 		    GraphCopy& edgeRef(EdgeRef& map) {
 		      _edge_maps.push_back(new _core_bits::RefCopy<From, Edge,
 		                           EdgeRefMap, EdgeRef>(map));
 		      return *this;
+		    }
 		    /// \brief Copy the edge cross references into the given map.
 		    ///
 		    /// This function copies the edge cross references (reverse references)
 		    /// into the given map. The parameter should be a map, whose key type
 		    /// is the Edge type of the destination graph, while the value type is
 		    /// the Edge type of the source graph.
 		    template <typename EdgeCrossRef>
 		    GraphCopy& edgeCrossRef(EdgeCrossRef& map) {
 		      _edge_maps.push_back(new _core_bits::CrossRefCopy<From,
 		                           Edge, EdgeRefMap, EdgeCrossRef>(map));
 		      return *this;
+		    }
 		    /// \brief Make a copy of the given edge map.
 		    ///
 		    /// This function makes a copy of the given edge map for the newly
 		    /// created graph.
 		    /// The key type of the new map \c tmap should be the Edge type of the
 		    /// destination graph, and the key type of the original map \c map
 		    /// should be the Edge type of the source graph.
 		    template <typename FromMap, typename ToMap>
 		    GraphCopy& edgeMap(const FromMap& map, ToMap& tmap) {
 		      _edge_maps.push_back(new _core_bits::MapCopy<From, Edge,
 		                           EdgeRefMap, FromMap, ToMap>(map, tmap));
 		      return *this;
+		    }
 		    /// \brief Make a copy of the given edge.
 		    ///
 		    /// This function makes a copy of the given edge.
 		    GraphCopy& edge(const Edge& edge, TEdge& tedge) {
 		      _edge_maps.push_back(new _core_bits::ItemCopy<From, Edge,
 		                           EdgeRefMap, TEdge>(edge, tedge));
 		      return *this;
+		    }
 		    /// \brief Execute copying.
 		    ///
 		    /// This function executes the copying of the graph along with the
 		    /// copying of the assigned data.
 		    void run() {
 		      NodeRefMap nodeRefMap(_from);
 		      EdgeRefMap edgeRefMap(_from);
 		      ArcRefMap arcRefMap(_from, _to, edgeRefMap, nodeRefMap);
 		      _core_bits::GraphCopySelector<To>::
 		        copy(_from, _to, nodeRefMap, edgeRefMap);
 		      for (int i = 0; i < int(_node_maps.size()); ++i) {
 		        _node_maps[i]->copy(_from, nodeRefMap);
+		      }
 		      for (int i = 0; i < int(_edge_maps.size()); ++i) {
 		        _edge_maps[i]->copy(_from, edgeRefMap);
+		      }
 		      for (int i = 0; i < int(_arc_maps.size()); ++i) {
 		        _arc_maps[i]->copy(_from, arcRefMap);
+		      }
+		    }
 		  private:
 		    const From& _from;
 		    To& _to;
 		    std::vector<_core_bits::MapCopyBase<From, Node, NodeRefMap>* >
 		      _node_maps;
 		    std::vector<_core_bits::MapCopyBase<From, Arc, ArcRefMap>* >
 		      _arc_maps;
 		    std::vector<_core_bits::MapCopyBase<From, Edge, EdgeRefMap>* >
 		      _edge_maps;
 		  };
 		  /// \brief Copy a graph to another graph.
 		  ///
 		  /// This function copies a graph to another graph.
 		  /// The complete usage of it is detailed in the GraphCopy class,
 		  /// but a short example shows a basic work:
 		  ///\code
 		  /// graphCopy(src, trg).nodeRef(nr).edgeCrossRef(ecr).run();
 		  ///\endcode
 		  ///
 		  /// After the copy the \c nr map will contain the mapping from the
 		  /// nodes of the \c from graph to the nodes of the \c to graph and
 		  /// \c ecr will contain the mapping from the edges of the \c to graph
 		  /// to the edges of the \c from graph.
 		  ///
 		  /// \see GraphCopy
 		  template <typename From, typename To>
 		  GraphCopy<From, To>
 		  graphCopy(const From& from, To& to) {
 		    return GraphCopy<From, To>(from, to);
+		  }
 		  namespace _core_bits {
 		    template <typename Graph, typename Enable = void>
 		    struct FindArcSelector {
 		      typedef typename Graph::Node Node;
 		      typedef typename Graph::Arc Arc;
 		      static Arc find(const Graph &g, Node u, Node v, Arc e) {
 		        if (e == INVALID) {
 		          g.firstOut(e, u);
 		        } else {
 		          g.nextOut(e);
+		        }
 		        while (e != INVALID && g.target(e) != v) {
 		          g.nextOut(e);
+		        }
 		        return e;
+		      }
 		    };
 		    template <typename Graph>
 		    struct FindArcSelector<
 		      Graph,
 		      typename enable_if<typename Graph::FindArcTag, void>::type>
+		    {
 		      typedef typename Graph::Node Node;
 		      typedef typename Graph::Arc Arc;
 		      static Arc find(const Graph &g, Node u, Node v, Arc prev) {
 		        return g.findArc(u, v, prev);
+		      }
 		    };
+		  }
 		  /// \brief Find an arc between two nodes of a digraph.
 		  ///
 		  /// This function finds an arc from node \c u to node \c v in the
 		  /// digraph \c g.
 		  ///
 		  /// If \c prev is \ref INVALID (this is the default value), then
 		  /// it finds the first arc from \c u to \c v. Otherwise it looks for
 		  /// the next arc from \c u to \c v after \c prev.
 		  /// \return The found arc or \ref INVALID if there is no such an arc.
 		  ///
 		  /// Thus you can iterate through each arc from \c u to \c v as it follows.
 		  ///\code
 		  /// for(Arc e = findArc(g,u,v); e != INVALID; e = findArc(g,u,v,e)) {
 		  ///   ...
 		  /// }
 		  ///\endcode
 		  ///
 		  /// \note \ref ConArcIt provides iterator interface for the same
 		  /// functionality.
 		  ///
 		  ///\sa ConArcIt
 		  ///\sa ArcLookUp, AllArcLookUp, DynArcLookUp
 		  template <typename Graph>
 		  inline typename Graph::Arc
 		  findArc(const Graph &g, typename Graph::Node u, typename Graph::Node v,
 		          typename Graph::Arc prev = INVALID) {
 		    return _core_bits::FindArcSelector<Graph>::find(g, u, v, prev);
+		  }
 		  /// \brief Iterator for iterating on parallel arcs connecting the same nodes.
 		  ///
 		  /// Iterator for iterating on parallel arcs connecting the same nodes. It is
 		  /// a higher level interface for the \ref findArc() function. You can

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
+		 * Copyright (C) 2003-2011
 		 * 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/bits/path_dump.h>
 		#include <lemon/core.h>
 		#include <lemon/error.h>
 		#include <lemon/maps.h>
 		#include <lemon/path.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 type of the digraph the algorithm runs on.
 		    typedef GR Digraph;
 		    ///\brief The type of the map that stores the predecessor
 		    ///arcs of the %DFS paths.
 		    ///
 		    ///The type of the map that stores the predecessor
 		    ///arcs of the %DFS paths.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
 		    ///Instantiates a PredMap.
 		    ///This function instantiates a PredMap.
 		    ///\param g is the digraph, to which we would like to define the
 		    ///PredMap.
 		    static PredMap *createPredMap(const Digraph &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.
 		    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
 		    ///Instantiates a ProcessedMap.
 		    ///This function instantiates a ProcessedMap.
 		    ///\param g is the digraph, to which
 		    ///we would like to define the ProcessedMap
 		#ifdef DOXYGEN
 		    static ProcessedMap *createProcessedMap(const Digraph &g)
 		#else
 		    static ProcessedMap *createProcessedMap(const Digraph &)
 		#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::ReadWriteMap "ReadWriteMap" concept.
 		    typedef typename Digraph::template NodeMap<bool> ReachedMap;
 		    ///Instantiates a ReachedMap.
 		    ///This function instantiates a ReachedMap.
 		    ///\param g is the digraph, to which
 		    ///we would like to define the ReachedMap.
 		    static ReachedMap *createReachedMap(const Digraph &g)
+		    {
 		      return new ReachedMap(g);
+		    }
 		    ///The type of the map that stores the distances of the nodes.
 		    ///The type of the map that stores the distances 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 DistMap.
 		    ///\param g is the digraph, to which we would like to define the
 		    ///DistMap.
 		    static DistMap *createDistMap(const Digraph &g)
+		    {
 		      return new DistMap(g);
+		    }
 		  };
 		  ///%DFS algorithm class.
 		  ///\ingroup search
 		  ///This class provides an efficient implementation of the %DFS algorithm.
 		  ///
 		  ///There is also a \ref dfs() "function-type interface" for the DFS
 		  ///algorithm, which is convenient in the simplier cases and it can be
 		  ///used easier.
 		  ///
 		  ///\tparam GR The type of the digraph the algorithm runs on.
 		  ///The default value is \ref ListDigraph. The value of GR is not used
 		  ///directly by \ref 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:
 		    ///The type of the digraph the algorithm runs on.
 		    typedef typename TR::Digraph Digraph;
 		    ///\brief The type of the map that stores the predecessor 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;
 		    ///The type of the map that indicates which nodes are reached.
 		    typedef typename TR::ReachedMap ReachedMap;
 		    ///The type of the map that indicates which nodes are processed.
 		    typedef typename TR::ProcessedMap ProcessedMap;
 		    ///The type of the paths.
 		    typedef PredMapPath<Digraph, PredMap> Path;
 		    ///The traits class.
 		    typedef TR Traits;
 		  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 predecessor arcs.
 		    PredMap *_pred;
 		    //Indicates if _pred is locally allocated (true) or not.
 		    bool local_pred;
 		    //Pointer to the map of distances.
 		    DistMap *_dist;
 		    //Indicates if _dist is locally allocated (true) or not.
 		    bool local_dist;
 		    //Pointer to the map of reached status of the nodes.
 		    ReachedMap *_reached;
 		    //Indicates if _reached is locally allocated (true) or not.
 		    bool local_reached;
 		    //Pointer to the map of processed status of the nodes.
 		    ProcessedMap *_processed;
 		    //Indicates if _processed is locally allocated (true) or not.
 		    bool local_processed;
 		    std::vector<typename Digraph::OutArcIt> _stack;
 		    int _stack_head;
 		    //Creates the maps if necessary.
 		    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 SetPredMapTraits : public Traits {
 		      typedef T PredMap;
 		      static PredMap *createPredMap(const Digraph &)
+		      {
 		        LEMON_ASSERT(false, "PredMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\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 SetPredMap : public Dfs<Digraph, SetPredMapTraits<T> > {
 		      typedef Dfs<Digraph, SetPredMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct SetDistMapTraits : public Traits {
 		      typedef T DistMap;
 		      static DistMap *createDistMap(const Digraph &)
+		      {
 		        LEMON_ASSERT(false, "DistMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\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 SetDistMap : public Dfs< Digraph, SetDistMapTraits<T> > {
 		      typedef Dfs<Digraph, SetDistMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct SetReachedMapTraits : public Traits {
 		      typedef T ReachedMap;
 		      static ReachedMap *createReachedMap(const Digraph &)
+		      {
 		        LEMON_ASSERT(false, "ReachedMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\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 SetReachedMap : public Dfs< Digraph, SetReachedMapTraits<T> > {
 		      typedef Dfs< Digraph, SetReachedMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct SetProcessedMapTraits : public Traits {
 		      typedef T ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &)
+		      {
 		        LEMON_ASSERT(false, "ProcessedMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\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 SetProcessedMap : public Dfs< Digraph, SetProcessedMapTraits<T> > {
 		      typedef Dfs< Digraph, SetProcessedMapTraits<T> > Create;
 		    };
 		    struct SetStandardProcessedMapTraits : 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
 		    ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
 		    ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
 		    ///If you don't set it explicitly, it will be automatically allocated.
 		    struct SetStandardProcessedMap :
 		      public Dfs< Digraph, SetStandardProcessedMapTraits > {
 		      typedef Dfs< Digraph, SetStandardProcessedMapTraits > Create;
 		    };
 		    ///@}
 		  public:
 		    ///Constructor.
 		    ///Constructor.
 		    ///\param g The digraph the algorithm runs 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 that stores the predecessor arcs.
 		    ///Sets the map that stores 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>
 		    Dfs &predMap(PredMap &m)
+		    {
 		      if(local_pred) {
 		        delete _pred;
 		        local_pred=false;
+		      }
 		      _pred = &m;
 		      return *this;
+		    }
 		    ///Sets the map that indicates which nodes are reached.
 		    ///Sets the map that indicates which nodes are reached.
 		    ///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>
 		    Dfs &reachedMap(ReachedMap &m)
+		    {
 		      if(local_reached) {
 		        delete _reached;
 		        local_reached=false;
+		      }
 		      _reached = &m;
 		      return *this;
+		    }
 		    ///Sets the map that indicates which nodes are processed.
 		    ///Sets the map that indicates which nodes are processed.
 		    ///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>
 		    Dfs &processedMap(ProcessedMap &m)
+		    {
 		      if(local_processed) {
 		        delete _processed;
 		        local_processed=false;
+		      }
 		      _processed = &m;
 		      return *this;
+		    }
 		    ///Sets the map that stores the distances of the nodes.
 		    ///Sets the map that stores the distances of the nodes 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>
 		    Dfs &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 \ref lemon::Dfs::run() "run()".
 		    ///\n
 		    ///If you need more control on the execution, first you must call
 		    ///\ref lemon::Dfs::init() "init()", then you can add a source node
 		    ///with \ref lemon::Dfs::addSource() "addSource()".
 		    ///Finally \ref lemon::Dfs::start() "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);
 		        _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.
 		    ///
 		    ///\pre The stack must be empty. (Otherwise the algorithm gives
 		    ///false results.)
 		    ///
 		    ///\warning Distances will be wrong (or at least strange) in case of
 		    ///multiple sources.
 		    void addSource(Node s)
+		    {
 		      LEMON_DEBUG(emptyQueue(), "The stack is not empty.");
 		      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 \c INVALID if the stack
 		    ///is empty.
 		    OutArcIt nextArc() const
+		    {
 		      return _stack_head>=0?_stack[_stack_head]:INVALID;
+		    }
 		    ///\brief Returns \c false if there are nodes
 		    ///to be processed.
 		    ///
 		    ///Returns \c false if there are nodes
 		    ///to be processed in the queue (stack).
 		    bool emptyQueue() const { 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 (stack).
 		    int queueSize() const { return _stack_head+1; }
 		    ///Executes the algorithm.
 		    ///Executes the algorithm.
 		    ///
 		    ///This method runs the %DFS algorithm from the root node
 		    ///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.
 		    ///
 		    ///\pre init() must be called and a root node should be
 		    ///added with addSource() before using this function.
 		    ///
 		    ///\note <tt>d.start()</tt> is just a shortcut of the following code.
 		    ///\code
 		    ///  while ( !d.emptyQueue() ) {
 		    ///    d.processNextArc();
 		    ///  }
 		    ///\endcode
 		    void start()
+		    {
 		      while ( !emptyQueue() ) processNextArc();
+		    }
 		    ///Executes the algorithm until the given target node is reached.
 		    ///Executes the algorithm until the given target node is reached.
 		    ///
 		    ///This method runs the %DFS algorithm from the root node
 		    ///in order to compute the DFS path to \c t.
 		    ///
 		    ///The algorithm computes
 		    ///- the %DFS path to \c t,
 		    ///- the distance of \c t from the root in the %DFS tree.
 		    ///
 		    ///\pre init() must be called and a root node should be
 		    ///added with addSource() before using this function.
 		    void start(Node t)
+		    {
 		      while ( !emptyQueue() && !(*_reached)[t] )
 		        processNextArc();
+		    }
 		    ///Executes the algorithm until a condition is met.
 		    ///Executes the algorithm until a condition is met.
 		    ///
 		    ///This method runs the %DFS algorithm from the root node
 		    ///until an arc \c a with <tt>am[a]</tt> true is found.
 		    ///
 		    ///\param am A \c bool (or convertible) arc map. The algorithm
 		    ///will stop when it reaches an arc \c a with <tt>am[a]</tt> true.
 		    ///
 		    ///\return The reached arc \c a with <tt>am[a]</tt> true or
 		    ///\c INVALID if no such arc was found.
 		    ///
 		    ///\pre init() must be called and a root node should be
 		    ///added with addSource() before using this function.
 		    ///
 		    ///\warning Contrary to \ref Bfs and \ref Dijkstra, \c am is an arc map,
 		    ///not a node map.
 		    template<class ArcBoolMap>
 		    Arc start(const ArcBoolMap &am)
+		    {
 		      while ( !emptyQueue() && !am[_stack[_stack_head]] )
 		        processNextArc();
 		      return emptyQueue() ? INVALID : _stack[_stack_head];
+		    }
 		    ///Runs the algorithm from the given source node.
 		    ///This method runs the %DFS algorithm from 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 <tt>d.run(s)</tt> 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.
 		    ///This method runs the %DFS algorithm from node \c s
 		    ///in order to compute the DFS path to node \c t
 		    ///(it stops searching when \c t is processed)
 		    ///
 		    ///\return \c true if \c t is reachable form \c s.
 		    ///
 		    ///\note Apart from the return value, <tt>d.run(s,t)</tt> is
 		    ///just a shortcut of the following code.
 		    ///\code
 		    ///  d.init();
 		    ///  d.addSource(s);
 		    ///  d.start(t);
 		    ///\endcode
 		    bool run(Node s,Node t) {
 		      init();
 		      addSource(s);
 		      start(t);
 		      return reached(t);
+		    }
 		    ///Runs the 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 <tt>d.run()</tt> is just a shortcut of the following code.
 		    ///\code
 		    ///  d.init();
 		    ///  for (NodeIt n(digraph); n != INVALID; ++n) {
 		    ///    if (!d.reached(n)) {
 		    ///      d.addSource(n);
 		    ///      d.start();
 		    ///    }
 		    ///  }
 		    ///\endcode
 		    void run() {
 		      init();
 		      for (NodeIt it(*G); 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
 		    ///Either \ref lemon::Dfs::run() "run()" or \ref lemon::Dfs::start()
 		    ///"start()" must be called before using them.
 		    ///@{
 		    ///The DFS path to a node.
 		    ///Returns the DFS path to a node.
 		    ///
 		    ///\warning \c t should be reachable from the root.
 		    ///
 		    ///\pre Either \ref run() or \ref start() must be called before
 		    ///using this function.
 		    Path path(Node t) const { return Path(*G, *_pred, t); }
 		    ///The distance of a node from the root.
 		    ///Returns the distance of a node from the root.
 		    ///
 		    ///\warning If node \c v is not reachable from the root, then
 		    ///the return value of this function is undefined.
 		    ///
 		    ///\pre Either \ref run() or \ref start() must be called before
 		    ///using this function.
 		    int dist(Node v) const { return (*_dist)[v]; }
 		    ///Returns the 'previous arc' of the %DFS tree for a node.
 		    ///This function returns the 'previous arc' of the %DFS tree for the
 		    ///node \c v, i.e. it returns the last arc of a %DFS path from the
 		    ///root to \c v. It is \c INVALID
 		    ///if \c v is not reachable from the root(s) or if \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.
 		    ///This function returns the 'previous node' of the %DFS
 		    ///tree for the node \c v, i.e. it returns the last but one node
 		    ///from a %DFS path from the root to \c v. It is \c INVALID
 		    ///if \c v is not reachable from the root(s) or if \c v is 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]); }
 		    ///\brief Returns a const reference to the node map that stores the
 		    ///distances of the nodes.
 		    ///
 		    ///Returns a const reference to the node map that stores the
 		    ///distances of the nodes calculated by the algorithm.
 		    ///
 		    ///\pre Either \ref run() or \ref init()
 		    ///must be called before using this function.
 		    const DistMap &distMap() const { return *_dist;}
 		    ///\brief Returns a const reference to the node map that stores the
 		    ///predecessor arcs.
 		    ///
 		    ///Returns a const reference to the node map that stores the predecessor
 		    ///arcs, which form 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(s).
 		    ///Returns \c true if \c v is reachable from the root(s).
 		    ///\pre Either \ref run() or \ref start()
 		    ///must be called before using this function.
 		    bool reached(Node v) const { 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 type of the digraph the algorithm runs on.
 		    typedef GR Digraph;
 		    ///\brief The type of the map that stores the predecessor
 		    ///arcs of the %DFS paths.
 		    ///
 		    ///The type of the map that stores the predecessor
 		    ///arcs of the %DFS paths.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
 		    ///Instantiates a PredMap.
 		    ///This function instantiates a PredMap.
 		    ///\param g is the digraph, to which we would like to define the
 		    ///PredMap.
 		    static PredMap *createPredMap(const Digraph &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.
 		    ///By default it is a NullMap.
 		    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
 		    ///Instantiates a ProcessedMap.
 		    ///This function instantiates a ProcessedMap.
 		    ///\param g is the digraph, to which
 		    ///we would like to define the ProcessedMap.
 		#ifdef DOXYGEN
 		    static ProcessedMap *createProcessedMap(const Digraph &g)
 		#else
 		    static ProcessedMap *createProcessedMap(const Digraph &)
 		#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::ReadWriteMap "ReadWriteMap" concept.
 		    typedef typename Digraph::template NodeMap<bool> ReachedMap;
 		    ///Instantiates a ReachedMap.
 		    ///This function instantiates a ReachedMap.
 		    ///\param g is the digraph, to which
 		    ///we would like to define the ReachedMap.
 		    static ReachedMap *createReachedMap(const Digraph &g)
+		    {
 		      return new ReachedMap(g);
+		    }
 		    ///The type of the map that stores the distances of the nodes.
 		    ///The type of the map that stores the distances 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 DistMap.
 		    ///\param g is the digraph, to which we would like to define
 		    ///the DistMap
 		    static DistMap *createDistMap(const Digraph &g)
+		    {
 		      return new DistMap(g);
+		    }
 		    ///The type of the DFS paths.
 		    ///The type of the DFS paths.
 		    ///It must meet the \ref concepts::Path "Path" concept.
 		    typedef lemon::Path<Digraph> Path;
 		  };
 		  /// Default traits class used by 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:
 		    //The type of the nodes in the digraph.
 		    typedef typename Base::Digraph::Node Node;
 		    //Pointer to the digraph the algorithm runs on.
 		    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 DFS path to the target node.
 		    void *_path;
 		    //Pointer to the distance of the target node.
 		    int *_di;
 		    public:
 		    /// Constructor.
 		    /// This constructor does not require parameters, therefore it initiates
 		    /// all of the attributes to \c 0.
 		    DfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0),
 		                      _dist(0), _path(0), _di(0) {}
 		    /// Constructor.
 		    /// This constructor requires one parameter,
 		    /// others are initiated to \c 0.
 		    /// \param g The digraph the algorithm runs on.
 		    DfsWizardBase(const GR &g) :
 		      _g(reinterpret_cast<void*>(const_cast<GR*>(&g))),
 		      _reached(0), _processed(0), _pred(0), _dist(0),  _path(0), _di(0) {}
 		  };
 		  /// Auxiliary class for the function-type interface of DFS algorithm.
 		  /// This auxiliary class is created to implement the
 		  /// \ref dfs() "function-type interface" of \ref Dfs algorithm.
 		  /// It does not have own \ref run() method, it uses the functions
 		  /// and features of the plain \ref Dfs.
 		  ///
 		  /// This class should only be used through the \ref dfs() function,
 		  /// which makes it easier to use the algorithm.
 		  template<class TR>
 		  class DfsWizard : public TR
+		  {
 		    typedef TR Base;
 		    ///The type of the digraph the algorithm runs on.
 		    typedef typename TR::Digraph Digraph;
 		    typedef typename Digraph::Node Node;
 		    typedef typename Digraph::NodeIt NodeIt;
 		    typedef typename Digraph::Arc Arc;
 		    typedef typename Digraph::OutArcIt OutArcIt;
 		    ///\brief The type of the map that stores the predecessor
 		    ///arcs of the DFS paths.
 		    typedef typename TR::PredMap PredMap;
 		    ///\brief The type of the map that stores the distances of the nodes.
 		    typedef typename TR::DistMap DistMap;
 		    ///\brief The type of the map that indicates which nodes are reached.
 		    typedef typename TR::ReachedMap ReachedMap;
 		    ///\brief The type of the map that indicates which nodes are processed.
 		    typedef typename TR::ProcessedMap ProcessedMap;
 		    ///The type of the DFS paths
 		    typedef typename TR::Path Path;
 		  public:
 		    /// Constructor.
 		    DfsWizard() : TR() {}
 		    /// Constructor that requires parameters.
 		    /// Constructor that requires parameters.
 		    /// These parameters will be the default values for the traits class.
 		    /// \param g The digraph the algorithm runs on.
 		    DfsWizard(const Digraph &g) :
 		      TR(g) {}
 		    ///Copy constructor
 		    DfsWizard(const TR &b) : TR(b) {}
 		    ~DfsWizard() {}
 		    ///Runs DFS algorithm from the given source node.
 		    ///This method runs DFS algorithm from node \c s
 		    ///in order to compute the DFS path to each node.
 		    void run(Node s)
+		    {
 		      Dfs<Digraph,TR> alg(*reinterpret_cast<const Digraph*>(Base::_g));
 		      if (Base::_pred)
 		        alg.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
 		      if (Base::_dist)
 		        alg.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
 		      if (Base::_reached)
 		        alg.reachedMap(*reinterpret_cast<ReachedMap*>(Base::_reached));
 		      if (Base::_processed)
 		        alg.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));
 		      if (s!=INVALID)
 		        alg.run(s);
 		      else
 		        alg.run();
+		    }
 		    ///Finds the DFS path between \c s and \c t.
 		    ///This method runs DFS algorithm from node \c s
 		    ///in order to compute the DFS path to node \c t
 		    ///(it stops searching when \c t is processed).
 		    ///
 		    ///\return \c true if \c t is reachable form \c s.
 		    bool run(Node s, Node t)
+		    {
 		      Dfs<Digraph,TR> alg(*reinterpret_cast<const Digraph*>(Base::_g));
 		      if (Base::_pred)
 		        alg.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
 		      if (Base::_dist)
 		        alg.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
 		      if (Base::_reached)
 		        alg.reachedMap(*reinterpret_cast<ReachedMap*>(Base::_reached));
 		      if (Base::_processed)
 		        alg.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));
 		      alg.run(s,t);
 		      if (Base::_path)
 		        *reinterpret_cast<Path*>(Base::_path) = alg.path(t);
 		      if (Base::_di)
 		        *Base::_di = alg.dist(t);
 		      return alg.reached(t);
+		      }
 		    ///Runs DFS algorithm to visit all nodes in the digraph.
 		    ///This method runs DFS algorithm in order to compute
 		    ///the DFS path to each node.
 		    void run()
+		    {
 		      run(INVALID);
+		    }
 		    template<class T>
 		    struct SetPredMapBase : public Base {
 		      typedef T PredMap;
 		      static PredMap *createPredMap(const Digraph &) { return 0; };
 		      SetPredMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-func-param "Named parameter"
 		    ///for setting PredMap object.
 		    ///
 		    ///\ref named-func-param "Named parameter"
 		    ///for setting PredMap object.
 		    template<class T>
 		    DfsWizard<SetPredMapBase<T> > predMap(const T &t)
+		    {
 		      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
 		      return DfsWizard<SetPredMapBase<T> >(*this);
+		    }
 		    template<class T>
 		    struct SetReachedMapBase : public Base {
 		      typedef T ReachedMap;
 		      static ReachedMap *createReachedMap(const Digraph &) { return 0; };
 		      SetReachedMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-func-param "Named parameter"
 		    ///for setting ReachedMap object.
 		    ///
 		    /// \ref named-func-param "Named parameter"
 		    ///for setting ReachedMap object.
 		    template<class T>
 		    DfsWizard<SetReachedMapBase<T> > reachedMap(const T &t)
+		    {
 		      Base::_reached=reinterpret_cast<void*>(const_cast<T*>(&t));
 		      return DfsWizard<SetReachedMapBase<T> >(*this);

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
+		 * Copyright (C) 2003-2011
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_GRAPH_TO_EPS_H
 		#define LEMON_GRAPH_TO_EPS_H
 		#include<iostream>
 		#include<fstream>
 		#include<sstream>
 		#include<algorithm>
 		#include<vector>
 		#ifndef WIN32
 		#include<sys/time.h>
 		#include<ctime>
 		#else
 		#include<lemon/bits/windows.h>
 		#endif
 		#include<lemon/math.h>
 		#include<lemon/core.h>
 		#include<lemon/dim2.h>
 		#include<lemon/maps.h>
 		#include<lemon/color.h>
 		#include<lemon/bits/bezier.h>
 		#include<lemon/error.h>
 		///\ingroup eps_io
 		///\file
 		///\brief A well configurable tool for visualizing graphs
 		namespace lemon {
 		  namespace _graph_to_eps_bits {
 		    template<class MT>
 		    class _NegY {
 		    public:
 		      typedef typename MT::Key Key;
 		      typedef typename MT::Value Value;
 		      const MT &map;
 		      int yscale;
 		      _NegY(const MT &m,bool b) : map(m), yscale(1-b*2) {}
 		      Value operator[](Key n) { return Value(map[n].x,map[n].y*yscale);}
 		    };
+		  }
 		///Default traits class of GraphToEps
 		///Default traits class of \ref GraphToEps.
 		///
 		///\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 _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() {
 		    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";
+		    {
 		      os << "%%CreationDate: ";
 		#ifndef WIN32
 		      timeval tv;
 		      gettimeofday(&tv, 0);
 		      char cbuf[26];
 		      ctime_r(&tv.tv_sec,cbuf);
 		      os << cbuf;
 		#else
 		      os << bits::getWinFormattedDate();
 		      os << 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);
 		      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);
 		      if(max_s>EPSILON) {
 		        _nodeScale/=max_s;
+		      }
+		    }
 		    double diag_len = 1;
 		    if(!(_absoluteNodeSizes&&_absoluteArcWidths)) {
 		      dim2::Box<double> bb;
 		      for(NodeIt n(g);n!=INVALID;++n) bb.add(mycoords[n]);
 		      if (bb.empty()) {
 		        bb = dim2::Box<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::Box<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::Box<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";
 		    //x y r
 		    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"
 		       << "  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"
 		       << "  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"
 		       << "       /w exch def /len exch def\n"
 		      //<< "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 {
 		        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());
 		          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.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;
 		//                 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) {

lemon/lgf_reader.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-2011
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		///\ingroup lemon_io
 		///\file
 		///\brief \ref lgf-format "LEMON Graph Format" reader.
 		#ifndef LEMON_LGF_READER_H
 		#define LEMON_LGF_READER_H
 		#include <iostream>
 		#include <fstream>
 		#include <sstream>
 		#include <set>
 		#include <map>
 		#include <lemon/core.h>
 		#include <lemon/lgf_writer.h>
 		#include <lemon/concept_check.h>
 		#include <lemon/concepts/maps.h>
 		namespace lemon {
 		  namespace _reader_bits {
 		    template <typename Value>
 		    struct DefaultConverter {
 		      Value operator()(const std::string& str) {
 		        std::istringstream is(str);
 		        Value value;
 		        if (!(is >> value)) {
 		          throw FormatError("Cannot read token");
+		        }
 		        char c;
 		        if (is >> std::ws >> c) {
 		          throw FormatError("Remaining characters in token");
+		        }
 		        return value;
+		      }
 		    };
 		    template <>
 		    struct DefaultConverter<std::string> {
 		      std::string operator()(const std::string& str) {
 		        return str;
+		      }
 		    };
 		    template <typename _Item>
 		    class MapStorageBase {
 		    public:
 		      typedef _Item Item;
 		    public:
 		      MapStorageBase() {}
 		      virtual ~MapStorageBase() {}
 		      virtual void set(const Item& item, const std::string& value) = 0;
 		    };
 		    template <typename _Item, typename _Map,
 		              typename _Converter = DefaultConverter<typename _Map::Value> >
 		    class MapStorage : public MapStorageBase<_Item> {
 		    public:
 		      typedef _Map Map;
 		      typedef _Converter Converter;
 		      typedef _Item Item;
 		    private:
 		      Map& _map;
 		      Converter _converter;
 		    public:
 		      MapStorage(Map& map, const Converter& converter = Converter())
 		        : _map(map), _converter(converter) {}
 		      virtual ~MapStorage() {}
 		      virtual void set(const Item& item ,const std::string& value) {
 		        _map.set(item, _converter(value));
+		      }
 		    };
 		    template <typename _Graph, bool _dir, typename _Map,
 		              typename _Converter = DefaultConverter<typename _Map::Value> >
 		    class GraphArcMapStorage : public MapStorageBase<typename _Graph::Edge> {
 		    public:
 		      typedef _Map Map;
 		      typedef _Converter Converter;
 		      typedef _Graph Graph;
 		      typedef typename Graph::Edge Item;
 		      static const bool dir = _dir;
 		    private:
 		      const Graph& _graph;
 		      Map& _map;
 		      Converter _converter;
 		    public:
 		      GraphArcMapStorage(const Graph& graph, Map& map,
 		                         const Converter& converter = Converter())
 		        : _graph(graph), _map(map), _converter(converter) {}
 		      virtual ~GraphArcMapStorage() {}
 		      virtual void set(const Item& item ,const std::string& value) {
 		        _map.set(_graph.direct(item, dir), _converter(value));
+		      }
 		    };
 		    class ValueStorageBase {
 		    public:
 		      ValueStorageBase() {}
 		      virtual ~ValueStorageBase() {}
 		      virtual void set(const std::string&) = 0;
 		    };
 		    template <typename _Value, typename _Converter = DefaultConverter<_Value> >
 		    class ValueStorage : public ValueStorageBase {
 		    public:
 		      typedef _Value Value;
 		      typedef _Converter Converter;
 		    private:
 		      Value& _value;
 		      Converter _converter;
 		    public:
 		      ValueStorage(Value& value, const Converter& converter = Converter())
 		        : _value(value), _converter(converter) {}
 		      virtual void set(const std::string& value) {
 		        _value = _converter(value);
+		      }
 		    };
 		    template <typename Value>
 		    struct MapLookUpConverter {
 		      const std::map<std::string, Value>& _map;
 		      MapLookUpConverter(const std::map<std::string, Value>& map)
 		        : _map(map) {}
 		      Value operator()(const std::string& str) {
 		        typename std::map<std::string, Value>::const_iterator it =
 		          _map.find(str);
 		        if (it == _map.end()) {
 		          std::ostringstream msg;
 		          msg << "Item not found: " << str;
 		          throw FormatError(msg.str());
+		        }
 		        return it->second;
+		      }
 		    };
 		    template <typename Graph>
 		    struct GraphArcLookUpConverter {
 		      const Graph& _graph;
 		      const std::map<std::string, typename Graph::Edge>& _map;
 		      GraphArcLookUpConverter(const Graph& graph,
 		                              const std::map<std::string,
 		                                             typename Graph::Edge>& map)
 		        : _graph(graph), _map(map) {}
 		      typename Graph::Arc operator()(const std::string& str) {
 		        if (str.empty() || (str[0] != '+' && str[0] != '-')) {
 		          throw FormatError("Item must start with '+' or '-'");
+		        }
 		        typename std::map<std::string, typename Graph::Edge>
 		          ::const_iterator it = _map.find(str.substr(1));
 		        if (it == _map.end()) {
 		          throw FormatError("Item not found");
+		        }
 		        return _graph.direct(it->second, str[0] == '+');
+		      }
 		    };
 		    inline bool isWhiteSpace(char c) {
 		      return c == ' ' || c == '\t' || c == '\v' ||
 		        c == '\n' || c == '\r' || c == '\f';
+		    }
 		    inline bool isOct(char c) {
 		      return '0' <= c && c <='7';
+		    }
 		    inline int valueOct(char c) {
 		      LEMON_ASSERT(isOct(c), "The character is not octal.");
 		      return c - '0';
+		    }
 		    inline bool isHex(char c) {
 		      return ('0' <= c && c <= '9') ||
 		        ('a' <= c && c <= 'z') ||
 		        ('A' <= c && c <= 'Z');
+		    }
 		    inline int valueHex(char c) {
 		      LEMON_ASSERT(isHex(c), "The character is not hexadecimal.");
 		      if ('0' <= c && c <= '9') return c - '0';
 		      if ('a' <= c && c <= 'z') return c - 'a' + 10;
 		      return c - 'A' + 10;
+		    }
 		    inline bool isIdentifierFirstChar(char c) {
 		      return ('a' <= c && c <= 'z') ||
 		        ('A' <= c && c <= 'Z') || c == '_';
+		    }
 		    inline bool isIdentifierChar(char c) {
 		      return isIdentifierFirstChar(c) ||
 		        ('0' <= c && c <= '9');
+		    }
 		    inline char readEscape(std::istream& is) {
 		      char c;
 		      if (!is.get(c))
 		        throw FormatError("Escape format error");
 		      switch (c) {
 		      case '\\':
 		        return '\\';
 		      case '\"':
 		        return '\"';
 		      case '\'':
 		        return '\'';
 		      case '\?':
 		        return '\?';
 		      case 'a':
 		        return '\a';
 		      case 'b':
 		        return '\b';
 		      case 'f':
 		        return '\f';
 		      case 'n':
 		        return '\n';
 		      case 'r':
 		        return '\r';
 		      case 't':
 		        return '\t';
 		      case 'v':
 		        return '\v';
 		      case 'x':
+		        {
 		          int code;
 		          if (!is.get(c) || !isHex(c))
 		            throw FormatError("Escape format error");
 		          else if (code = valueHex(c), !is.get(c) || !isHex(c)) is.putback(c);
 		          else code = code * 16 + valueHex(c);
 		          return code;
+		        }
 		      default:
+		        {
 		          int code;
 		          if (!isOct(c))
 		            throw FormatError("Escape format error");
 		          else if (code = valueOct(c), !is.get(c) || !isOct(c))
 		            is.putback(c);
 		          else if (code = code * 8 + valueOct(c), !is.get(c) || !isOct(c))
 		            is.putback(c);
 		          else code = code * 8 + valueOct(c);
 		          return code;
+		        }
+		      }
+		    }
 		    inline std::istream& readToken(std::istream& is, std::string& str) {
 		      std::ostringstream os;
 		      char c;
 		      is >> std::ws;
 		      if (!is.get(c))
 		        return is;
 		      if (c == '\"') {
 		        while (is.get(c) && c != '\"') {
 		          if (c == '\\')
 		            c = readEscape(is);
 		          os << c;
+		        }
 		        if (!is)
 		          throw FormatError("Quoted format error");
 		      } else {
 		        is.putback(c);
 		        while (is.get(c) && !isWhiteSpace(c)) {
 		          if (c == '\\')
 		            c = readEscape(is);
 		          os << c;
+		        }
 		        if (!is) {
 		          is.clear();
 		        } else {
 		          is.putback(c);
+		        }
+		      }
 		      str = os.str();
 		      return is;
+		    }
 		    class Section {
 		    public:
 		      virtual ~Section() {}
 		      virtual void process(std::istream& is, int& line_num) = 0;
 		    };
 		    template <typename Functor>
 		    class LineSection : public Section {
 		    private:
 		      Functor _functor;
 		    public:
 		      LineSection(const Functor& functor) : _functor(functor) {}
 		      virtual ~LineSection() {}
 		      virtual void process(std::istream& is, int& line_num) {
 		        char c;
 		        std::string line;
 		        while (is.get(c) && c != '@') {
 		          if (c == '\n') {
 		            ++line_num;
 		          } else if (c == '#') {
 		            getline(is, line);
 		            ++line_num;
 		          } else if (!isWhiteSpace(c)) {
 		            is.putback(c);
 		            getline(is, line);
 		            _functor(line);
 		            ++line_num;
+		          }
+		        }
 		        if (is) is.putback(c);
 		        else if (is.eof()) is.clear();
+		      }
 		    };
 		    template <typename Functor>
 		    class StreamSection : public Section {
 		    private:
 		      Functor _functor;
 		    public:
 		      StreamSection(const Functor& functor) : _functor(functor) {}
 		      virtual ~StreamSection() {}
 		      virtual void process(std::istream& is, int& line_num) {
 		        _functor(is, line_num);
 		        char c;
 		        std::string line;
 		        while (is.get(c) && c != '@') {
 		          if (c == '\n') {
 		            ++line_num;
 		          } else if (!isWhiteSpace(c)) {
 		            getline(is, line);
 		            ++line_num;
+		          }
+		        }
 		        if (is) is.putback(c);
 		        else if (is.eof()) is.clear();
+		      }
 		    };
+		  }
 		  template <typename Digraph>
 		  class DigraphReader;
 		  template <typename Digraph>
-		  DigraphReader<Digraph> digraphReader(Digraph& digraph,
 		  DigraphReader<Digraph> digraphReader(Digraph& digraph,
 		                                       std::istream& is = std::cin);
 		  template <typename Digraph>
 		  DigraphReader<Digraph> digraphReader(Digraph& digraph, const std::string& fn);
 		  template <typename Digraph>
 		  DigraphReader<Digraph> digraphReader(Digraph& digraph, const char *fn);
 		  /// \ingroup lemon_io
 		  ///
 		  /// \brief \ref lgf-format "LGF" reader for directed graphs
 		  ///
 		  /// This utility reads an \ref lgf-format "LGF" file.
 		  ///
 		  /// The reading method does a batch processing. The user creates a
 		  /// reader object, then various reading rules can be added to the
 		  /// reader, and eventually the reading is executed with the \c run()
 		  /// member function. A map reading rule can be added to the reader
 		  /// with the \c nodeMap() or \c arcMap() members. An optional
 		  /// converter parameter can also be added as a standard functor
 		  /// converting from \c std::string to the value type of the map. If it
 		  /// is set, it will determine how the tokens in the file should be
 		  /// converted to the value type of the map. If the functor is not set,
 		  /// then a default conversion will be used. One map can be read into
 		  /// multiple map objects at the same time. The \c attribute(), \c
 		  /// node() and \c arc() functions are used to add attribute reading
 		  /// rules.
 		  ///
 		  ///\code
 		  /// DigraphReader<Digraph>(digraph, std::cin).
 		  ///   nodeMap("coordinates", coord_map).
 		  ///   arcMap("capacity", cap_map).
 		  ///   node("source", src).
 		  ///   node("target", trg).
 		  ///   attribute("caption", caption).
 		  ///   run();
 		  ///\endcode
 		  ///
 		  /// By default the reader uses the first section in the file of the
 		  /// proper type. If a section has an optional name, then it can be
 		  /// selected for reading by giving an optional name parameter to the
 		  /// \c nodes(), \c arcs() or \c attributes() functions.
 		  ///
 		  /// The \c useNodes() and \c useArcs() functions are used to tell the reader
 		  /// that the nodes or arcs should not be constructed (added to the
 		  /// graph) during the reading, but instead the label map of the items
 		  /// are given as a parameter of these functions. An
 		  /// application of these functions is multipass reading, which is
 		  /// important if two \c \@arcs sections must be read from the
 		  /// file. In this case the first phase would read the node set and one
 		  /// of the arc sets, while the second phase would read the second arc
 		  /// set into an \e ArcSet class (\c SmartArcSet or \c ListArcSet).
 		  /// The previously read label node map should be passed to the \c
 		  /// useNodes() functions. Another application of multipass reading when
 		  /// paths are given as a node map or an arc map.
 		  /// It is impossible to read this in
 		  /// a single pass, because the arcs are not constructed when the node
 		  /// maps are read.
 		  template <typename _Digraph>
 		  class DigraphReader {
 		  public:
 		    typedef _Digraph Digraph;
 		    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
 		  private:
 		    std::istream* _is;
 		    bool local_is;
 		    std::string _filename;
 		    Digraph& _digraph;
 		    std::string _nodes_caption;
 		    std::string _arcs_caption;
 		    std::string _attributes_caption;
 		    typedef std::map<std::string, Node> NodeIndex;
 		    NodeIndex _node_index;
 		    typedef std::map<std::string, Arc> ArcIndex;
 		    ArcIndex _arc_index;
 		    typedef std::vector<std::pair<std::string,
 		      _reader_bits::MapStorageBase<Node>*> > NodeMaps;
 		    NodeMaps _node_maps;
 		    typedef std::vector<std::pair<std::string,
 		      _reader_bits::MapStorageBase<Arc>*> >ArcMaps;
 		    ArcMaps _arc_maps;
 		    typedef std::multimap<std::string, _reader_bits::ValueStorageBase*>
 		      Attributes;
 		    Attributes _attributes;
 		    bool _use_nodes;
 		    bool _use_arcs;
 		    bool _skip_nodes;
 		    bool _skip_arcs;
 		    int line_num;
 		    std::istringstream line;
 		  public:
 		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph reader, which reads from the given
 		    /// input stream.
 		    DigraphReader(Digraph& digraph, std::istream& is = std::cin)
 		      : _is(&is), local_is(false), _digraph(digraph),
 		        _use_nodes(false), _use_arcs(false),
 		        _skip_nodes(false), _skip_arcs(false) {}
 		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph reader, which reads from the given
 		    /// file.
 		    DigraphReader(Digraph& digraph, const std::string& fn)
 		      : _is(new std::ifstream(fn.c_str())), local_is(true),
 		        _filename(fn), _digraph(digraph),
 		        _use_nodes(false), _use_arcs(false),
 		        _skip_nodes(false), _skip_arcs(false) {
 		      if (!(*_is)) {
 		        delete _is;
 		        throw IoError("Cannot open file", fn);
+		      }
+		    }
 		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph reader, which reads from the given
 		    /// file.
 		    DigraphReader(Digraph& digraph, const char* fn)
 		      : _is(new std::ifstream(fn)), local_is(true),
 		        _filename(fn), _digraph(digraph),
 		        _use_nodes(false), _use_arcs(false),
 		        _skip_nodes(false), _skip_arcs(false) {
 		      if (!(*_is)) {
 		        delete _is;
 		        throw IoError("Cannot open file", fn);
+		      }
+		    }
 		    /// \brief Destructor
 		    ~DigraphReader() {
 		      for (typename NodeMaps::iterator it = _node_maps.begin();
 		           it != _node_maps.end(); ++it) {
 		        delete it->second;
+		      }
 		      for (typename ArcMaps::iterator it = _arc_maps.begin();
 		           it != _arc_maps.end(); ++it) {
 		        delete it->second;
+		      }
 		      for (typename Attributes::iterator it = _attributes.begin();
 		           it != _attributes.end(); ++it) {
 		        delete it->second;
+		      }
 		      if (local_is) {
 		        delete _is;
+		      }
+		    }
 		  private:
 		    template <typename DGR>
 		    friend DigraphReader<DGR> digraphReader(DGR& digraph, std::istream& is);
 		    template <typename DGR>
-		    friend DigraphReader<DGR> digraphReader(DGR& digraph,
 		    friend DigraphReader<DGR> digraphReader(DGR& digraph,
 		                                            const std::string& fn);
 		    template <typename DGR>
 		    friend DigraphReader<DGR> digraphReader(DGR& digraph, const char *fn);
 		    DigraphReader(DigraphReader& other)
 		      : _is(other._is), local_is(other.local_is), _digraph(other._digraph),
 		        _use_nodes(other._use_nodes), _use_arcs(other._use_arcs),
 		        _skip_nodes(other._skip_nodes), _skip_arcs(other._skip_arcs) {
 		      other._is = 0;
 		      other.local_is = false;
 		      _node_index.swap(other._node_index);
 		      _arc_index.swap(other._arc_index);
 		      _node_maps.swap(other._node_maps);
 		      _arc_maps.swap(other._arc_maps);
 		      _attributes.swap(other._attributes);
 		      _nodes_caption = other._nodes_caption;
 		      _arcs_caption = other._arcs_caption;
 		      _attributes_caption = other._attributes_caption;
+		    }
 		    DigraphReader& operator=(const DigraphReader&);
 		  public:
 		    /// \name Reading rules
 		    /// @{
 		    /// \brief Node map reading rule
 		    ///
 		    /// Add a node map reading rule to the reader.
 		    template <typename Map>
 		    DigraphReader& nodeMap(const std::string& caption, Map& map) {
 		      checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
 		      _reader_bits::MapStorageBase<Node>* storage =
 		        new _reader_bits::MapStorage<Node, Map>(map);
 		      _node_maps.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Node map reading rule
 		    ///
 		    /// Add a node map reading rule with specialized converter to the
 		    /// reader.
 		    template <typename Map, typename Converter>
 		    DigraphReader& nodeMap(const std::string& caption, Map& map,
 		                           const Converter& converter = Converter()) {
 		      checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
 		      _reader_bits::MapStorageBase<Node>* storage =
 		        new _reader_bits::MapStorage<Node, Map, Converter>(map, converter);
 		      _node_maps.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Arc map reading rule
 		    ///
 		    /// Add an arc map reading rule to the reader.
 		    template <typename Map>
 		    DigraphReader& arcMap(const std::string& caption, Map& map) {
 		      checkConcept<concepts::WriteMap<Arc, typename Map::Value>, Map>();
 		      _reader_bits::MapStorageBase<Arc>* storage =
 		        new _reader_bits::MapStorage<Arc, Map>(map);
 		      _arc_maps.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Arc map reading rule
 		    ///
 		    /// Add an arc map reading rule with specialized converter to the
 		    /// reader.
 		    template <typename Map, typename Converter>
 		    DigraphReader& arcMap(const std::string& caption, Map& map,
 		                          const Converter& converter = Converter()) {
 		      checkConcept<concepts::WriteMap<Arc, typename Map::Value>, Map>();
 		      _reader_bits::MapStorageBase<Arc>* storage =
 		        new _reader_bits::MapStorage<Arc, Map, Converter>(map, converter);
 		      _arc_maps.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Attribute reading rule
 		    ///
 		    /// Add an attribute reading rule to the reader.
 		    template <typename Value>
 		    DigraphReader& attribute(const std::string& caption, Value& value) {
 		      _reader_bits::ValueStorageBase* storage =
 		        new _reader_bits::ValueStorage<Value>(value);
 		      _attributes.insert(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Attribute reading rule
 		    ///
 		    /// Add an attribute reading rule with specialized converter to the
 		    /// reader.
 		    template <typename Value, typename Converter>
 		    DigraphReader& attribute(const std::string& caption, Value& value,
 		                             const Converter& converter = Converter()) {
 		      _reader_bits::ValueStorageBase* storage =
 		        new _reader_bits::ValueStorage<Value, Converter>(value, converter);
 		      _attributes.insert(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Node reading rule
 		    ///
 		    /// Add a node reading rule to reader.
 		    DigraphReader& node(const std::string& caption, Node& node) {
 		      typedef _reader_bits::MapLookUpConverter<Node> Converter;
 		      Converter converter(_node_index);
 		      _reader_bits::ValueStorageBase* storage =
 		        new _reader_bits::ValueStorage<Node, Converter>(node, converter);
 		      _attributes.insert(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Arc reading rule
 		    ///
 		    /// Add an arc reading rule to reader.
 		    DigraphReader& arc(const std::string& caption, Arc& arc) {
 		      typedef _reader_bits::MapLookUpConverter<Arc> Converter;
 		      Converter converter(_arc_index);
 		      _reader_bits::ValueStorageBase* storage =
 		        new _reader_bits::ValueStorage<Arc, Converter>(arc, converter);
 		      _attributes.insert(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// @}
 		    /// \name Select section by name
 		    /// @{
 		    /// \brief Set \c \@nodes section to be read
 		    ///
 		    /// Set \c \@nodes section to be read
 		    DigraphReader& nodes(const std::string& caption) {
 		      _nodes_caption = caption;
 		      return *this;
+		    }
 		    /// \brief Set \c \@arcs section to be read
 		    ///
 		    /// Set \c \@arcs section to be read
 		    DigraphReader& arcs(const std::string& caption) {
 		      _arcs_caption = caption;
 		      return *this;
+		    }
 		    /// \brief Set \c \@attributes section to be read
 		    ///
 		    /// Set \c \@attributes section to be read
 		    DigraphReader& attributes(const std::string& caption) {
 		      _attributes_caption = caption;
 		      return *this;
+		    }
 		    /// @}
 		    /// \name Using previously constructed node or arc set
 		    /// @{
 		    /// \brief Use previously constructed node set
 		    ///
 		    /// Use previously constructed node set, and specify the node
 		    /// label map.
 		    template <typename Map>
 		    DigraphReader& useNodes(const Map& map) {
 		      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
 		      LEMON_ASSERT(!_use_nodes, "Multiple usage of useNodes() member");
 		      _use_nodes = true;
 		      _writer_bits::DefaultConverter<typename Map::Value> converter;
 		      for (NodeIt n(_digraph); n != INVALID; ++n) {
 		        _node_index.insert(std::make_pair(converter(map[n]), n));
+		      }
 		      return *this;
+		    }
 		    /// \brief Use previously constructed node set
 		    ///
 		    /// Use previously constructed node set, and specify the node
 		    /// label map and a functor which converts the label map values to
 		    /// \c std::string.
 		    template <typename Map, typename Converter>
 		    DigraphReader& useNodes(const Map& map,
 		                            const Converter& converter = Converter()) {
 		      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
 		      LEMON_ASSERT(!_use_nodes, "Multiple usage of useNodes() member");
 		      _use_nodes = true;
 		      for (NodeIt n(_digraph); n != INVALID; ++n) {
 		        _node_index.insert(std::make_pair(converter(map[n]), n));
+		      }
 		      return *this;
+		    }
 		    /// \brief Use previously constructed arc set
 		    ///
 		    /// Use previously constructed arc set, and specify the arc
 		    /// label map.
 		    template <typename Map>
 		    DigraphReader& useArcs(const Map& map) {
 		      checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();
 		      LEMON_ASSERT(!_use_arcs, "Multiple usage of useArcs() member");
 		      _use_arcs = true;
 		      _writer_bits::DefaultConverter<typename Map::Value> converter;
 		      for (ArcIt a(_digraph); a != INVALID; ++a) {
 		        _arc_index.insert(std::make_pair(converter(map[a]), a));
+		      }
 		      return *this;
+		    }
 		    /// \brief Use previously constructed arc set
 		    ///
 		    /// Use previously constructed arc set, and specify the arc
 		    /// label map and a functor which converts the label map values to
 		    /// \c std::string.
 		    template <typename Map, typename Converter>
 		    DigraphReader& useArcs(const Map& map,
 		                           const Converter& converter = Converter()) {
 		      checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();
 		      LEMON_ASSERT(!_use_arcs, "Multiple usage of useArcs() member");
 		      _use_arcs = true;
 		      for (ArcIt a(_digraph); a != INVALID; ++a) {
 		        _arc_index.insert(std::make_pair(converter(map[a]), a));
+		      }
 		      return *this;
+		    }
 		    /// \brief Skips the reading of node section
 		    ///
 		    /// Omit the reading of the node section. This implies that each node
 		    /// map reading rule will be abandoned, and the nodes of the graph
 		    /// will not be constructed, which usually cause that the arc set
 		    /// could not be read due to lack of node name resolving.
 		    /// Therefore \c skipArcs() function should also be used, or
 		    /// \c useNodes() should be used to specify the label of the nodes.
 		    DigraphReader& skipNodes() {
 		      LEMON_ASSERT(!_skip_nodes, "Skip nodes already set");
 		      _skip_nodes = true;
 		      return *this;
+		    }
 		    /// \brief Skips the reading of arc section
 		    ///
 		    /// Omit the reading of the arc section. This implies that each arc
 		    /// map reading rule will be abandoned, and the arcs of the graph
 		    /// will not be constructed.
 		    DigraphReader& skipArcs() {
 		      LEMON_ASSERT(!_skip_arcs, "Skip arcs already set");
 		      _skip_arcs = true;
 		      return *this;
+		    }
 		    /// @}
 		  private:
 		    bool readLine() {
 		      std::string str;
 		      while(++line_num, std::getline(*_is, str)) {
 		        line.clear(); line.str(str);
 		        char c;
 		        if (line >> std::ws >> c && c != '#') {
 		          line.putback(c);
 		          return true;
+		        }
+		      }
 		      return false;
+		    }
 		    bool readSuccess() {
 		      return static_cast<bool>(*_is);
+		    }
 		    void skipSection() {
 		      char c;
 		      while (readSuccess() && line >> c && c != '@') {
 		        readLine();
+		      }
 		      if (readSuccess()) {
 		        line.putback(c);
+		      }
+		    }
 		    void readNodes() {
 		      std::vector<int> map_index(_node_maps.size());
 		      int map_num, label_index;
 		      char c;
 		      if (!readLine() || !(line >> c) || c == '@') {
 		        if (readSuccess() && line) line.putback(c);
 		        if (!_node_maps.empty())
 		          throw FormatError("Cannot find map names");
 		        return;
+		      }
 		      line.putback(c);
+		      {
 		        std::map<std::string, int> maps;
 		        std::string map;
 		        int index = 0;
 		        while (_reader_bits::readToken(line, map)) {
 		          if (maps.find(map) != maps.end()) {
 		            std::ostringstream msg;
 		            msg << "Multiple occurence of node map: " << map;
 		            throw FormatError(msg.str());
+		          }
 		          maps.insert(std::make_pair(map, index));
 		          ++index;
+		        }
 		        for (int i = 0; i < static_cast<int>(_node_maps.size()); ++i) {
 		          std::map<std::string, int>::iterator jt =
 		            maps.find(_node_maps[i].first);
 		          if (jt == maps.end()) {
 		            std::ostringstream msg;
 		            msg << "Map not found: " << _node_maps[i].first;
 		            throw FormatError(msg.str());
+		          }
 		          map_index[i] = jt->second;
+		        }
+		        {
 		          std::map<std::string, int>::iterator jt = maps.find("label");
 		          if (jt != maps.end()) {
 		            label_index = jt->second;
 		          } else {
 		            label_index = -1;
+		          }
+		        }
 		        map_num = maps.size();
+		      }
 		      while (readLine() && line >> c && c != '@') {
 		        line.putback(c);
 		        std::vector<std::string> tokens(map_num);
 		        for (int i = 0; i < map_num; ++i) {
 		          if (!_reader_bits::readToken(line, tokens[i])) {
 		            std::ostringstream msg;
 		            msg << "Column not found (" << i + 1 << ")";
 		            throw FormatError(msg.str());
+		          }
+		        }
 		        if (line >> std::ws >> c)
 		          throw FormatError("Extra character at the end of line");
 		        Node n;
 		        if (!_use_nodes) {
 		          n = _digraph.addNode();
 		          if (label_index != -1)
 		            _node_index.insert(std::make_pair(tokens[label_index], n));
 		        } else {
 		          if (label_index == -1)
 		            throw FormatError("Label map not found");
 		          typename std::map<std::string, Node>::iterator it =
 		            _node_index.find(tokens[label_index]);
 		          if (it == _node_index.end()) {
 		            std::ostringstream msg;
 		            msg << "Node with label not found: " << tokens[label_index];
 		            throw FormatError(msg.str());
+		          }
 		          n = it->second;
+		        }
 		        for (int i = 0; i < static_cast<int>(_node_maps.size()); ++i) {
 		          _node_maps[i].second->set(n, tokens[map_index[i]]);
+		        }
+		      }
 		      if (readSuccess()) {
 		        line.putback(c);
+		      }
+		    }
 		    void readArcs() {
 		      std::vector<int> map_index(_arc_maps.size());
 		      int map_num, label_index;
 		      char c;
 		      if (!readLine() || !(line >> c) || c == '@') {
 		        if (readSuccess() && line) line.putback(c);
 		        if (!_arc_maps.empty())
 		          throw FormatError("Cannot find map names");
 		        return;
+		      }
 		      line.putback(c);
+		      {
 		        std::map<std::string, int> maps;
 		        std::string map;
 		        int index = 0;
 		        while (_reader_bits::readToken(line, map)) {
 		          if(map == "-") {
 		              if(index!=0)
 		                throw FormatError("'-' is not allowed as a map name");
 		              else if (line >> std::ws >> c)
 		                throw FormatError("Extra character at the end of line");
 		              else break;
+		            }
 		          if (maps.find(map) != maps.end()) {
 		            std::ostringstream msg;
 		            msg << "Multiple occurence of arc map: " << map;
 		            throw FormatError(msg.str());
+		          }
 		          maps.insert(std::make_pair(map, index));
 		          ++index;
+		        }
 		        for (int i = 0; i < static_cast<int>(_arc_maps.size()); ++i) {
 		          std::map<std::string, int>::iterator jt =
 		            maps.find(_arc_maps[i].first);
 		          if (jt == maps.end()) {
 		            std::ostringstream msg;
 		            msg << "Map not found: " << _arc_maps[i].first;
 		            throw FormatError(msg.str());
+		          }
 		          map_index[i] = jt->second;
+		        }
+		        {
 		          std::map<std::string, int>::iterator jt = maps.find("label");
 		          if (jt != maps.end()) {
 		            label_index = jt->second;
 		          } else {
 		            label_index = -1;
+		          }
+		        }
 		        map_num = maps.size();
+		      }
 		      while (readLine() && line >> c && c != '@') {
 		        line.putback(c);
 		        std::string source_token;
 		        std::string target_token;
 		        if (!_reader_bits::readToken(line, source_token))
 		          throw FormatError("Source not found");
 		        if (!_reader_bits::readToken(line, target_token))
 		          throw FormatError("Target not found");
 		        std::vector<std::string> tokens(map_num);
 		        for (int i = 0; i < map_num; ++i) {
 		          if (!_reader_bits::readToken(line, tokens[i])) {
 		            std::ostringstream msg;
 		            msg << "Column not found (" << i + 1 << ")";
 		            throw FormatError(msg.str());
+		          }
+		        }
 		        if (line >> std::ws >> c)
 		          throw FormatError("Extra character at the end of line");
 		        Arc a;
 		        if (!_use_arcs) {
 		          typename NodeIndex::iterator it;
 		          it = _node_index.find(source_token);
 		          if (it == _node_index.end()) {
 		            std::ostringstream msg;
 		            msg << "Item not found: " << source_token;
 		            throw FormatError(msg.str());
+		          }
 		          Node source = it->second;
 		          it = _node_index.find(target_token);
 		          if (it == _node_index.end()) {
 		            std::ostringstream msg;
 		            msg << "Item not found: " << target_token;
 		            throw FormatError(msg.str());
+		          }
 		          Node target = it->second;
 		          a = _digraph.addArc(source, target);
 		          if (label_index != -1)
 		            _arc_index.insert(std::make_pair(tokens[label_index], a));
 		        } else {
 		          if (label_index == -1)
 		            throw FormatError("Label map not found");
 		          typename std::map<std::string, Arc>::iterator it =
 		            _arc_index.find(tokens[label_index]);
 		          if (it == _arc_index.end()) {
 		            std::ostringstream msg;
 		            msg << "Arc with label not found: " << tokens[label_index];
 		            throw FormatError(msg.str());
+		          }
 		          a = it->second;
+		        }
 		        for (int i = 0; i < static_cast<int>(_arc_maps.size()); ++i) {
 		          _arc_maps[i].second->set(a, tokens[map_index[i]]);
+		        }
+		      }
 		      if (readSuccess()) {
 		        line.putback(c);
+		      }
+		    }
 		    void readAttributes() {
 		      std::set<std::string> read_attr;
 		      char c;
 		      while (readLine() && line >> c && c != '@') {
 		        line.putback(c);
 		        std::string attr, token;
 		        if (!_reader_bits::readToken(line, attr))
 		          throw FormatError("Attribute name not found");
 		        if (!_reader_bits::readToken(line, token))
 		          throw FormatError("Attribute value not found");
 		        if (line >> c)
 		          throw FormatError("Extra character at the end of line");
+		        {
 		          std::set<std::string>::iterator it = read_attr.find(attr);
 		          if (it != read_attr.end()) {
 		            std::ostringstream msg;
 		            msg << "Multiple occurence of attribute: " << attr;
 		            throw FormatError(msg.str());
+		          }
 		          read_attr.insert(attr);
+		        }
+		        {
 		          typename Attributes::iterator it = _attributes.lower_bound(attr);
 		          while (it != _attributes.end() && it->first == attr) {
 		            it->second->set(token);
 		            ++it;
+		          }
+		        }
+		      }
 		      if (readSuccess()) {
 		        line.putback(c);
+		      }
 		      for (typename Attributes::iterator it = _attributes.begin();
 		           it != _attributes.end(); ++it) {
 		        if (read_attr.find(it->first) == read_attr.end()) {
 		          std::ostringstream msg;
 		          msg << "Attribute not found: " << it->first;
 		          throw FormatError(msg.str());
+		        }
+		      }
+		    }
 		  public:
 		    /// \name Execution of the reader
 		    /// @{
 		    /// \brief Start the batch processing
 		    ///
 		    /// This function starts the batch processing
 		    void run() {
 		      LEMON_ASSERT(_is != 0, "This reader assigned to an other reader");
 		      bool nodes_done = _skip_nodes;
 		      bool arcs_done = _skip_arcs;
 		      bool attributes_done = false;
 		      line_num = 0;
 		      readLine();
 		      skipSection();
 		      while (readSuccess()) {
 		        try {
 		          char c;
 		          std::string section, caption;
 		          line >> c;
 		          _reader_bits::readToken(line, section);
 		          _reader_bits::readToken(line, caption);
 		          if (line >> c)
 		            throw FormatError("Extra character at the end of line");
 		          if (section == "nodes" && !nodes_done) {
 		            if (_nodes_caption.empty() || _nodes_caption == caption) {
 		              readNodes();
 		              nodes_done = true;
+		            }
 		          } else if ((section == "arcs" || section == "edges") &&
 		                     !arcs_done) {
 		            if (_arcs_caption.empty() || _arcs_caption == caption) {
 		              readArcs();
 		              arcs_done = true;
+		            }
 		          } else if (section == "attributes" && !attributes_done) {
 		            if (_attributes_caption.empty() || _attributes_caption == caption) {
 		              readAttributes();
 		              attributes_done = true;
+		            }
 		          } else {
 		            readLine();
 		            skipSection();
+		          }
 		        } catch (FormatError& error) {
 		          error.line(line_num);
 		          error.file(_filename);
 		          throw;
+		        }
+		      }
 		      if (!nodes_done) {
 		        throw FormatError("Section @nodes not found");
+		      }
 		      if (!arcs_done) {
 		        throw FormatError("Section @arcs not found");
+		      }
 		      if (!attributes_done && !_attributes.empty()) {
 		        throw FormatError("Section @attributes not found");
+		      }
+		    }
 		    /// @}
 		  };
 		  /// \brief Return a \ref DigraphReader class
 		  ///
 		  /// This function just returns a \ref DigraphReader class.
 		  /// \relates DigraphReader
 		  template <typename Digraph>
 		  DigraphReader<Digraph> digraphReader(Digraph& digraph, std::istream& is) {
 		    DigraphReader<Digraph> tmp(digraph, is);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref DigraphReader class
 		  ///
 		  /// This function just returns a \ref DigraphReader class.
 		  /// \relates DigraphReader
 		  template <typename Digraph>
 		  DigraphReader<Digraph> digraphReader(Digraph& digraph,
 		                                       const std::string& fn) {
 		    DigraphReader<Digraph> tmp(digraph, fn);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref DigraphReader class
 		  ///
 		  /// This function just returns a \ref DigraphReader class.
 		  /// \relates DigraphReader
 		  template <typename Digraph>
 		  DigraphReader<Digraph> digraphReader(Digraph& digraph, const char* fn) {
 		    DigraphReader<Digraph> tmp(digraph, fn);
 		    return tmp;
+		  }
 		  template <typename Graph>
 		  class GraphReader;
 		  template <typename Graph>
-		  GraphReader<Graph> graphReader(Graph& graph,
 		  GraphReader<Graph> graphReader(Graph& graph,
 		                                 std::istream& is = std::cin);
 		  template <typename Graph>
 		  GraphReader<Graph> graphReader(Graph& graph, const std::string& fn);
 		  template <typename Graph>
 		  GraphReader<Graph> graphReader(Graph& graph, const char *fn);
 		  /// \ingroup lemon_io
 		  ///
 		  /// \brief \ref lgf-format "LGF" reader for undirected graphs
 		  ///
 		  /// This utility reads an \ref lgf-format "LGF" file.
 		  ///
 		  /// It can be used almost the same way as \c DigraphReader.
 		  /// The only difference is that this class can handle edges and
 		  /// edge maps as well as arcs and arc maps.
 		  ///
 		  /// The columns in the \c \@edges (or \c \@arcs) section are the
 		  /// edge maps. However, if there are two maps with the same name
 		  /// prefixed with \c '+' and \c '-', then these can be read into an
 		  /// arc map.  Similarly, an attribute can be read into an arc, if
 		  /// it's value is an edge label prefixed with \c '+' or \c '-'.
 		  template <typename _Graph>
 		  class GraphReader {
 		  public:
 		    typedef _Graph Graph;
 		    TEMPLATE_GRAPH_TYPEDEFS(Graph);
 		  private:
 		    std::istream* _is;
 		    bool local_is;
 		    std::string _filename;
 		    Graph& _graph;
 		    std::string _nodes_caption;
 		    std::string _edges_caption;
 		    std::string _attributes_caption;
 		    typedef std::map<std::string, Node> NodeIndex;
 		    NodeIndex _node_index;
 		    typedef std::map<std::string, Edge> EdgeIndex;
 		    EdgeIndex _edge_index;
 		    typedef std::vector<std::pair<std::string,
 		      _reader_bits::MapStorageBase<Node>*> > NodeMaps;
 		    NodeMaps _node_maps;
 		    typedef std::vector<std::pair<std::string,
 		      _reader_bits::MapStorageBase<Edge>*> > EdgeMaps;
 		    EdgeMaps _edge_maps;
 		    typedef std::multimap<std::string, _reader_bits::ValueStorageBase*>
 		      Attributes;
 		    Attributes _attributes;
 		    bool _use_nodes;
 		    bool _use_edges;
 		    bool _skip_nodes;
 		    bool _skip_edges;
 		    int line_num;
 		    std::istringstream line;
 		  public:
 		    /// \brief Constructor
 		    ///
 		    /// Construct an undirected graph reader, which reads from the given
 		    /// input stream.
 		    GraphReader(Graph& graph, std::istream& is = std::cin)
 		      : _is(&is), local_is(false), _graph(graph),
 		        _use_nodes(false), _use_edges(false),
 		        _skip_nodes(false), _skip_edges(false) {}
 		    /// \brief Constructor
 		    ///
 		    /// Construct an undirected graph reader, which reads from the given
 		    /// file.
 		    GraphReader(Graph& graph, const std::string& fn)
 		      : _is(new std::ifstream(fn.c_str())), local_is(true),
 		        _filename(fn), _graph(graph),
 		        _use_nodes(false), _use_edges(false),
 		        _skip_nodes(false), _skip_edges(false) {
 		      if (!(*_is)) {
 		        delete _is;
 		        throw IoError("Cannot open file", fn);
+		      }
+		    }
 		    /// \brief Constructor
 		    ///
 		    /// Construct an undirected graph reader, which reads from the given
 		    /// file.
 		    GraphReader(Graph& graph, const char* fn)
 		      : _is(new std::ifstream(fn)), local_is(true),
 		        _filename(fn), _graph(graph),
 		        _use_nodes(false), _use_edges(false),
 		        _skip_nodes(false), _skip_edges(false) {
 		      if (!(*_is)) {
 		        delete _is;
 		        throw IoError("Cannot open file", fn);
+		      }
+		    }
 		    /// \brief Destructor
 		    ~GraphReader() {
 		      for (typename NodeMaps::iterator it = _node_maps.begin();
 		           it != _node_maps.end(); ++it) {
 		        delete it->second;
+		      }
 		      for (typename EdgeMaps::iterator it = _edge_maps.begin();
 		           it != _edge_maps.end(); ++it) {
 		        delete it->second;
+		      }
 		      for (typename Attributes::iterator it = _attributes.begin();
 		           it != _attributes.end(); ++it) {
 		        delete it->second;
+		      }
 		      if (local_is) {
 		        delete _is;
+		      }
+		    }
 		  private:
 		    template <typename GR>
 		    friend GraphReader<GR> graphReader(GR& graph, std::istream& is);
 		    template <typename GR>
-		    friend GraphReader<GR> graphReader(GR& graph, const std::string& fn);
 		    friend GraphReader<GR> graphReader(GR& graph, const std::string& fn);
 		    template <typename GR>
 		    friend GraphReader<GR> graphReader(GR& graph, const char *fn);
 		    GraphReader(GraphReader& other)
 		      : _is(other._is), local_is(other.local_is), _graph(other._graph),
 		        _use_nodes(other._use_nodes), _use_edges(other._use_edges),
 		        _skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) {
 		      other._is = 0;
 		      other.local_is = false;
 		      _node_index.swap(other._node_index);
 		      _edge_index.swap(other._edge_index);
 		      _node_maps.swap(other._node_maps);
 		      _edge_maps.swap(other._edge_maps);
 		      _attributes.swap(other._attributes);
 		      _nodes_caption = other._nodes_caption;
 		      _edges_caption = other._edges_caption;
 		      _attributes_caption = other._attributes_caption;
+		    }
 		    GraphReader& operator=(const GraphReader&);
 		  public:
 		    /// \name Reading rules
 		    /// @{
 		    /// \brief Node map reading rule
 		    ///
 		    /// Add a node map reading rule to the reader.
 		    template <typename Map>
 		    GraphReader& nodeMap(const std::string& caption, Map& map) {
 		      checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
 		      _reader_bits::MapStorageBase<Node>* storage =
 		        new _reader_bits::MapStorage<Node, Map>(map);
 		      _node_maps.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Node map reading rule
 		    ///
 		    /// Add a node map reading rule with specialized converter to the
 		    /// reader.
 		    template <typename Map, typename Converter>
 		    GraphReader& nodeMap(const std::string& caption, Map& map,
 		                           const Converter& converter = Converter()) {
 		      checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
 		      _reader_bits::MapStorageBase<Node>* storage =
 		        new _reader_bits::MapStorage<Node, Map, Converter>(map, converter);
 		      _node_maps.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Edge map reading rule
 		    ///
 		    /// Add an edge map reading rule to the reader.
 		    template <typename Map>
 		    GraphReader& edgeMap(const std::string& caption, Map& map) {
 		      checkConcept<concepts::WriteMap<Edge, typename Map::Value>, Map>();
 		      _reader_bits::MapStorageBase<Edge>* storage =
 		        new _reader_bits::MapStorage<Edge, Map>(map);
 		      _edge_maps.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Edge map reading rule
 		    ///
 		    /// Add an edge map reading rule with specialized converter to the
 		    /// reader.
 		    template <typename Map, typename Converter>
 		    GraphReader& edgeMap(const std::string& caption, Map& map,
 		                          const Converter& converter = Converter()) {
 		      checkConcept<concepts::WriteMap<Edge, typename Map::Value>, Map>();
 		      _reader_bits::MapStorageBase<Edge>* storage =
 		        new _reader_bits::MapStorage<Edge, Map, Converter>(map, converter);
 		      _edge_maps.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Arc map reading rule
 		    ///
 		    /// Add an arc map reading rule to the reader.
 		    template <typename Map>
 		    GraphReader& arcMap(const std::string& caption, Map& map) {
 		      checkConcept<concepts::WriteMap<Arc, typename Map::Value>, Map>();
 		      _reader_bits::MapStorageBase<Edge>* forward_storage =
 		        new _reader_bits::GraphArcMapStorage<Graph, true, Map>(_graph, map);
 		      _edge_maps.push_back(std::make_pair('+' + caption, forward_storage));
 		      _reader_bits::MapStorageBase<Edge>* backward_storage =
 		        new _reader_bits::GraphArcMapStorage<Graph, false, Map>(_graph, map);
 		      _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
 		      return *this;
+		    }
 		    /// \brief Arc map reading rule
 		    ///
 		    /// Add an arc map reading rule with specialized converter to the
 		    /// reader.
 		    template <typename Map, typename Converter>
 		    GraphReader& arcMap(const std::string& caption, Map& map,
 		                          const Converter& converter = Converter()) {
 		      checkConcept<concepts::WriteMap<Arc, typename Map::Value>, Map>();
 		      _reader_bits::MapStorageBase<Edge>* forward_storage =
 		        new _reader_bits::GraphArcMapStorage<Graph, true, Map, Converter>
 		        (_graph, map, converter);
 		      _edge_maps.push_back(std::make_pair('+' + caption, forward_storage));
 		      _reader_bits::MapStorageBase<Edge>* backward_storage =
 		        new _reader_bits::GraphArcMapStorage<Graph, false, Map, Converter>
 		        (_graph, map, converter);
 		      _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
 		      return *this;
+		    }
 		    /// \brief Attribute reading rule
 		    ///
 		    /// Add an attribute reading rule to the reader.
 		    template <typename Value>
 		    GraphReader& attribute(const std::string& caption, Value& value) {
 		      _reader_bits::ValueStorageBase* storage =
 		        new _reader_bits::ValueStorage<Value>(value);
 		      _attributes.insert(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Attribute reading rule
 		    ///
 		    /// Add an attribute reading rule with specialized converter to the
 		    /// reader.
 		    template <typename Value, typename Converter>
 		    GraphReader& attribute(const std::string& caption, Value& value,
 		                             const Converter& converter = Converter()) {
 		      _reader_bits::ValueStorageBase* storage =
 		        new _reader_bits::ValueStorage<Value, Converter>(value, converter);
 		      _attributes.insert(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Node reading rule
 		    ///
 		    /// Add a node reading rule to reader.
 		    GraphReader& node(const std::string& caption, Node& node) {
 		      typedef _reader_bits::MapLookUpConverter<Node> Converter;
 		      Converter converter(_node_index);
 		      _reader_bits::ValueStorageBase* storage =
 		        new _reader_bits::ValueStorage<Node, Converter>(node, converter);
 		      _attributes.insert(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Edge reading rule
 		    ///
 		    /// Add an edge reading rule to reader.
 		    GraphReader& edge(const std::string& caption, Edge& edge) {
 		      typedef _reader_bits::MapLookUpConverter<Edge> Converter;
 		      Converter converter(_edge_index);
 		      _reader_bits::ValueStorageBase* storage =
 		        new _reader_bits::ValueStorage<Edge, Converter>(edge, converter);
 		      _attributes.insert(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Arc reading rule
 		    ///
 		    /// Add an arc reading rule to reader.
 		    GraphReader& arc(const std::string& caption, Arc& arc) {
 		      typedef _reader_bits::GraphArcLookUpConverter<Graph> Converter;
 		      Converter converter(_graph, _edge_index);
 		      _reader_bits::ValueStorageBase* storage =
 		        new _reader_bits::ValueStorage<Arc, Converter>(arc, converter);
 		      _attributes.insert(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// @}
 		    /// \name Select section by name
 		    /// @{
 		    /// \brief Set \c \@nodes section to be read
 		    ///
 		    /// Set \c \@nodes section to be read.
 		    GraphReader& nodes(const std::string& caption) {
 		      _nodes_caption = caption;
 		      return *this;
+		    }
 		    /// \brief Set \c \@edges section to be read
 		    ///
 		    /// Set \c \@edges section to be read.
 		    GraphReader& edges(const std::string& caption) {
 		      _edges_caption = caption;
 		      return *this;
+		    }
 		    /// \brief Set \c \@attributes section to be read
 		    ///
 		    /// Set \c \@attributes section to be read.
 		    GraphReader& attributes(const std::string& caption) {
 		      _attributes_caption = caption;
 		      return *this;
+		    }
 		    /// @}
 		    /// \name Using previously constructed node or edge set
 		    /// @{
 		    /// \brief Use previously constructed node set
 		    ///
 		    /// Use previously constructed node set, and specify the node
 		    /// label map.
 		    template <typename Map>
 		    GraphReader& useNodes(const Map& map) {
 		      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
 		      LEMON_ASSERT(!_use_nodes, "Multiple usage of useNodes() member");
 		      _use_nodes = true;
 		      _writer_bits::DefaultConverter<typename Map::Value> converter;
 		      for (NodeIt n(_graph); n != INVALID; ++n) {
 		        _node_index.insert(std::make_pair(converter(map[n]), n));
+		      }
 		      return *this;
+		    }
 		    /// \brief Use previously constructed node set
 		    ///
 		    /// Use previously constructed node set, and specify the node
 		    /// label map and a functor which converts the label map values to
 		    /// \c std::string.
 		    template <typename Map, typename Converter>
 		    GraphReader& useNodes(const Map& map,
 		                            const Converter& converter = Converter()) {
 		      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
 		      LEMON_ASSERT(!_use_nodes, "Multiple usage of useNodes() member");
 		      _use_nodes = true;
 		      for (NodeIt n(_graph); n != INVALID; ++n) {
 		        _node_index.insert(std::make_pair(converter(map[n]), n));
+		      }
 		      return *this;
+		    }
 		    /// \brief Use previously constructed edge set
 		    ///
 		    /// Use previously constructed edge set, and specify the edge
 		    /// label map.
 		    template <typename Map>
 		    GraphReader& useEdges(const Map& map) {
 		      checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();
 		      LEMON_ASSERT(!_use_edges, "Multiple usage of useEdges() member");
 		      _use_edges = true;
 		      _writer_bits::DefaultConverter<typename Map::Value> converter;
 		      for (EdgeIt a(_graph); a != INVALID; ++a) {
 		        _edge_index.insert(std::make_pair(converter(map[a]), a));
+		      }
 		      return *this;
+		    }
 		    /// \brief Use previously constructed edge set
 		    ///
 		    /// Use previously constructed edge set, and specify the edge
 		    /// label map and a functor which converts the label map values to
 		    /// \c std::string.
 		    template <typename Map, typename Converter>
 		    GraphReader& useEdges(const Map& map,
 		                            const Converter& converter = Converter()) {
 		      checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();
 		      LEMON_ASSERT(!_use_edges, "Multiple usage of useEdges() member");
 		      _use_edges = true;
 		      for (EdgeIt a(_graph); a != INVALID; ++a) {
 		        _edge_index.insert(std::make_pair(converter(map[a]), a));
+		      }
 		      return *this;
+		    }
 		    /// \brief Skip the reading of node section
 		    ///
 		    /// Omit the reading of the node section. This implies that each node
 		    /// map reading rule will be abandoned, and the nodes of the graph
 		    /// will not be constructed, which usually cause that the edge set
 		    /// could not be read due to lack of node name
 		    /// could not be read due to lack of node name resolving.
 		    /// Therefore \c skipEdges() function should also be used, or
 		    /// \c useNodes() should be used to specify the label of the nodes.
 		    GraphReader& skipNodes() {
 		      LEMON_ASSERT(!_skip_nodes, "Skip nodes already set");
 		      _skip_nodes = true;
 		      return *this;
+		    }
 		    /// \brief Skip the reading of edge section
 		    ///
 		    /// Omit the reading of the edge section. This implies that each edge
 		    /// map reading rule will be abandoned, and the edges of the graph
 		    /// will not be constructed.
 		    GraphReader& skipEdges() {
 		      LEMON_ASSERT(!_skip_edges, "Skip edges already set");
 		      _skip_edges = true;
 		      return *this;
+		    }
 		    /// @}
 		  private:
 		    bool readLine() {
 		      std::string str;
 		      while(++line_num, std::getline(*_is, str)) {
 		        line.clear(); line.str(str);
 		        char c;
 		        if (line >> std::ws >> c && c != '#') {
 		          line.putback(c);
 		          return true;
+		        }
+		      }
 		      return false;
+		    }
 		    bool readSuccess() {
 		      return static_cast<bool>(*_is);
+		    }
 		    void skipSection() {
 		      char c;
 		      while (readSuccess() && line >> c && c != '@') {
 		        readLine();
+		      }
 		      if (readSuccess()) {
 		        line.putback(c);
+		      }
+		    }
 		    void readNodes() {
 		      std::vector<int> map_index(_node_maps.size());
 		      int map_num, label_index;
 		      char c;
 		      if (!readLine() || !(line >> c) || c == '@') {
 		        if (readSuccess() && line) line.putback(c);
 		        if (!_node_maps.empty())
 		          throw FormatError("Cannot find map names");
 		        return;
+		      }
 		      line.putback(c);
+		      {
 		        std::map<std::string, int> maps;
 		        std::string map;
 		        int index = 0;
 		        while (_reader_bits::readToken(line, map)) {
 		          if (maps.find(map) != maps.end()) {
 		            std::ostringstream msg;
 		            msg << "Multiple occurence of node map: " << map;
 		            throw FormatError(msg.str());
+		          }
 		          maps.insert(std::make_pair(map, index));
 		          ++index;
+		        }
 		        for (int i = 0; i < static_cast<int>(_node_maps.size()); ++i) {
 		          std::map<std::string, int>::iterator jt =
 		            maps.find(_node_maps[i].first);
 		          if (jt == maps.end()) {
 		            std::ostringstream msg;
 		            msg << "Map not found: " << _node_maps[i].first;
 		            throw FormatError(msg.str());
+		          }
 		          map_index[i] = jt->second;
+		        }
+		        {
 		          std::map<std::string, int>::iterator jt = maps.find("label");
 		          if (jt != maps.end()) {
 		            label_index = jt->second;
 		          } else {
 		            label_index = -1;
+		          }
+		        }
 		        map_num = maps.size();
+		      }
 		      while (readLine() && line >> c && c != '@') {
 		        line.putback(c);
 		        std::vector<std::string> tokens(map_num);
 		        for (int i = 0; i < map_num; ++i) {
 		          if (!_reader_bits::readToken(line, tokens[i])) {
 		            std::ostringstream msg;
 		            msg << "Column not found (" << i + 1 << ")";
 		            throw FormatError(msg.str());
+		          }
+		        }
 		        if (line >> std::ws >> c)
 		          throw FormatError("Extra character at the end of line");
 		        Node n;
 		        if (!_use_nodes) {
 		          n = _graph.addNode();
 		          if (label_index != -1)
 		            _node_index.insert(std::make_pair(tokens[label_index], n));
 		        } else {
 		          if (label_index == -1)
 		            throw FormatError("Label map not found");
 		          typename std::map<std::string, Node>::iterator it =
 		            _node_index.find(tokens[label_index]);
 		          if (it == _node_index.end()) {
 		            std::ostringstream msg;
 		            msg << "Node with label not found: " << tokens[label_index];
 		            throw FormatError(msg.str());
+		          }
 		          n = it->second;
+		        }
 		        for (int i = 0; i < static_cast<int>(_node_maps.size()); ++i) {
 		          _node_maps[i].second->set(n, tokens[map_index[i]]);
+		        }
+		      }
 		      if (readSuccess()) {
 		        line.putback(c);
+		      }
+		    }
 		    void readEdges() {
 		      std::vector<int> map_index(_edge_maps.size());
 		      int map_num, label_index;
 		      char c;
 		      if (!readLine() || !(line >> c) || c == '@') {
 		        if (readSuccess() && line) line.putback(c);
 		        if (!_edge_maps.empty())
 		          throw FormatError("Cannot find map names");
 		        return;
+		      }
 		      line.putback(c);
+		      {
 		        std::map<std::string, int> maps;
 		        std::string map;
 		        int index = 0;
 		        while (_reader_bits::readToken(line, map)) {
 		          if(map == "-") {
 		              if(index!=0)
 		                throw FormatError("'-' is not allowed as a map name");
 		              else if (line >> std::ws >> c)
 		                throw FormatError("Extra character at the end of line");
 		              else break;
+		            }
 		          if (maps.find(map) != maps.end()) {
 		            std::ostringstream msg;
 		            msg << "Multiple occurence of edge map: " << map;
 		            throw FormatError(msg.str());
+		          }
 		          maps.insert(std::make_pair(map, index));
 		          ++index;
+		        }
 		        for (int i = 0; i < static_cast<int>(_edge_maps.size()); ++i) {
 		          std::map<std::string, int>::iterator jt =
 		            maps.find(_edge_maps[i].first);
 		          if (jt == maps.end()) {
 		            std::ostringstream msg;
 		            msg << "Map not found: " << _edge_maps[i].first;
 		            throw FormatError(msg.str());
+		          }
 		          map_index[i] = jt->second;
+		        }
+		        {
 		          std::map<std::string, int>::iterator jt = maps.find("label");
 		          if (jt != maps.end()) {
 		            label_index = jt->second;
 		          } else {
 		            label_index = -1;
+		          }
+		        }
 		        map_num = maps.size();
+		      }
 		      while (readLine() && line >> c && c != '@') {
 		        line.putback(c);
 		        std::string source_token;
 		        std::string target_token;
 		        if (!_reader_bits::readToken(line, source_token))
 		          throw FormatError("Node u not found");
 		        if (!_reader_bits::readToken(line, target_token))
 		          throw FormatError("Node v not found");
 		        std::vector<std::string> tokens(map_num);
 		        for (int i = 0; i < map_num; ++i) {
 		          if (!_reader_bits::readToken(line, tokens[i])) {
 		            std::ostringstream msg;
 		            msg << "Column not found (" << i + 1 << ")";
 		            throw FormatError(msg.str());
+		          }
+		        }
 		        if (line >> std::ws >> c)
 		          throw FormatError("Extra character at the end of line");
 		        Edge e;
 		        if (!_use_edges) {
 		          typename NodeIndex::iterator it;
 		          it = _node_index.find(source_token);
 		          if (it == _node_index.end()) {
 		            std::ostringstream msg;
 		            msg << "Item not found: " << source_token;
 		            throw FormatError(msg.str());
+		          }
 		          Node source = it->second;
 		          it = _node_index.find(target_token);
 		          if (it == _node_index.end()) {
 		            std::ostringstream msg;
 		            msg << "Item not found: " << target_token;
 		            throw FormatError(msg.str());
+		          }
 		          Node target = it->second;
 		          e = _graph.addEdge(source, target);
 		          if (label_index != -1)
 		            _edge_index.insert(std::make_pair(tokens[label_index], e));
 		        } else {
 		          if (label_index == -1)
 		            throw FormatError("Label map not found");
 		          typename std::map<std::string, Edge>::iterator it =
 		            _edge_index.find(tokens[label_index]);
 		          if (it == _edge_index.end()) {
 		            std::ostringstream msg;
 		            msg << "Edge with label not found: " << tokens[label_index];
 		            throw FormatError(msg.str());
+		          }
 		          e = it->second;
+		        }
 		        for (int i = 0; i < static_cast<int>(_edge_maps.size()); ++i) {
 		          _edge_maps[i].second->set(e, tokens[map_index[i]]);
+		        }
+		      }
 		      if (readSuccess()) {
 		        line.putback(c);
+		      }
+		    }
 		    void readAttributes() {
 		      std::set<std::string> read_attr;
 		      char c;
 		      while (readLine() && line >> c && c != '@') {
 		        line.putback(c);
 		        std::string attr, token;
 		        if (!_reader_bits::readToken(line, attr))
 		          throw FormatError("Attribute name not found");
 		        if (!_reader_bits::readToken(line, token))
 		          throw FormatError("Attribute value not found");
 		        if (line >> c)
 		          throw FormatError("Extra character at the end of line");
+		        {
 		          std::set<std::string>::iterator it = read_attr.find(attr);
 		          if (it != read_attr.end()) {
 		            std::ostringstream msg;
 		            msg << "Multiple occurence of attribute: " << attr;
 		            throw FormatError(msg.str());
+		          }
 		          read_attr.insert(attr);
+		        }
+		        {
 		          typename Attributes::iterator it = _attributes.lower_bound(attr);
 		          while (it != _attributes.end() && it->first == attr) {
 		            it->second->set(token);
 		            ++it;
+		          }
+		        }
+		      }
 		      if (readSuccess()) {
 		        line.putback(c);
+		      }
 		      for (typename Attributes::iterator it = _attributes.begin();
 		           it != _attributes.end(); ++it) {
 		        if (read_attr.find(it->first) == read_attr.end()) {
 		          std::ostringstream msg;
 		          msg << "Attribute not found: " << it->first;
 		          throw FormatError(msg.str());
+		        }
+		      }
+		    }
 		  public:
 		    /// \name Execution of the reader
 		    /// @{
 		    /// \brief Start the batch processing
 		    ///
 		    /// This function starts the batch processing
 		    void run() {
 		      LEMON_ASSERT(_is != 0, "This reader assigned to an other reader");
 		      bool nodes_done = _skip_nodes;
 		      bool edges_done = _skip_edges;
 		      bool attributes_done = false;
 		      line_num = 0;
 		      readLine();
 		      skipSection();
 		      while (readSuccess()) {
 		        try {
 		          char c;
 		          std::string section, caption;
 		          line >> c;
 		          _reader_bits::readToken(line, section);
 		          _reader_bits::readToken(line, caption);
 		          if (line >> c)
 		            throw FormatError("Extra character at the end of line");
 		          if (section == "nodes" && !nodes_done) {
 		            if (_nodes_caption.empty() || _nodes_caption == caption) {
 		              readNodes();
 		              nodes_done = true;
+		            }
 		          } else if ((section == "edges" || section == "arcs") &&
 		                     !edges_done) {
 		            if (_edges_caption.empty() || _edges_caption == caption) {
 		              readEdges();
 		              edges_done = true;
+		            }
 		          } else if (section == "attributes" && !attributes_done) {
 		            if (_attributes_caption.empty() || _attributes_caption == caption) {
 		              readAttributes();
 		              attributes_done = true;
+		            }
 		          } else {
 		            readLine();
 		            skipSection();
+		          }
 		        } catch (FormatError& error) {
 		          error.line(line_num);
 		          error.file(_filename);
 		          throw;
+		        }
+		      }
 		      if (!nodes_done) {
 		        throw FormatError("Section @nodes not found");
+		      }
 		      if (!edges_done) {
 		        throw FormatError("Section @edges not found");
+		      }
 		      if (!attributes_done && !_attributes.empty()) {
 		        throw FormatError("Section @attributes not found");
+		      }
+		    }
 		    /// @}
 		  };
 		  /// \brief Return a \ref GraphReader class
 		  ///
 		  /// This function just returns a \ref GraphReader class.
 		  /// \relates GraphReader
 		  template <typename Graph>
 		  GraphReader<Graph> graphReader(Graph& graph, std::istream& is) {
 		    GraphReader<Graph> tmp(graph, is);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref GraphReader class
 		  ///
 		  /// This function just returns a \ref GraphReader class.
 		  /// \relates GraphReader
 		  template <typename Graph>
 		  GraphReader<Graph> graphReader(Graph& graph, const std::string& fn) {
 		    GraphReader<Graph> tmp(graph, fn);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref GraphReader class
 		  ///
 		  /// This function just returns a \ref GraphReader class.
 		  /// \relates GraphReader
 		  template <typename Graph>
 		  GraphReader<Graph> graphReader(Graph& graph, const char* fn) {
 		    GraphReader<Graph> tmp(graph, fn);
 		    return tmp;
+		  }
 		  class SectionReader;
 		  SectionReader sectionReader(std::istream& is);
 		  SectionReader sectionReader(const std::string& fn);
 		  SectionReader sectionReader(const char* fn);
 		  /// \ingroup lemon_io
 		  ///
 		  /// \brief Section reader class
 		  ///
 		  /// In the \ref lgf-format "LGF" file extra sections can be placed,
 		  /// which contain any data in arbitrary format. Such sections can be
 		  /// read with this class. A reading rule can be added to the class
 		  /// with two different functions. With the \c sectionLines() function a
 		  /// functor can process the section line-by-line, while with the \c
 		  /// sectionStream() member the section can be read from an input
 		  /// stream.
 		  class SectionReader {
 		  private:
 		    std::istream* _is;
 		    bool local_is;
 		    std::string _filename;
 		    typedef std::map<std::string, _reader_bits::Section*> Sections;
 		    Sections _sections;
 		    int line_num;
 		    std::istringstream line;
 		  public:
 		    /// \brief Constructor
 		    ///
 		    /// Construct a section reader, which reads from the given input
 		    /// stream.
 		    SectionReader(std::istream& is)
 		      : _is(&is), local_is(false) {}
 		    /// \brief Constructor
 		    ///
 		    /// Construct a section reader, which reads from the given file.
 		    SectionReader(const std::string& fn)
 		      : _is(new std::ifstream(fn.c_str())), local_is(true),
 		        _filename(fn) {
 		      if (!(*_is)) {
 		        delete _is;
 		        throw IoError("Cannot open file", fn);
+		      }
+		    }
 		    /// \brief Constructor
 		    ///
 		    /// Construct a section reader, which reads from the given file.
 		    SectionReader(const char* fn)
 		      : _is(new std::ifstream(fn)), local_is(true),
 		        _filename(fn) {
 		      if (!(*_is)) {
 		        delete _is;
 		        throw IoError("Cannot open file", fn);
+		      }
+		    }
 		    /// \brief Destructor
 		    ~SectionReader() {
 		      for (Sections::iterator it = _sections.begin();
 		           it != _sections.end(); ++it) {
 		        delete it->second;
+		      }
 		      if (local_is) {
 		        delete _is;
+		      }
+		    }
 		  private:
 		    friend SectionReader sectionReader(std::istream& is);
 		    friend SectionReader sectionReader(const std::string& fn);
 		    friend SectionReader sectionReader(const char* fn);
 		    SectionReader(SectionReader& other)
 		      : _is(other._is), local_is(other.local_is) {
 		      other._is = 0;
 		      other.local_is = false;
 		      _sections.swap(other._sections);
+		    }
 		    SectionReader& operator=(const SectionReader&);
 		  public:
 		    /// \name Section readers
 		    /// @{
 		    /// \brief Add a section processor with line oriented reading
 		    ///
 		    /// The first parameter is the type descriptor of the section, the
 		    /// second is a functor, which takes just one \c std::string
 		    /// parameter. At the reading process, each line of the section
 		    /// will be given to the functor object. However, the empty lines
 		    /// and the comment lines are filtered out, and the leading
 		    /// whitespaces are trimmed from each processed string.
 		    ///
 		    /// For example let's see a section, which contain several
 		    /// integers, which should be inserted into a vector.
 		    ///\code
 		    ///  @numbers
 		    ///  12 45 23
 		    ///  4
 		    ///  23 6
 		    ///\endcode
 		    ///
 		    /// The functor is implemented as a struct:
 		    ///\code
 		    ///  struct NumberSection {
 		    ///    std::vector<int>& _data;
 		    ///    NumberSection(std::vector<int>& data) : _data(data) {}
 		    ///    void operator()(const std::string& line) {
 		    ///      std::istringstream ls(line);
 		    ///      int value;
 		    ///      while (ls >> value) _data.push_back(value);
 		    ///    }
 		    ///  };
 		    ///
 		    ///  // ...
 		    ///
 		    ///  reader.sectionLines("numbers", NumberSection(vec));
 		    ///\endcode
 		    template <typename Functor>
 		    SectionReader& sectionLines(const std::string& type, Functor functor) {
 		      LEMON_ASSERT(!type.empty(), "Type is empty.");
 		      LEMON_ASSERT(_sections.find(type) == _sections.end(),
 		                   "Multiple reading of section.");
 		      _sections.insert(std::make_pair(type,
 		        new _reader_bits::LineSection<Functor>(functor)));
 		      return *this;
+		    }
 		    /// \brief Add a section processor with stream oriented reading
 		    ///
 		    /// The first parameter is the type of the section, the second is
 		    /// a functor, which takes an \c std::istream& and an \c int&
 		    /// parameter, the latter regard to the line number of stream. The
 		    /// functor can read the input while the section go on, and the
 		    /// line number should be modified accordingly.
 		    template <typename Functor>
 		    SectionReader& sectionStream(const std::string& type, Functor functor) {
 		      LEMON_ASSERT(!type.empty(), "Type is empty.");
 		      LEMON_ASSERT(_sections.find(type) == _sections.end(),
 		                   "Multiple reading of section.");
 		      _sections.insert(std::make_pair(type,
 		         new _reader_bits::StreamSection<Functor>(functor)));
 		      return *this;
+		    }
 		    /// @}
 		  private:
 		    bool readLine() {
 		      std::string str;
 		      while(++line_num, std::getline(*_is, str)) {
 		        line.clear(); line.str(str);
 		        char c;
 		        if (line >> std::ws >> c && c != '#') {
 		          line.putback(c);
 		          return true;
+		        }
+		      }
 		      return false;
+		    }
 		    bool readSuccess() {
 		      return static_cast<bool>(*_is);
+		    }
 		    void skipSection() {
 		      char c;
 		      while (readSuccess() && line >> c && c != '@') {
 		        readLine();
+		      }
 		      if (readSuccess()) {
 		        line.putback(c);
+		      }
+		    }
 		  public:
 		    /// \name Execution of the reader
 		    /// @{
 		    /// \brief Start the batch processing
 		    ///
 		    /// This function starts the batch processing.
 		    void run() {
 		      LEMON_ASSERT(_is != 0, "This reader assigned to an other reader");
 		      std::set<std::string> extra_sections;
 		      line_num = 0;
 		      readLine();
 		      skipSection();
 		      while (readSuccess()) {
 		        try {
 		          char c;
 		          std::string section, caption;
 		          line >> c;
 		          _reader_bits::readToken(line, section);
 		          _reader_bits::readToken(line, caption);
 		          if (line >> c)
 		            throw FormatError("Extra character at the end of line");
 		          if (extra_sections.find(section) != extra_sections.end()) {
 		            std::ostringstream msg;
 		            msg << "Multiple occurence of section: " << section;
 		            throw FormatError(msg.str());
+		          }
 		          Sections::iterator it = _sections.find(section);
 		          if (it != _sections.end()) {
 		            extra_sections.insert(section);
 		            it->second->process(*_is, line_num);
+		          }
 		          readLine();
 		          skipSection();
 		        } catch (FormatError& error) {
 		          error.line(line_num);
 		          error.file(_filename);
 		          throw;
+		        }
+		      }
 		      for (Sections::iterator it = _sections.begin();
 		           it != _sections.end(); ++it) {
 		        if (extra_sections.find(it->first) == extra_sections.end()) {
 		          std::ostringstream os;
 		          os << "Cannot find section: " << it->first;
 		          throw FormatError(os.str());
+		        }
+		      }
+		    }
 		    /// @}
 		  };
 		  /// \brief Return a \ref SectionReader class
 		  ///
 		  /// This function just returns a \ref SectionReader class.
 		  /// \relates SectionReader
 		  inline SectionReader sectionReader(std::istream& is) {
 		    SectionReader tmp(is);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref SectionReader class
 		  ///
 		  /// This function just returns a \ref SectionReader class.
 		  /// \relates SectionReader
 		  inline SectionReader sectionReader(const std::string& fn) {
 		    SectionReader tmp(fn);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref SectionReader class
 		  ///
 		  /// This function just returns a \ref SectionReader class.
 		  /// \relates SectionReader
 		  inline SectionReader sectionReader(const char* fn) {
 		    SectionReader tmp(fn);
 		    return tmp;
+		  }
 		  /// \ingroup lemon_io
 		  ///
 		  /// \brief Reader for the contents of the \ref lgf-format "LGF" file
 		  ///
 		  /// This class can be used to read the sections, the map names and
 		  /// the attributes from a file. Usually, the LEMON programs know
 		  /// that, which type of graph, which maps and which attributes
 		  /// should be read from a file, but in general tools (like glemon)
 		  /// the contents of an LGF file should be guessed somehow. This class
 		  /// reads the graph and stores the appropriate information for
 		  /// reading the graph.
 		  ///
 		  ///\code
 		  /// LgfContents contents("graph.lgf");
 		  /// contents.run();
 		  ///
 		  /// // Does it contain any node section and arc section?
 		  /// if (contents.nodeSectionNum() == 0 || contents.arcSectionNum()) {
 		  ///   std::cerr << "Failure, cannot find graph." << std::endl;
 		  ///   return -1;
 		  /// }
 		  /// std::cout << "The name of the default node section: "
 		  ///           << contents.nodeSection(0) << std::endl;
 		  /// std::cout << "The number of the arc maps: "
 		  ///           << contents.arcMaps(0).size() << std::endl;
 		  /// std::cout << "The name of second arc map: "
 		  ///           << contents.arcMaps(0)[1] << std::endl;
 		  ///\endcode
 		  class LgfContents {
 		  private:
 		    std::istream* _is;
 		    bool local_is;
 		    std::vector<std::string> _node_sections;

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