LEMON/LEMON-main Changeset - r517:2b6d5d22bb23

Repositories » LEMON » LEMON-main

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

Changeset - r517:2b6d5d22bb23

« 499:b1ef32
« 495:dab9e6

518:8668e1 »

r517:2b6d5d22bb23

Fri, 20 Feb 2009 22:37:19

[Not Reviewed]

0 comments (0 inline)

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

Merge

0 12 0

merge default

11 files changed with 255 insertions and 403 deletions:

.hgignore

CMakeLists.txt

configure.ac

lemon/bits/default_map.h

lemon/bits/windows.cc

lemon/config.h.cmake

lemon/config.h.in

lemon/lgf_reader.h

lemon/lgf_writer.h

lemon/path.h

lemon/random.h

lemon/tolerance.h

219

↑ Collapse diff ↑

.hgignore

Show inline comments

 		syntax: glob
 		*.obj
 		*.orig
 		*.rej
 		*~
 		*.o
 		*.log
 		*.lo
 		*.tar.*
 		*.bak
 		Makefile.in
 		aclocal.m4
 		config.h.in
 		configure
 		Makefile
 		config.h
 		config.log
 		config.status
 		libtool
 		stamp-h1
 		lemon/lemon.pc
 		lemon/libemon.la
 		lemon/stamp-h2
 		doc/Doxyfile
 		cmake/cmake.version
 		.dirstamp
 		.libs/*
 		.deps/*
 		demo/*.eps
 		m4/libtool.m4
 		m4/ltoptions.m4
 		m4/ltsugar.m4
 		m4/ltversion.m4
 		m4/lt~obsolete.m4
 		syntax: regexp
 		(.*/)?\#[^/]*\#$
 		(.*/)?\.\#[^/]*$
 		^doc/html/.*
 		^doc/.*\.tag
 		^autom4te.cache/.*
 		^build-aux/.*
 		^.*objs.*/.*
 		^test/[a-z_]*$
 		^tools/[a-z-_]*$
 		^demo/.*_demo$
 		^.*build.*/.*
 		^doc/gen-images/.*
 		CMakeFiles
 		DartTestfile.txt
 		cmake_install.cmake
 		CMakeCache.txt

CMakeLists.txt

Show inline comments

 		CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
 		IF(EXISTS ${CMAKE_SOURCE_DIR}/cmake/version.cmake)
 		  INCLUDE(${CMAKE_SOURCE_DIR}/cmake/version.cmake)
 		ELSE(EXISTS ${CMAKE_SOURCE_DIR}/cmake/version.cmake)
 		  SET(PROJECT_NAME "LEMON")
 		  SET(PROJECT_VERSION "hg-tip" CACHE STRING "LEMON version string.")
 		ENDIF(EXISTS ${CMAKE_SOURCE_DIR}/cmake/version.cmake)
 		PROJECT(${PROJECT_NAME})
 		SET(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake)
 		INCLUDE(FindDoxygen)
 		INCLUDE(FindGhostscript)
 		FIND_PACKAGE(GLPK 4.33)
 		ADD_DEFINITIONS(-DHAVE_CONFIG_H)
 		IF(MSVC)
 		  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4250 /wd4355 /wd4800 /wd4996")
 		# Suppressed warnings:
 		# C4250: 'class1' : inherits 'class2::member' via dominance
 		# C4355: 'this' : used in base member initializer list
 		# C4800: 'type' : forcing value to bool 'true' or 'false' (performance warning)
 		# C4996: 'function': was declared deprecated
 		ENDIF(MSVC)
 		IF(GLPK_FOUND)
 		  SET(HAVE_LP TRUE)
 		  SET(HAVE_MIP TRUE)
 		  SET(HAVE_GLPK TRUE)
 		ENDIF(GLPK_FOUND)
 		INCLUDE(CheckTypeSize)
 		CHECK_TYPE_SIZE("long long" LONG_LONG)
 		ENABLE_TESTING()
 		ADD_SUBDIRECTORY(lemon)
 		ADD_SUBDIRECTORY(demo)
 		ADD_SUBDIRECTORY(doc)
 		ADD_SUBDIRECTORY(test)
 		IF(WIN32)
 		  SET(CPACK_PACKAGE_NAME ${PROJECT_NAME})
 		  SET(CPACK_PACKAGE_VENDOR "EGRES")
 		  SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY
 		    "LEMON - Library of Efficient Models and Optimization in Networks")
 		  SET(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_SOURCE_DIR}/LICENSE")
 		  SET(CPACK_PACKAGE_VERSION ${PROJECT_VERSION})
 		  SET(CPACK_PACKAGE_INSTALL_DIRECTORY
 		    "${PROJECT_NAME} ${PROJECT_VERSION}")
 		  SET(CPACK_PACKAGE_INSTALL_REGISTRY_KEY
 		    "${PROJECT_NAME} ${PROJECT_VERSION}")
 		  SET(CPACK_COMPONENTS_ALL headers library html_documentation)
 		  SET(CPACK_COMPONENT_HEADERS_DISPLAY_NAME "C++ headers")
 		  SET(CPACK_COMPONENT_LIBRARY_DISPLAY_NAME "Dynamic-link library")
 		  SET(CPACK_COMPONENT_HTML_DOCUMENTATION_DISPLAY_NAME "HTML documentation")
 		  SET(CPACK_COMPONENT_HEADERS_DESCRIPTION
 		    "C++ header files")
 		  SET(CPACK_COMPONENT_LIBRARY_DESCRIPTION
 		    "DLL and import library")
 		  SET(CPACK_COMPONENT_HTML_DOCUMENTATION_DESCRIPTION
 		    "Doxygen generated documentation")
 		  SET(CPACK_COMPONENT_HEADERS_DEPENDS library)
 		  SET(CPACK_COMPONENT_HEADERS_GROUP "Development")
 		  SET(CPACK_COMPONENT_LIBRARY_GROUP "Development")
 		  SET(CPACK_COMPONENT_HTML_DOCUMENTATION_GROUP "Documentation")
 		  SET(CPACK_COMPONENT_GROUP_DEVELOPMENT_DESCRIPTION
 		    "Components needed to develop software using LEMON")
 		  SET(CPACK_COMPONENT_GROUP_DOCUMENTATION_DESCRIPTION
 		    "Documentation of LEMON")
 		  SET(CPACK_ALL_INSTALL_TYPES Full Developer)
 		  SET(CPACK_COMPONENT_HEADERS_INSTALL_TYPES Developer Full)
 		  SET(CPACK_COMPONENT_LIBRARY_INSTALL_TYPES Developer Full)
 		  SET(CPACK_COMPONENT_HTML_DOCUMENTATION_INSTALL_TYPES Full)
 		  SET(CPACK_GENERATOR "NSIS")
 		  SET(CPACK_NSIS_MUI_ICON "${CMAKE_SOURCE_DIR}/cmake/nsis/lemon.ico")
 		  SET(CPACK_NSIS_MUI_UNIICON "${CMAKE_SOURCE_DIR}/cmake/nsis/uninstall.ico")
 		  #SET(CPACK_PACKAGE_ICON "${CMAKE_SOURCE_DIR}/cmake/nsis\\\\installer.bmp")
 		  SET(CPACK_NSIS_INSTALLED_ICON_NAME "bin\\\\lemon.ico")
 		  SET(CPACK_NSIS_DISPLAY_NAME "${CPACK_PACKAGE_INSTALL_DIRECTORY} ${PROJECT_NAME}")
 		  SET(CPACK_NSIS_HELP_LINK "http:\\\\\\\\lemon.cs.elte.hu")
 		  SET(CPACK_NSIS_URL_INFO_ABOUT "http:\\\\\\\\lemon.cs.elte.hu")
 		  SET(CPACK_NSIS_CONTACT "lemon-user@lemon.cs.elte.hu")
 		  SET(CPACK_NSIS_CREATE_ICONS_EXTRA "
 		    CreateShortCut \\\"$SMPROGRAMS\\\\$STARTMENU_FOLDER\\\\Documentation.lnk\\\" \\\"$INSTDIR\\\\doc\\\\index.html\\\"
 		    ")
 		  SET(CPACK_NSIS_DELETE_ICONS_EXTRA "
 		    !insertmacro MUI_STARTMENU_GETFOLDER Application $MUI_TEMP
 		    Delete \\\"$SMPROGRAMS\\\\$MUI_TEMP\\\\Documentation.lnk\\\"
 		    ")
 		  INCLUDE(CPack)
 		ENDIF(WIN32)

configure.ac

Show inline comments

 		dnl Process this file with autoconf to produce a configure script.
 		dnl Version information.
 		m4_define([lemon_version_number],
 			[m4_normalize(esyscmd([echo ${LEMON_VERSION}]))])
 		dnl m4_define([lemon_version_number], [])
 		m4_define([lemon_hg_path], [m4_normalize(esyscmd([./scripts/chg-len.py]))])
 		m4_define([lemon_hg_revision], [m4_normalize(esyscmd([hg id -i]))])
 		m4_define([lemon_version], [ifelse(lemon_version_number(),
 					   [],
 					   [lemon_hg_path().lemon_hg_revision()],
 					   [lemon_version_number()])])
 		AC_PREREQ([2.59])
 		AC_INIT([LEMON], [lemon_version()], [lemon-user@lemon.cs.elte.hu], [lemon])
 		AC_CONFIG_AUX_DIR([build-aux])
 		AC_CONFIG_MACRO_DIR([m4])
 		AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects nostdinc])
 		AC_CONFIG_SRCDIR([lemon/list_graph.h])
 		AC_CONFIG_HEADERS([config.h lemon/config.h])
 		dnl Do compilation tests using the C++ compiler.
 		AC_LANG([C++])
 		dnl Check the existence of long long type.
 		AC_CHECK_TYPE(long long, [long_long_found=yes], [long_long_found=no])
 		if test x"$long_long_found" = x"yes"; then
 		  AC_DEFINE([HAVE_LONG_LONG], [1], [Define to 1 if you have long long.])
 		fi
 		dnl Checks for programs.
 		AC_PROG_CXX
 		AC_PROG_CXXCPP
 		AC_PROG_INSTALL
 		AC_DISABLE_SHARED
 		AC_PROG_LIBTOOL
 		AC_CHECK_PROG([doxygen_found],[doxygen],[yes],[no])
 		AC_CHECK_PROG([gs_found],[gs],[yes],[no])
 		dnl Detect Intel compiler.
 		AC_MSG_CHECKING([whether we are using the Intel C++ compiler])
 		AC_COMPILE_IFELSE([#ifndef __INTEL_COMPILER
 		choke me
 		#endif], [ICC=[yes]], [ICC=[no]])
 		if test x"$ICC" = x"yes"; then
 		  AC_MSG_RESULT([yes])
 		else
 		  AC_MSG_RESULT([no])
 		fi
 		dnl Set custom compiler flags when using g++.
 		if test "$GXX" = yes -a "$ICC" = no; then
 		  WARNINGCXXFLAGS="-Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas"
 		fi
 		AC_SUBST([WARNINGCXXFLAGS])
 		dnl Checks for libraries.
 		LX_CHECK_GLPK
 		LX_CHECK_CPLEX
 		LX_CHECK_SOPLEX
 		LX_CHECK_CLP
 		AM_CONDITIONAL([HAVE_LP], [test x"$lx_lp_found" = x"yes"])
 		AM_CONDITIONAL([HAVE_MIP], [test x"$lx_mip_found" = x"yes"])
 		dnl Disable/enable building the demo programs.
 		AC_ARG_ENABLE([demo],
 		AS_HELP_STRING([--enable-demo], [build the demo programs])
 		AS_HELP_STRING([--disable-demo], [do not build the demo programs @<:@default@:>@]),
 		              [], [enable_demo=no])
 		AC_MSG_CHECKING([whether to build the demo programs])
 		if test x"$enable_demo" != x"no"; then
 		  AC_MSG_RESULT([yes])
 		else
 		  AC_MSG_RESULT([no])
 		fi
 		AM_CONDITIONAL([WANT_DEMO], [test x"$enable_demo" != x"no"])
 		dnl Disable/enable building the binary tools.
 		AC_ARG_ENABLE([tools],
 		AS_HELP_STRING([--enable-tools], [build additional tools @<:@default@:>@])
 		AS_HELP_STRING([--disable-tools], [do not build additional tools]),
 		              [], [enable_tools=yes])
 		AC_MSG_CHECKING([whether to build the additional tools])
 		if test x"$enable_tools" != x"no"; then
 		  AC_MSG_RESULT([yes])
 		else
 		  AC_MSG_RESULT([no])
 		fi
 		AM_CONDITIONAL([WANT_TOOLS], [test x"$enable_tools" != x"no"])
 		dnl Checks for header files.
 		AC_CHECK_HEADERS(limits.h sys/time.h sys/times.h unistd.h)
 		dnl Checks for typedefs, structures, and compiler characteristics.
 		AC_C_CONST
 		AC_C_INLINE
 		AC_TYPE_SIZE_T
 		AC_HEADER_TIME
 		AC_STRUCT_TM
 		dnl Checks for library functions.
 		AC_HEADER_STDC
 		AC_CHECK_FUNCS(gettimeofday times ctime_r)
 		dnl Add dependencies on files generated by configure.
 		AC_SUBST([CONFIG_STATUS_DEPENDENCIES],
 		  ['$(top_srcdir)/doc/Doxyfile.in $(top_srcdir)/lemon/lemon.pc.in $(top_srcdir)/cmake/version.cmake.in'])
 		AC_CONFIG_FILES([
 		Makefile
 		cmake/version.cmake
 		doc/Doxyfile
 		lemon/lemon.pc
 		])
 		AC_OUTPUT
 		echo
 		echo '****************************** SUMMARY ******************************'
 		echo
 		echo Package version............... : $PACKAGE-$VERSION
 		echo
 		echo C++ compiler.................. : $CXX
 		echo C++ compiles flags............ : $WARNINGCXXFLAGS $CXXFLAGS
 		echo
 		echo Compiler supports long long... : $long_long_found
 		echo
 		echo GLPK support.................. : $lx_glpk_found
 		echo CPLEX support................. : $lx_cplex_found
 		echo SOPLEX support................ : $lx_soplex_found
 		echo CLP support................... : $lx_clp_found
 		echo
 		echo Build demo programs........... : $enable_demo
 		echo Build additional tools........ : $enable_tools
 		echo
 		echo The packace will be installed in
 		echo -n '  '
 		echo $prefix.
 		echo
 		echo '*********************************************************************'
 		echo
 		echo Configure complete, now type \'make\' and then \'make install\'.
 		echo

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-2009
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_BITS_DEFAULT_MAP_H
 		#define LEMON_BITS_DEFAULT_MAP_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 __GNUC__ && !defined __STRICT_ANSI__
+		#if defined 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/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
 		 * 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);
 		#if defined(_MSC_VER) && (_MSC_VER < 1500)
 		      LPWSTR buf1, buf2, buf3;
 		      if (GetDateFormat(LOCALE_USER_DEFAULT, 0, &time,
 		                        L"ddd MMM dd", buf1, 11) &&
 		          GetTimeFormat(LOCALE_USER_DEFAULT, 0, &time,
 		                        L"HH':'mm':'ss", buf2, 9) &&
 		          GetDateFormat(LOCALE_USER_DEFAULT, 0, &time,
 		                        L"yyyy", buf3, 5)) {
 		      char buf1[11], buf2[9], buf3[5];
 			  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
 		      char buf1[11], buf2[9], buf3[5];
 		      if (GetDateFormat(LOCALE_USER_DEFAULT, 0, &time,
 		                        "ddd MMM dd", buf1, 11) &&
 		          GetTimeFormat(LOCALE_USER_DEFAULT, 0, &time,
 		                        "HH':'mm':'ss", buf2, 9) &&
 		          GetDateFormat(LOCALE_USER_DEFAULT, 0, &time,
 		                        "yyyy", buf3, 5)) {
 		        os << buf1 << ' ' << buf2 << ' ' << buf3;
+		      }
 		#endif
 		      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/config.h.cmake

Show inline comments

 		#cmakedefine HAVE_LP 1
 		#cmakedefine HAVE_MIP 1
-		#cmakedefine HAVE_GLPK 1
+		#cmakedefine HAVE_LONG_LONG 1
 		#cmakedefine HAVE_LP 1
 		#cmakedefine HAVE_MIP 1
 		#cmakedefine HAVE_GLPK 1

lemon/config.h.in

Show inline comments

 		/* Define to 1 if you have long long */
 		#undef HAVE_LONG_LONG
 		/* Define to 1 if you have any LP solver. */
 		#undef HAVE_LP
 		/* Define to 1 if you have any MIP solver. */
 		#undef HAVE_MIP
 		/* Define to 1 if you have CPLEX. */
 		#undef HAVE_CPLEX
 		/* Define to 1 if you have GLPK. */
 		#undef HAVE_GLPK
 		/* Define to 1 if you have SOPLEX */
 		#undef HAVE_SOPLEX
 		/* Define to 1 if you have CLP */
 		#undef HAVE_CLP

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-2009
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		///\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;
 		  /// \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 = std::cin) {
 		    DigraphReader<Digraph> tmp(digraph, is);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref DigraphReader class
 		  ///
 		  /// This function just returns a \ref DigraphReader class.
 		  /// \relates DigraphReader
 		  DigraphReader<Digraph> digraphReader(Digraph& digraph,
 		                                       std::istream& is = std::cin);
 		  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
 		  DigraphReader<Digraph> digraphReader(Digraph& digraph, const std::string& fn);
 		  template <typename Digraph>
 		  DigraphReader<Digraph> digraphReader(Digraph& digraph, const char* fn) {
 		    DigraphReader<Digraph> tmp(digraph, fn);
 		    return tmp;
+		  }
 		  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:
 		    friend DigraphReader<Digraph> digraphReader<>(Digraph& digraph,
 		                                                  std::istream& is);
 		    friend DigraphReader<Digraph> digraphReader<>(Digraph& digraph,
 		                                                  const std::string& fn);
 		    friend DigraphReader<Digraph> digraphReader<>(Digraph& digraph,
 		                                                  const char *fn);
 		    template <typename DGR>
 		    friend DigraphReader<DGR> digraphReader(DGR& digraph, std::istream& is);
 		    template <typename DGR>
 		    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 (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;
 		  /// \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 = std::cin) {
 		    GraphReader<Graph> tmp(graph, is);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref GraphReader class
 		  ///
 		  /// This function just returns a \ref GraphReader class.
-		  /// \relates GraphReader
+		  GraphReader<Graph> graphReader(Graph& graph,
 		                                 std::istream& is = std::cin);
 		  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
+		  GraphReader<Graph> graphReader(Graph& graph, const std::string& fn);
 		  template <typename Graph>
 		  GraphReader<Graph> graphReader(Graph& graph, const char* fn) {
 		    GraphReader<Graph> tmp(graph, fn);
 		    return tmp;
+		  }
 		  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:
 		    friend GraphReader<Graph> graphReader<>(Graph& graph, std::istream& is);
 		    friend GraphReader<Graph> graphReader<>(Graph& graph,
 		                                            const std::string& fn);
 		    friend GraphReader<Graph> graphReader<>(Graph& graph, const char *fn);
 		    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);
 		    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 (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;
 		    std::vector<std::string> _edge_sections;
 		    std::vector<std::string> _attribute_sections;
 		    std::vector<std::string> _extra_sections;
 		    std::vector<bool> _arc_sections;
 		    std::vector<std::vector<std::string> > _node_maps;
 		    std::vector<std::vector<std::string> > _edge_maps;
 		    std::vector<std::vector<std::string> > _attributes;
 		    int line_num;
 		    std::istringstream line;
 		  public:
 		    /// \brief Constructor
 		    ///
 		    /// Construct an \e LGF contents reader, which reads from the given
 		    /// input stream.
 		    LgfContents(std::istream& is)
 		      : _is(&is), local_is(false) {}
 		    /// \brief Constructor
 		    ///
 		    /// Construct an \e LGF contents reader, which reads from the given
 		    /// file.
 		    LgfContents(const std::string& fn)
 		      : _is(new std::ifstream(fn.c_str())), local_is(true) {
 		      if (!(*_is)) {
 		        delete _is;
 		        throw IoError("Cannot open file", fn);
+		      }
+		    }
 		    /// \brief Constructor
 		    ///
 		    /// Construct an \e LGF contents reader, which reads from the given
 		    /// file.
 		    LgfContents(const char* fn)
 		      : _is(new std::ifstream(fn)), local_is(true) {
 		      if (!(*_is)) {
 		        delete _is;
 		        throw IoError("Cannot open file", fn);
+		      }
+		    }
 		    /// \brief Destructor
 		    ~LgfContents() {
 		      if (local_is) delete _is;
+		    }
 		  private:
 		    LgfContents(const LgfContents&);
 		    LgfContents& operator=(const LgfContents&);
 		  public:
 		    /// \name Node sections
 		    /// @{
 		    /// \brief Gives back the number of node sections in the file.
 		    ///
 		    /// Gives back the number of node sections in the file.
 		    int nodeSectionNum() const {
 		      return _node_sections.size();
+		    }
 		    /// \brief Returns the node section name at the given position.
 		    ///
 		    /// Returns the node section name at the given position.
 		    const std::string& nodeSection(int i) const {
 		      return _node_sections[i];
+		    }
 		    /// \brief Gives back the node maps for the given section.
 		    ///
 		    /// Gives back the node maps for the given section.
 		    const std::vector<std::string>& nodeMapNames(int i) const {
 		      return _node_maps[i];
+		    }
 		    /// @}
 		    /// \name Arc/Edge sections
 		    /// @{
 		    /// \brief Gives back the number of arc/edge sections in the file.
 		    ///
 		    /// Gives back the number of arc/edge sections in the file.
 		    /// \note It is synonym of \c edgeSectionNum().
 		    int arcSectionNum() const {
 		      return _edge_sections.size();
+		    }
 		    /// \brief Returns the arc/edge section name at the given position.
 		    ///
 		    /// Returns the arc/edge section name at the given position.
 		    /// \note It is synonym of \c edgeSection().
 		    const std::string& arcSection(int i) const {
 		      return _edge_sections[i];
+		    }
 		    /// \brief Gives back the arc/edge maps for the given section.
 		    ///
 		    /// Gives back the arc/edge maps for the given section.
 		    /// \note It is synonym of \c edgeMapNames().
 		    const std::vector<std::string>& arcMapNames(int i) const {
 		      return _edge_maps[i];
+		    }
 		    /// @}
 		    /// \name Synonyms
 		    /// @{
 		    /// \brief Gives back the number of arc/edge sections in the file.
 		    ///
 		    /// Gives back the number of arc/edge sections in the file.
 		    /// \note It is synonym of \c arcSectionNum().
 		    int edgeSectionNum() const {
 		      return _edge_sections.size();
+		    }
 		    /// \brief Returns the section name at the given position.
 		    ///
 		    /// Returns the section name at the given position.
 		    /// \note It is synonym of \c arcSection().
 		    const std::string& edgeSection(int i) const {
 		      return _edge_sections[i];
+		    }
 		    /// \brief Gives back the edge maps for the given section.
 		    ///
 		    /// Gives back the edge maps for the given section.
 		    /// \note It is synonym of \c arcMapNames().
 		    const std::vector<std::string>& edgeMapNames(int i) const {
 		      return _edge_maps[i];
+		    }
 		    /// @}
 		    /// \name Attribute sections
 		    /// @{
 		    /// \brief Gives back the number of attribute sections in the file.
 		    ///
 		    /// Gives back the number of attribute sections in the file.
 		    int attributeSectionNum() const {
 		      return _attribute_sections.size();
+		    }
 		    /// \brief Returns the attribute section name at the given position.
 		    ///
 		    /// Returns the attribute section name at the given position.
 		    const std::string& attributeSectionNames(int i) const {
 		      return _attribute_sections[i];
+		    }
 		    /// \brief Gives back the attributes for the given section.
 		    ///
 		    /// Gives back the attributes for the given section.
 		    const std::vector<std::string>& attributes(int i) const {
 		      return _attributes[i];
+		    }
 		    /// @}
 		    /// \name Extra sections
 		    /// @{
 		    /// \brief Gives back the number of extra sections in the file.
 		    ///
 		    /// Gives back the number of extra sections in the file.
 		    int extraSectionNum() const {
 		      return _extra_sections.size();
+		    }
 		    /// \brief Returns the extra section type at the given position.
 		    ///
 		    /// Returns the section type at the given position.
 		    const std::string& extraSection(int i) const {
 		      return _extra_sections[i];
+		    }
 		    /// @}
 		  private:
 		    bool readLine() {
 		      std::string str;
 		      while(++line_num, std::getline(*_is, str)) {
 		        line.clear(); line.str(str);
 		        char c;

lemon/lgf_writer.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2009
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		///\ingroup lemon_io
 		///\file
 		///\brief \ref lgf-format "LEMON Graph Format" writer.
 		#ifndef LEMON_LGF_WRITER_H
 		#define LEMON_LGF_WRITER_H
 		#include <iostream>
 		#include <fstream>
 		#include <sstream>
 		#include <algorithm>
 		#include <vector>
 		#include <functional>
 		#include <lemon/core.h>
 		#include <lemon/maps.h>
 		#include <lemon/concept_check.h>
 		#include <lemon/concepts/maps.h>
 		namespace lemon {
 		  namespace _writer_bits {
 		    template <typename Value>
 		    struct DefaultConverter {
 		      std::string operator()(const Value& value) {
 		        std::ostringstream os;
 		        os << value;
 		        return os.str();
+		      }
 		    };
 		    template <typename T>
 		    bool operator<(const T&, const T&) {
 		      throw FormatError("Label map is not comparable");
+		    }
 		    template <typename _Map>
 		    class MapLess {
 		    public:
 		      typedef _Map Map;
 		      typedef typename Map::Key Item;
 		    private:
 		      const Map& _map;
 		    public:
 		      MapLess(const Map& map) : _map(map) {}
 		      bool operator()(const Item& left, const Item& right) {
 		        return _map[left] < _map[right];
+		      }
 		    };
 		    template <typename _Graph, bool _dir, typename _Map>
 		    class GraphArcMapLess {
 		    public:
 		      typedef _Map Map;
 		      typedef _Graph Graph;
 		      typedef typename Graph::Edge Item;
 		    private:
 		      const Graph& _graph;
 		      const Map& _map;
 		    public:
 		      GraphArcMapLess(const Graph& graph, const Map& map)
 		        : _graph(graph), _map(map) {}
 		      bool operator()(const Item& left, const Item& right) {
 		        return _map[_graph.direct(left, _dir)] <
 		          _map[_graph.direct(right, _dir)];
+		      }
 		    };
 		    template <typename _Item>
 		    class MapStorageBase {
 		    public:
 		      typedef _Item Item;
 		    public:
 		      MapStorageBase() {}
 		      virtual ~MapStorageBase() {}
 		      virtual std::string get(const Item& item) = 0;
 		      virtual void sort(std::vector<Item>&) = 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:
 		      const Map& _map;
 		      Converter _converter;
 		    public:
 		      MapStorage(const Map& map, const Converter& converter = Converter())
 		        : _map(map), _converter(converter) {}
 		      virtual ~MapStorage() {}
 		      virtual std::string get(const Item& item) {
 		        return _converter(_map[item]);
+		      }
 		      virtual void sort(std::vector<Item>& items) {
 		        MapLess<Map> less(_map);
 		        std::sort(items.begin(), items.end(), less);
+		      }
 		    };
 		    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;
 		      const Map& _map;
 		      Converter _converter;
 		    public:
 		      GraphArcMapStorage(const Graph& graph, const Map& map,
 		                         const Converter& converter = Converter())
 		        : _graph(graph), _map(map), _converter(converter) {}
 		      virtual ~GraphArcMapStorage() {}
 		      virtual std::string get(const Item& item) {
 		        return _converter(_map[_graph.direct(item, dir)]);
+		      }
 		      virtual void sort(std::vector<Item>& items) {
 		        GraphArcMapLess<Graph, dir, Map> less(_graph, _map);
 		        std::sort(items.begin(), items.end(), less);
+		      }
 		    };
 		    class ValueStorageBase {
 		    public:
 		      ValueStorageBase() {}
 		      virtual ~ValueStorageBase() {}
 		      virtual std::string get() = 0;
 		    };
 		    template <typename _Value, typename _Converter = DefaultConverter<_Value> >
 		    class ValueStorage : public ValueStorageBase {
 		    public:
 		      typedef _Value Value;
 		      typedef _Converter Converter;
 		    private:
 		      const Value& _value;
 		      Converter _converter;
 		    public:
 		      ValueStorage(const Value& value, const Converter& converter = Converter())
 		        : _value(value), _converter(converter) {}
 		      virtual std::string get() {
 		        return _converter(_value);
+		      }
 		    };
 		    template <typename Value>
 		    struct MapLookUpConverter {
 		      const std::map<Value, std::string>& _map;
 		      MapLookUpConverter(const std::map<Value, std::string>& map)
 		        : _map(map) {}
 		      std::string operator()(const Value& str) {
 		        typename std::map<Value, std::string>::const_iterator it =
 		          _map.find(str);
 		        if (it == _map.end()) {
 		          throw FormatError("Item not found");
+		        }
 		        return it->second;
+		      }
 		    };
 		    template <typename Graph>
 		    struct GraphArcLookUpConverter {
 		      const Graph& _graph;
 		      const std::map<typename Graph::Edge, std::string>& _map;
 		      GraphArcLookUpConverter(const Graph& graph,
 		                              const std::map<typename Graph::Edge,
 		                                             std::string>& map)
 		        : _graph(graph), _map(map) {}
 		      std::string operator()(const typename Graph::Arc& val) {
 		        typename std::map<typename Graph::Edge, std::string>
 		          ::const_iterator it = _map.find(val);
 		        if (it == _map.end()) {
 		          throw FormatError("Item not found");
+		        }
 		        return (_graph.direction(val) ? '+' : '-') + it->second;
+		      }
 		    };
 		    inline bool isWhiteSpace(char c) {
 		      return c == ' ' || c == '\t' || c == '\v' ||
 		        c == '\n' || c == '\r' || c == '\f';
+		    }
 		    inline bool isEscaped(char c) {
 		      return c == '\\' || c == '\"' || c == '\'' ||
 		        c == '\a' || c == '\b';
+		    }
 		    inline static void writeEscape(std::ostream& os, char c) {
 		      switch (c) {
 		      case '\\':
 		        os << "\\\\";
 		        return;
 		      case '\"':
 		        os << "\\\"";
 		        return;
 		      case '\a':
 		        os << "\\a";
 		        return;
 		      case '\b':
 		        os << "\\b";
 		        return;
 		      case '\f':
 		        os << "\\f";
 		        return;
 		      case '\r':
 		        os << "\\r";
 		        return;
 		      case '\n':
 		        os << "\\n";
 		        return;
 		      case '\t':
 		        os << "\\t";
 		        return;
 		      case '\v':
 		        os << "\\v";
 		        return;
 		      default:
 		        if (c < 0x20) {
 		          std::ios::fmtflags flags = os.flags();
 		          os << '\\' << std::oct << static_cast<int>(c);
 		          os.flags(flags);
 		        } else {
 		          os << c;
+		        }
 		        return;
+		      }
+		    }
 		    inline bool requireEscape(const std::string& str) {
 		      if (str.empty() || str[0] == '@') return true;
 		      std::istringstream is(str);
 		      char c;
 		      while (is.get(c)) {
 		        if (isWhiteSpace(c) || isEscaped(c)) {
 		          return true;
+		        }
+		      }
 		      return false;
+		    }
 		    inline std::ostream& writeToken(std::ostream& os, const std::string& str) {
 		      if (requireEscape(str)) {
 		        os << '\"';
 		        for (std::string::const_iterator it = str.begin();
 		             it != str.end(); ++it) {
 		          writeEscape(os, *it);
+		        }
 		        os << '\"';
 		      } else {
 		        os << str;
+		      }
 		      return os;
+		    }
 		    class Section {
 		    public:
 		      virtual ~Section() {}
 		      virtual void process(std::ostream& os) = 0;
 		    };
 		    template <typename Functor>
 		    class LineSection : public Section {
 		    private:
 		      Functor _functor;
 		    public:
 		      LineSection(const Functor& functor) : _functor(functor) {}
 		      virtual ~LineSection() {}
 		      virtual void process(std::ostream& os) {
 		        std::string line;
 		        while (!(line = _functor()).empty()) os << line << std::endl;
+		      }
 		    };
 		    template <typename Functor>
 		    class StreamSection : public Section {
 		    private:
 		      Functor _functor;
 		    public:
 		      StreamSection(const Functor& functor) : _functor(functor) {}
 		      virtual ~StreamSection() {}
 		      virtual void process(std::ostream& os) {
 		        _functor(os);
+		      }
 		    };
+		  }
 		  template <typename Digraph>
 		  class DigraphWriter;
 		  /// \brief Return a \ref DigraphWriter class
 		  ///
 		  /// This function just returns a \ref DigraphWriter class.
 		  /// \relates DigraphWriter
 		  template <typename Digraph>
 		  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
 		                                       std::ostream& os = std::cout) {
 		    DigraphWriter<Digraph> tmp(digraph, os);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref DigraphWriter class
 		  ///
 		  /// This function just returns a \ref DigraphWriter class.
-		  /// \relates DigraphWriter
+		                                       std::ostream& os = std::cout);
 		  template <typename Digraph>
 		  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
 		                                       const std::string& fn) {
 		    DigraphWriter<Digraph> tmp(digraph, fn);
 		    return tmp;
+		  }
 		                                       const std::string& fn);
 		  /// \brief Return a \ref DigraphWriter class
 		  ///
 		  /// This function just returns a \ref DigraphWriter class.
 		  /// \relates DigraphWriter
 		  template <typename Digraph>
 		  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
 		                                       const char* fn) {
 		    DigraphWriter<Digraph> tmp(digraph, fn);
 		    return tmp;
+		  }
 		                                       const char* fn);
 		  /// \ingroup lemon_io
 		  ///
 		  /// \brief \ref lgf-format "LGF" writer for directed graphs
 		  ///
 		  /// This utility writes an \ref lgf-format "LGF" file.
 		  ///
 		  /// The writing method does a batch processing. The user creates a
 		  /// writer object, then various writing rules can be added to the
 		  /// writer, and eventually the writing is executed with the \c run()
 		  /// member function. A map writing rule can be added to the writer
 		  /// with the \c nodeMap() or \c arcMap() members. An optional
 		  /// converter parameter can also be added as a standard functor
 		  /// converting from the value type of the map to \c std::string. If it
 		  /// is set, it will determine how the value type of the map is written to
 		  /// the output stream. If the functor is not set, then a default
 		  /// conversion will be used. The \c attribute(), \c node() and \c
 		  /// arc() functions are used to add attribute writing rules.
 		  ///
 		  ///\code
 		  /// DigraphWriter<Digraph>(digraph, std::cout).
 		  ///   nodeMap("coordinates", coord_map).
 		  ///   nodeMap("size", size).
 		  ///   nodeMap("title", title).
 		  ///   arcMap("capacity", cap_map).
 		  ///   node("source", src).
 		  ///   node("target", trg).
 		  ///   attribute("caption", caption).
 		  ///   run();
 		  ///\endcode
 		  ///
 		  ///
 		  /// By default, the writer does not write additional captions to the
 		  /// sections, but they can be give as an optional parameter of
 		  /// the \c nodes(), \c arcs() or \c
 		  /// attributes() functions.
 		  ///
 		  /// The \c skipNodes() and \c skipArcs() functions forbid the
 		  /// writing of the sections. If two arc sections should be written
 		  /// to the output, it can be done in two passes, the first pass
 		  /// writes the node section and the first arc section, then the
 		  /// second pass skips the node section and writes just the arc
 		  /// section to the stream. The output stream can be retrieved with
 		  /// the \c ostream() function, hence the second pass can append its
 		  /// output to the output of the first pass.
 		  template <typename _Digraph>
 		  class DigraphWriter {
 		  public:
 		    typedef _Digraph Digraph;
 		    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
 		  private:
 		    std::ostream* _os;
 		    bool local_os;
 		    const Digraph& _digraph;
 		    std::string _nodes_caption;
 		    std::string _arcs_caption;
 		    std::string _attributes_caption;
 		    typedef std::map<Node, std::string> NodeIndex;
 		    NodeIndex _node_index;
 		    typedef std::map<Arc, std::string> ArcIndex;
 		    ArcIndex _arc_index;
 		    typedef std::vector<std::pair<std::string,
 		      _writer_bits::MapStorageBase<Node>* > > NodeMaps;
 		    NodeMaps _node_maps;
 		    typedef std::vector<std::pair<std::string,
 		      _writer_bits::MapStorageBase<Arc>* > >ArcMaps;
 		    ArcMaps _arc_maps;
 		    typedef std::vector<std::pair<std::string,
 		      _writer_bits::ValueStorageBase*> > Attributes;
 		    Attributes _attributes;
 		    bool _skip_nodes;
 		    bool _skip_arcs;
 		  public:
 		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph writer, which writes to the given
 		    /// output stream.
 		    DigraphWriter(const Digraph& digraph, std::ostream& os = std::cout)
 		      : _os(&os), local_os(false), _digraph(digraph),
 		        _skip_nodes(false), _skip_arcs(false) {}
 		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph writer, which writes to the given
 		    /// output file.
 		    DigraphWriter(const Digraph& digraph, const std::string& fn)
 		      : _os(new std::ofstream(fn.c_str())), local_os(true), _digraph(digraph),
 		        _skip_nodes(false), _skip_arcs(false) {
 		      if (!(*_os)) {
 		        delete _os;
 		        throw IoError("Cannot write file", fn);
+		      }
+		    }
 		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph writer, which writes to the given
 		    /// output file.
 		    DigraphWriter(const Digraph& digraph, const char* fn)
 		      : _os(new std::ofstream(fn)), local_os(true), _digraph(digraph),
 		        _skip_nodes(false), _skip_arcs(false) {
 		      if (!(*_os)) {
 		        delete _os;
 		        throw IoError("Cannot write file", fn);
+		      }
+		    }
 		    /// \brief Destructor
 		    ~DigraphWriter() {
 		      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_os) {
 		        delete _os;
+		      }
+		    }
 		  private:
 		    friend DigraphWriter<Digraph> digraphWriter<>(const Digraph& digraph,
 		                                                  std::ostream& os);
 		    friend DigraphWriter<Digraph> digraphWriter<>(const Digraph& digraph,
 		                                                  const std::string& fn);
 		    friend DigraphWriter<Digraph> digraphWriter<>(const Digraph& digraph,
 		                                                  const char *fn);
 		    template <typename DGR>
 		    friend DigraphWriter<DGR> digraphWriter(const DGR& digraph,
 		                                            std::ostream& os);
 		    template <typename DGR>
 		    friend DigraphWriter<DGR> digraphWriter(const DGR& digraph,
 		                                            const std::string& fn);
 		    template <typename DGR>
 		    friend DigraphWriter<DGR> digraphWriter(const DGR& digraph,
 		                                            const char *fn);
 		    DigraphWriter(DigraphWriter& other)
 		      : _os(other._os), local_os(other.local_os), _digraph(other._digraph),
 		        _skip_nodes(other._skip_nodes), _skip_arcs(other._skip_arcs) {
 		      other._os = 0;
 		      other.local_os = 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;
+		    }
 		    DigraphWriter& operator=(const DigraphWriter&);
 		  public:
 		    /// \name Writing rules
 		    /// @{
 		    /// \brief Node map writing rule
 		    ///
 		    /// Add a node map writing rule to the writer.
 		    template <typename Map>
 		    DigraphWriter& nodeMap(const std::string& caption, const Map& map) {
 		      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
 		      _writer_bits::MapStorageBase<Node>* storage =
 		        new _writer_bits::MapStorage<Node, Map>(map);
 		      _node_maps.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Node map writing rule
 		    ///
 		    /// Add a node map writing rule with specialized converter to the
 		    /// writer.
 		    template <typename Map, typename Converter>
 		    DigraphWriter& nodeMap(const std::string& caption, const Map& map,
 		                           const Converter& converter = Converter()) {
 		      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
 		      _writer_bits::MapStorageBase<Node>* storage =
 		        new _writer_bits::MapStorage<Node, Map, Converter>(map, converter);
 		      _node_maps.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Arc map writing rule
 		    ///
 		    /// Add an arc map writing rule to the writer.
 		    template <typename Map>
 		    DigraphWriter& arcMap(const std::string& caption, const Map& map) {
 		      checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();
 		      _writer_bits::MapStorageBase<Arc>* storage =
 		        new _writer_bits::MapStorage<Arc, Map>(map);
 		      _arc_maps.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Arc map writing rule
 		    ///
 		    /// Add an arc map writing rule with specialized converter to the
 		    /// writer.
 		    template <typename Map, typename Converter>
 		    DigraphWriter& arcMap(const std::string& caption, const Map& map,
 		                          const Converter& converter = Converter()) {
 		      checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();
 		      _writer_bits::MapStorageBase<Arc>* storage =
 		        new _writer_bits::MapStorage<Arc, Map, Converter>(map, converter);
 		      _arc_maps.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Attribute writing rule
 		    ///
 		    /// Add an attribute writing rule to the writer.
 		    template <typename Value>
 		    DigraphWriter& attribute(const std::string& caption, const Value& value) {
 		      _writer_bits::ValueStorageBase* storage =
 		        new _writer_bits::ValueStorage<Value>(value);
 		      _attributes.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Attribute writing rule
 		    ///
 		    /// Add an attribute writing rule with specialized converter to the
 		    /// writer.
 		    template <typename Value, typename Converter>
 		    DigraphWriter& attribute(const std::string& caption, const Value& value,
 		                             const Converter& converter = Converter()) {
 		      _writer_bits::ValueStorageBase* storage =
 		        new _writer_bits::ValueStorage<Value, Converter>(value, converter);
 		      _attributes.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Node writing rule
 		    ///
 		    /// Add a node writing rule to the writer.
 		    DigraphWriter& node(const std::string& caption, const Node& node) {
 		      typedef _writer_bits::MapLookUpConverter<Node> Converter;
 		      Converter converter(_node_index);
 		      _writer_bits::ValueStorageBase* storage =
 		        new _writer_bits::ValueStorage<Node, Converter>(node, converter);
 		      _attributes.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Arc writing rule
 		    ///
 		    /// Add an arc writing rule to writer.
 		    DigraphWriter& arc(const std::string& caption, const Arc& arc) {
 		      typedef _writer_bits::MapLookUpConverter<Arc> Converter;
 		      Converter converter(_arc_index);
 		      _writer_bits::ValueStorageBase* storage =
 		        new _writer_bits::ValueStorage<Arc, Converter>(arc, converter);
 		      _attributes.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \name Section captions
 		    /// @{
 		    /// \brief Add an additional caption to the \c \@nodes section
 		    ///
 		    /// Add an additional caption to the \c \@nodes section.
 		    DigraphWriter& nodes(const std::string& caption) {
 		      _nodes_caption = caption;
 		      return *this;
+		    }
 		    /// \brief Add an additional caption to the \c \@arcs section
 		    ///
 		    /// Add an additional caption to the \c \@arcs section.
 		    DigraphWriter& arcs(const std::string& caption) {
 		      _arcs_caption = caption;
 		      return *this;
+		    }
 		    /// \brief Add an additional caption to the \c \@attributes section
 		    ///
 		    /// Add an additional caption to the \c \@attributes section.
 		    DigraphWriter& attributes(const std::string& caption) {
 		      _attributes_caption = caption;
 		      return *this;
+		    }
 		    /// \name Skipping section
 		    /// @{
 		    /// \brief Skip writing the node set
 		    ///
 		    /// The \c \@nodes section will not be written to the stream.
 		    DigraphWriter& skipNodes() {
 		      LEMON_ASSERT(!_skip_nodes, "Multiple usage of skipNodes() member");
 		      _skip_nodes = true;
 		      return *this;
+		    }
 		    /// \brief Skip writing arc set
 		    ///
 		    /// The \c \@arcs section will not be written to the stream.
 		    DigraphWriter& skipArcs() {
 		      LEMON_ASSERT(!_skip_arcs, "Multiple usage of skipArcs() member");
 		      _skip_arcs = true;
 		      return *this;
+		    }
 		    /// @}
 		  private:
 		    void writeNodes() {
 		      _writer_bits::MapStorageBase<Node>* label = 0;
 		      for (typename NodeMaps::iterator it = _node_maps.begin();
 		           it != _node_maps.end(); ++it) {
 		        if (it->first == "label") {
 		          label = it->second;
 		          break;
+		        }
+		      }
 		      *_os << "@nodes";
 		      if (!_nodes_caption.empty()) {
 		        _writer_bits::writeToken(*_os << ' ', _nodes_caption);
+		      }
 		      *_os << std::endl;
 		      if (label == 0) {
 		        *_os << "label" << '\t';
+		      }
 		      for (typename NodeMaps::iterator it = _node_maps.begin();
 		           it != _node_maps.end(); ++it) {
 		        _writer_bits::writeToken(*_os, it->first) << '\t';
+		      }
 		      *_os << std::endl;
 		      std::vector<Node> nodes;
 		      for (NodeIt n(_digraph); n != INVALID; ++n) {
 		        nodes.push_back(n);
+		      }
 		      if (label == 0) {
 		        IdMap<Digraph, Node> id_map(_digraph);
 		        _writer_bits::MapLess<IdMap<Digraph, Node> > id_less(id_map);
 		        std::sort(nodes.begin(), nodes.end(), id_less);
 		      } else {
 		        label->sort(nodes);
+		      }
 		      for (int i = 0; i < static_cast<int>(nodes.size()); ++i) {
 		        Node n = nodes[i];
 		        if (label == 0) {
 		          std::ostringstream os;
 		          os << _digraph.id(n);
 		          _writer_bits::writeToken(*_os, os.str());
 		          *_os << '\t';
 		          _node_index.insert(std::make_pair(n, os.str()));
+		        }
 		        for (typename NodeMaps::iterator it = _node_maps.begin();
 		             it != _node_maps.end(); ++it) {
 		          std::string value = it->second->get(n);
 		          _writer_bits::writeToken(*_os, value);
 		          if (it->first == "label") {
 		            _node_index.insert(std::make_pair(n, value));
+		          }
 		          *_os << '\t';
+		        }
 		        *_os << std::endl;
+		      }
+		    }
 		    void createNodeIndex() {
 		      _writer_bits::MapStorageBase<Node>* label = 0;
 		      for (typename NodeMaps::iterator it = _node_maps.begin();
 		           it != _node_maps.end(); ++it) {
 		        if (it->first == "label") {
 		          label = it->second;
 		          break;
+		        }
+		      }
 		      if (label == 0) {
 		        for (NodeIt n(_digraph); n != INVALID; ++n) {
 		          std::ostringstream os;
 		          os << _digraph.id(n);
 		          _node_index.insert(std::make_pair(n, os.str()));
+		        }
 		      } else {
 		        for (NodeIt n(_digraph); n != INVALID; ++n) {
 		          std::string value = label->get(n);
 		          _node_index.insert(std::make_pair(n, value));
+		        }
+		      }
+		    }
 		    void writeArcs() {
 		      _writer_bits::MapStorageBase<Arc>* label = 0;
 		      for (typename ArcMaps::iterator it = _arc_maps.begin();
 		           it != _arc_maps.end(); ++it) {
 		        if (it->first == "label") {
 		          label = it->second;
 		          break;
+		        }
+		      }
 		      *_os << "@arcs";
 		      if (!_arcs_caption.empty()) {
 		        _writer_bits::writeToken(*_os << ' ', _arcs_caption);
+		      }
 		      *_os << std::endl;
 		      *_os << '\t' << '\t';
 		      if (label == 0) {
 		        *_os << "label" << '\t';
+		      }
 		      for (typename ArcMaps::iterator it = _arc_maps.begin();
 		           it != _arc_maps.end(); ++it) {
 		        _writer_bits::writeToken(*_os, it->first) << '\t';
+		      }
 		      *_os << std::endl;
 		      std::vector<Arc> arcs;
 		      for (ArcIt n(_digraph); n != INVALID; ++n) {
 		        arcs.push_back(n);
+		      }
 		      if (label == 0) {
 		        IdMap<Digraph, Arc> id_map(_digraph);
 		        _writer_bits::MapLess<IdMap<Digraph, Arc> > id_less(id_map);
 		        std::sort(arcs.begin(), arcs.end(), id_less);
 		      } else {
 		        label->sort(arcs);
+		      }
 		      for (int i = 0; i < static_cast<int>(arcs.size()); ++i) {
 		        Arc a = arcs[i];
 		        _writer_bits::writeToken(*_os, _node_index.
 		                                 find(_digraph.source(a))->second);
 		        *_os << '\t';
 		        _writer_bits::writeToken(*_os, _node_index.
 		                                 find(_digraph.target(a))->second);
 		        *_os << '\t';
 		        if (label == 0) {
 		          std::ostringstream os;
 		          os << _digraph.id(a);
 		          _writer_bits::writeToken(*_os, os.str());
 		          *_os << '\t';
 		          _arc_index.insert(std::make_pair(a, os.str()));
+		        }
 		        for (typename ArcMaps::iterator it = _arc_maps.begin();
 		             it != _arc_maps.end(); ++it) {
 		          std::string value = it->second->get(a);
 		          _writer_bits::writeToken(*_os, value);
 		          if (it->first == "label") {
 		            _arc_index.insert(std::make_pair(a, value));
+		          }
 		          *_os << '\t';
+		        }
 		        *_os << std::endl;
+		      }
+		    }
 		    void createArcIndex() {
 		      _writer_bits::MapStorageBase<Arc>* label = 0;
 		      for (typename ArcMaps::iterator it = _arc_maps.begin();
 		           it != _arc_maps.end(); ++it) {
 		        if (it->first == "label") {
 		          label = it->second;
 		          break;
+		        }
+		      }
 		      if (label == 0) {
 		        for (ArcIt a(_digraph); a != INVALID; ++a) {
 		          std::ostringstream os;
 		          os << _digraph.id(a);
 		          _arc_index.insert(std::make_pair(a, os.str()));
+		        }
 		      } else {
 		        for (ArcIt a(_digraph); a != INVALID; ++a) {
 		          std::string value = label->get(a);
 		          _arc_index.insert(std::make_pair(a, value));
+		        }
+		      }
+		    }
 		    void writeAttributes() {
 		      if (_attributes.empty()) return;
 		      *_os << "@attributes";
 		      if (!_attributes_caption.empty()) {
 		        _writer_bits::writeToken(*_os << ' ', _attributes_caption);
+		      }
 		      *_os << std::endl;
 		      for (typename Attributes::iterator it = _attributes.begin();
 		           it != _attributes.end(); ++it) {
 		        _writer_bits::writeToken(*_os, it->first) << ' ';
 		        _writer_bits::writeToken(*_os, it->second->get());
 		        *_os << std::endl;
+		      }
+		    }
 		  public:
 		    /// \name Execution of the writer
 		    /// @{
 		    /// \brief Start the batch processing
 		    ///
 		    /// This function starts the batch processing.
 		    void run() {
 		      if (!_skip_nodes) {
 		        writeNodes();
 		      } else {
 		        createNodeIndex();
+		      }
 		      if (!_skip_arcs) {
 		        writeArcs();
 		      } else {
 		        createArcIndex();
+		      }
 		      writeAttributes();
+		    }
 		    /// \brief Give back the stream of the writer
 		    ///
 		    /// Give back the stream of the writer.
 		    std::ostream& ostream() {
 		      return *_os;
+		    }
 		    /// @}
 		  };
 		  /// \brief Return a \ref DigraphWriter class
 		  ///
 		  /// This function just returns a \ref DigraphWriter class.
 		  /// \relates DigraphWriter
 		  template <typename Digraph>
 		  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
 		                                       std::ostream& os) {
 		    DigraphWriter<Digraph> tmp(digraph, os);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref DigraphWriter class
 		  ///
 		  /// This function just returns a \ref DigraphWriter class.
 		  /// \relates DigraphWriter
 		  template <typename Digraph>
 		  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
 		                                       const std::string& fn) {
 		    DigraphWriter<Digraph> tmp(digraph, fn);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref DigraphWriter class
 		  ///
 		  /// This function just returns a \ref DigraphWriter class.
 		  /// \relates DigraphWriter
 		  template <typename Digraph>
 		  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
 		                                       const char* fn) {
 		    DigraphWriter<Digraph> tmp(digraph, fn);
 		    return tmp;
+		  }
 		  template <typename Graph>
 		  class GraphWriter;
 		  /// \brief Return a \ref GraphWriter class
 		  ///
 		  /// This function just returns a \ref GraphWriter class.
 		  /// \relates GraphWriter
 		  template <typename Graph>
 		  GraphWriter<Graph> graphWriter(const Graph& graph,
 		                                 std::ostream& os = std::cout) {
 		    GraphWriter<Graph> tmp(graph, os);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref GraphWriter class
 		  ///
 		  /// This function just returns a \ref GraphWriter class.
-		  /// \relates GraphWriter
+		                                 std::ostream& os = std::cout);
 		  template <typename Graph>
 		  GraphWriter<Graph> graphWriter(const Graph& graph, const std::string& fn) {
 		    GraphWriter<Graph> tmp(graph, fn);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref GraphWriter class
 		  ///
 		  /// This function just returns a \ref GraphWriter class.
-		  /// \relates GraphWriter
+		  GraphWriter<Graph> graphWriter(const Graph& graph, const std::string& fn);
 		  template <typename Graph>
 		  GraphWriter<Graph> graphWriter(const Graph& graph, const char* fn) {
 		    GraphWriter<Graph> tmp(graph, fn);
 		    return tmp;
+		  }
 		  GraphWriter<Graph> graphWriter(const Graph& graph, const char* fn);
 		  /// \ingroup lemon_io
 		  ///
 		  /// \brief \ref lgf-format "LGF" writer for directed graphs
 		  ///
 		  /// This utility writes an \ref lgf-format "LGF" file.
 		  ///
 		  /// It can be used almost the same way as \c DigraphWriter.
 		  /// The only difference is that this class can handle edges and
 		  /// edge maps as well as arcs and arc maps.
 		  ///
 		  /// The arc maps are written into the file as two columns, the
 		  /// caption of the columns are the name of the map prefixed with \c
 		  /// '+' and \c '-'. The arcs are written into the \c \@attributes
 		  /// section as a \c '+' or a \c '-' prefix (depends on the direction
 		  /// of the arc) and the label of corresponding edge.
 		  template <typename _Graph>
 		  class GraphWriter {
 		  public:
 		    typedef _Graph Graph;
 		    TEMPLATE_GRAPH_TYPEDEFS(Graph);
 		  private:
 		    std::ostream* _os;
 		    bool local_os;
 		    const Graph& _graph;
 		    std::string _nodes_caption;
 		    std::string _edges_caption;
 		    std::string _attributes_caption;
 		    typedef std::map<Node, std::string> NodeIndex;
 		    NodeIndex _node_index;
 		    typedef std::map<Edge, std::string> EdgeIndex;
 		    EdgeIndex _edge_index;
 		    typedef std::vector<std::pair<std::string,
 		      _writer_bits::MapStorageBase<Node>* > > NodeMaps;
 		    NodeMaps _node_maps;
 		    typedef std::vector<std::pair<std::string,
 		      _writer_bits::MapStorageBase<Edge>* > >EdgeMaps;
 		    EdgeMaps _edge_maps;
 		    typedef std::vector<std::pair<std::string,
 		      _writer_bits::ValueStorageBase*> > Attributes;
 		    Attributes _attributes;
 		    bool _skip_nodes;
 		    bool _skip_edges;
 		  public:
 		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph writer, which writes to the given
 		    /// output stream.
 		    GraphWriter(const Graph& graph, std::ostream& os = std::cout)
 		      : _os(&os), local_os(false), _graph(graph),
 		        _skip_nodes(false), _skip_edges(false) {}
 		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph writer, which writes to the given
 		    /// output file.
 		    GraphWriter(const Graph& graph, const std::string& fn)
 		      : _os(new std::ofstream(fn.c_str())), local_os(true), _graph(graph),
 		        _skip_nodes(false), _skip_edges(false) {
 		      if (!(*_os)) {
 		        delete _os;
 		        throw IoError("Cannot write file", fn);
+		      }
+		    }
 		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph writer, which writes to the given
 		    /// output file.
 		    GraphWriter(const Graph& graph, const char* fn)
 		      : _os(new std::ofstream(fn)), local_os(true), _graph(graph),
 		        _skip_nodes(false), _skip_edges(false) {
 		      if (!(*_os)) {
 		        delete _os;
 		        throw IoError("Cannot write file", fn);
+		      }
+		    }
 		    /// \brief Destructor
 		    ~GraphWriter() {
 		      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_os) {
 		        delete _os;
+		      }
+		    }
 		  private:
 		    friend GraphWriter<Graph> graphWriter<>(const Graph& graph,
 		                                            std::ostream& os);
 		    friend GraphWriter<Graph> graphWriter<>(const Graph& graph,
 		                                            const std::string& fn);
 		    friend GraphWriter<Graph> graphWriter<>(const Graph& graph,
 		                                            const char *fn);
+		    template <typename GR>
 		    friend GraphWriter<GR> graphWriter(const GR& graph,
 		                                       std::ostream& os);
 		    template <typename GR>
 		    friend GraphWriter<GR> graphWriter(const GR& graph,
 		                                       const std::string& fn);
 		    template <typename GR>
 		    friend GraphWriter<GR> graphWriter(const GR& graph,
 		                                       const char *fn);
 		    GraphWriter(GraphWriter& other)
 		      : _os(other._os), local_os(other.local_os), _graph(other._graph),
 		        _skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) {
 		      other._os = 0;
 		      other.local_os = 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;
+		    }
 		    GraphWriter& operator=(const GraphWriter&);
 		  public:
 		    /// \name Writing rules
 		    /// @{
 		    /// \brief Node map writing rule
 		    ///
 		    /// Add a node map writing rule to the writer.
 		    template <typename Map>
 		    GraphWriter& nodeMap(const std::string& caption, const Map& map) {
 		      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
 		      _writer_bits::MapStorageBase<Node>* storage =
 		        new _writer_bits::MapStorage<Node, Map>(map);
 		      _node_maps.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Node map writing rule
 		    ///
 		    /// Add a node map writing rule with specialized converter to the
 		    /// writer.
 		    template <typename Map, typename Converter>
 		    GraphWriter& nodeMap(const std::string& caption, const Map& map,
 		                           const Converter& converter = Converter()) {
 		      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
 		      _writer_bits::MapStorageBase<Node>* storage =
 		        new _writer_bits::MapStorage<Node, Map, Converter>(map, converter);
 		      _node_maps.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Edge map writing rule
 		    ///
 		    /// Add an edge map writing rule to the writer.
 		    template <typename Map>
 		    GraphWriter& edgeMap(const std::string& caption, const Map& map) {
 		      checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();
 		      _writer_bits::MapStorageBase<Edge>* storage =
 		        new _writer_bits::MapStorage<Edge, Map>(map);
 		      _edge_maps.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Edge map writing rule
 		    ///
 		    /// Add an edge map writing rule with specialized converter to the
 		    /// writer.
 		    template <typename Map, typename Converter>
 		    GraphWriter& edgeMap(const std::string& caption, const Map& map,
 		                          const Converter& converter = Converter()) {
 		      checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();
 		      _writer_bits::MapStorageBase<Edge>* storage =
 		        new _writer_bits::MapStorage<Edge, Map, Converter>(map, converter);
 		      _edge_maps.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Arc map writing rule
 		    ///
 		    /// Add an arc map writing rule to the writer.
 		    template <typename Map>
 		    GraphWriter& arcMap(const std::string& caption, const Map& map) {
 		      checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();
 		      _writer_bits::MapStorageBase<Edge>* forward_storage =
 		        new _writer_bits::GraphArcMapStorage<Graph, true, Map>(_graph, map);
 		      _edge_maps.push_back(std::make_pair('+' + caption, forward_storage));
 		      _writer_bits::MapStorageBase<Edge>* backward_storage =
 		        new _writer_bits::GraphArcMapStorage<Graph, false, Map>(_graph, map);
 		      _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
 		      return *this;
+		    }
 		    /// \brief Arc map writing rule
 		    ///
 		    /// Add an arc map writing rule with specialized converter to the
 		    /// writer.
 		    template <typename Map, typename Converter>
 		    GraphWriter& arcMap(const std::string& caption, const Map& map,
 		                          const Converter& converter = Converter()) {
 		      checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();
 		      _writer_bits::MapStorageBase<Edge>* forward_storage =
 		        new _writer_bits::GraphArcMapStorage<Graph, true, Map, Converter>
 		        (_graph, map, converter);
 		      _edge_maps.push_back(std::make_pair('+' + caption, forward_storage));
 		      _writer_bits::MapStorageBase<Edge>* backward_storage =
 		        new _writer_bits::GraphArcMapStorage<Graph, false, Map, Converter>
 		        (_graph, map, converter);
 		      _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
 		      return *this;
+		    }
 		    /// \brief Attribute writing rule
 		    ///
 		    /// Add an attribute writing rule to the writer.
 		    template <typename Value>
 		    GraphWriter& attribute(const std::string& caption, const Value& value) {
 		      _writer_bits::ValueStorageBase* storage =
 		        new _writer_bits::ValueStorage<Value>(value);
 		      _attributes.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Attribute writing rule
 		    ///
 		    /// Add an attribute writing rule with specialized converter to the
 		    /// writer.
 		    template <typename Value, typename Converter>
 		    GraphWriter& attribute(const std::string& caption, const Value& value,
 		                             const Converter& converter = Converter()) {
 		      _writer_bits::ValueStorageBase* storage =
 		        new _writer_bits::ValueStorage<Value, Converter>(value, converter);
 		      _attributes.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Node writing rule
 		    ///
 		    /// Add a node writing rule to the writer.
 		    GraphWriter& node(const std::string& caption, const Node& node) {
 		      typedef _writer_bits::MapLookUpConverter<Node> Converter;
 		      Converter converter(_node_index);
 		      _writer_bits::ValueStorageBase* storage =
 		        new _writer_bits::ValueStorage<Node, Converter>(node, converter);
 		      _attributes.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Edge writing rule
 		    ///
 		    /// Add an edge writing rule to writer.
 		    GraphWriter& edge(const std::string& caption, const Edge& edge) {
 		      typedef _writer_bits::MapLookUpConverter<Edge> Converter;
 		      Converter converter(_edge_index);
 		      _writer_bits::ValueStorageBase* storage =
 		        new _writer_bits::ValueStorage<Edge, Converter>(edge, converter);
 		      _attributes.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Arc writing rule
 		    ///
 		    /// Add an arc writing rule to writer.
 		    GraphWriter& arc(const std::string& caption, const Arc& arc) {
 		      typedef _writer_bits::GraphArcLookUpConverter<Graph> Converter;
 		      Converter converter(_graph, _edge_index);
 		      _writer_bits::ValueStorageBase* storage =
 		        new _writer_bits::ValueStorage<Arc, Converter>(arc, converter);
 		      _attributes.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \name Section captions
 		    /// @{
 		    /// \brief Add an additional caption to the \c \@nodes section
 		    ///
 		    /// Add an additional caption to the \c \@nodes section.
 		    GraphWriter& nodes(const std::string& caption) {
 		      _nodes_caption = caption;
 		      return *this;
+		    }
 		    /// \brief Add an additional caption to the \c \@arcs section
 		    ///
 		    /// Add an additional caption to the \c \@arcs section.
 		    GraphWriter& edges(const std::string& caption) {
 		      _edges_caption = caption;
 		      return *this;
+		    }
 		    /// \brief Add an additional caption to the \c \@attributes section
 		    ///
 		    /// Add an additional caption to the \c \@attributes section.
 		    GraphWriter& attributes(const std::string& caption) {
 		      _attributes_caption = caption;
 		      return *this;
+		    }
 		    /// \name Skipping section
 		    /// @{
 		    /// \brief Skip writing the node set
 		    ///
 		    /// The \c \@nodes section will not be written to the stream.
 		    GraphWriter& skipNodes() {
 		      LEMON_ASSERT(!_skip_nodes, "Multiple usage of skipNodes() member");
 		      _skip_nodes = true;
 		      return *this;
+		    }
 		    /// \brief Skip writing edge set
 		    ///
 		    /// The \c \@edges section will not be written to the stream.
 		    GraphWriter& skipEdges() {
 		      LEMON_ASSERT(!_skip_edges, "Multiple usage of skipEdges() member");
 		      _skip_edges = true;
 		      return *this;
+		    }
 		    /// @}
 		  private:
 		    void writeNodes() {
 		      _writer_bits::MapStorageBase<Node>* label = 0;
 		      for (typename NodeMaps::iterator it = _node_maps.begin();
 		           it != _node_maps.end(); ++it) {
 		        if (it->first == "label") {
 		          label = it->second;
 		          break;
+		        }
+		      }
 		      *_os << "@nodes";
 		      if (!_nodes_caption.empty()) {
 		        _writer_bits::writeToken(*_os << ' ', _nodes_caption);
+		      }
 		      *_os << std::endl;
 		      if (label == 0) {
 		        *_os << "label" << '\t';
+		      }
 		      for (typename NodeMaps::iterator it = _node_maps.begin();
 		           it != _node_maps.end(); ++it) {
 		        _writer_bits::writeToken(*_os, it->first) << '\t';
+		      }
 		      *_os << std::endl;
 		      std::vector<Node> nodes;
 		      for (NodeIt n(_graph); n != INVALID; ++n) {
 		        nodes.push_back(n);
+		      }
 		      if (label == 0) {
 		        IdMap<Graph, Node> id_map(_graph);
 		        _writer_bits::MapLess<IdMap<Graph, Node> > id_less(id_map);
 		        std::sort(nodes.begin(), nodes.end(), id_less);
 		      } else {
 		        label->sort(nodes);
+		      }
 		      for (int i = 0; i < static_cast<int>(nodes.size()); ++i) {
 		        Node n = nodes[i];
 		        if (label == 0) {
 		          std::ostringstream os;
 		          os << _graph.id(n);
 		          _writer_bits::writeToken(*_os, os.str());
 		          *_os << '\t';
 		          _node_index.insert(std::make_pair(n, os.str()));
+		        }
 		        for (typename NodeMaps::iterator it = _node_maps.begin();
 		             it != _node_maps.end(); ++it) {
 		          std::string value = it->second->get(n);
 		          _writer_bits::writeToken(*_os, value);
 		          if (it->first == "label") {
 		            _node_index.insert(std::make_pair(n, value));
+		          }
 		          *_os << '\t';
+		        }
 		        *_os << std::endl;
+		      }
+		    }
 		    void createNodeIndex() {
 		      _writer_bits::MapStorageBase<Node>* label = 0;
 		      for (typename NodeMaps::iterator it = _node_maps.begin();
 		           it != _node_maps.end(); ++it) {
 		        if (it->first == "label") {
 		          label = it->second;
 		          break;
+		        }
+		      }
 		      if (label == 0) {
 		        for (NodeIt n(_graph); n != INVALID; ++n) {
 		          std::ostringstream os;
 		          os << _graph.id(n);
 		          _node_index.insert(std::make_pair(n, os.str()));
+		        }
 		      } else {
 		        for (NodeIt n(_graph); n != INVALID; ++n) {
 		          std::string value = label->get(n);
 		          _node_index.insert(std::make_pair(n, value));
+		        }
+		      }
+		    }
 		    void writeEdges() {
 		      _writer_bits::MapStorageBase<Edge>* label = 0;
 		      for (typename EdgeMaps::iterator it = _edge_maps.begin();
 		           it != _edge_maps.end(); ++it) {
 		        if (it->first == "label") {
 		          label = it->second;
 		          break;
+		        }
+		      }
 		      *_os << "@edges";
 		      if (!_edges_caption.empty()) {
 		        _writer_bits::writeToken(*_os << ' ', _edges_caption);
+		      }
 		      *_os << std::endl;
 		      *_os << '\t' << '\t';
 		      if (label == 0) {
 		        *_os << "label" << '\t';
+		      }
 		      for (typename EdgeMaps::iterator it = _edge_maps.begin();
 		           it != _edge_maps.end(); ++it) {
 		        _writer_bits::writeToken(*_os, it->first) << '\t';
+		      }
 		      *_os << std::endl;
 		      std::vector<Edge> edges;
 		      for (EdgeIt n(_graph); n != INVALID; ++n) {
 		        edges.push_back(n);
+		      }
 		      if (label == 0) {
 		        IdMap<Graph, Edge> id_map(_graph);
 		        _writer_bits::MapLess<IdMap<Graph, Edge> > id_less(id_map);
 		        std::sort(edges.begin(), edges.end(), id_less);
 		      } else {
 		        label->sort(edges);
+		      }
 		      for (int i = 0; i < static_cast<int>(edges.size()); ++i) {
 		        Edge e = edges[i];
 		        _writer_bits::writeToken(*_os, _node_index.
 		                                 find(_graph.u(e))->second);
 		        *_os << '\t';
 		        _writer_bits::writeToken(*_os, _node_index.
 		                                 find(_graph.v(e))->second);
 		        *_os << '\t';
 		        if (label == 0) {
 		          std::ostringstream os;
 		          os << _graph.id(e);
 		          _writer_bits::writeToken(*_os, os.str());
 		          *_os << '\t';
 		          _edge_index.insert(std::make_pair(e, os.str()));
+		        }
 		        for (typename EdgeMaps::iterator it = _edge_maps.begin();
 		             it != _edge_maps.end(); ++it) {
 		          std::string value = it->second->get(e);
 		          _writer_bits::writeToken(*_os, value);
 		          if (it->first == "label") {
 		            _edge_index.insert(std::make_pair(e, value));
+		          }
 		          *_os << '\t';
+		        }
 		        *_os << std::endl;
+		      }
+		    }
 		    void createEdgeIndex() {
 		      _writer_bits::MapStorageBase<Edge>* label = 0;
 		      for (typename EdgeMaps::iterator it = _edge_maps.begin();
 		           it != _edge_maps.end(); ++it) {
 		        if (it->first == "label") {
 		          label = it->second;
 		          break;
+		        }
+		      }
 		      if (label == 0) {
 		        for (EdgeIt e(_graph); e != INVALID; ++e) {
 		          std::ostringstream os;
 		          os << _graph.id(e);
 		          _edge_index.insert(std::make_pair(e, os.str()));
+		        }
 		      } else {
 		        for (EdgeIt e(_graph); e != INVALID; ++e) {
 		          std::string value = label->get(e);
 		          _edge_index.insert(std::make_pair(e, value));
+		        }
+		      }
+		    }
 		    void writeAttributes() {
 		      if (_attributes.empty()) return;
 		      *_os << "@attributes";
 		      if (!_attributes_caption.empty()) {
 		        _writer_bits::writeToken(*_os << ' ', _attributes_caption);
+		      }
 		      *_os << std::endl;
 		      for (typename Attributes::iterator it = _attributes.begin();
 		           it != _attributes.end(); ++it) {
 		        _writer_bits::writeToken(*_os, it->first) << ' ';
 		        _writer_bits::writeToken(*_os, it->second->get());
 		        *_os << std::endl;
+		      }
+		    }
 		  public:
 		    /// \name Execution of the writer
 		    /// @{
 		    /// \brief Start the batch processing
 		    ///
 		    /// This function starts the batch processing.
 		    void run() {
 		      if (!_skip_nodes) {
 		        writeNodes();
 		      } else {
 		        createNodeIndex();
+		      }
 		      if (!_skip_edges) {
 		        writeEdges();
 		      } else {
 		        createEdgeIndex();
+		      }
 		      writeAttributes();
+		    }
 		    /// \brief Give back the stream of the writer
 		    ///
 		    /// Give back the stream of the writer
 		    std::ostream& ostream() {
 		      return *_os;
+		    }
 		    /// @}
 		  };
 		  /// \brief Return a \ref GraphWriter class
 		  ///
 		  /// This function just returns a \ref GraphWriter class.
 		  /// \relates GraphWriter
 		  template <typename Graph>
 		  GraphWriter<Graph> graphWriter(const Graph& graph,
 		                                 std::ostream& os) {
 		    GraphWriter<Graph> tmp(graph, os);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref GraphWriter class
 		  ///
 		  /// This function just returns a \ref GraphWriter class.
 		  /// \relates GraphWriter
 		  template <typename Graph>
 		  GraphWriter<Graph> graphWriter(const Graph& graph, const std::string& fn) {
 		    GraphWriter<Graph> tmp(graph, fn);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref GraphWriter class
 		  ///
 		  /// This function just returns a \ref GraphWriter class.
 		  /// \relates GraphWriter
 		  template <typename Graph>
 		  GraphWriter<Graph> graphWriter(const Graph& graph, const char* fn) {
 		    GraphWriter<Graph> tmp(graph, fn);
 		    return tmp;
+		  }
 		  class SectionWriter;
 		  SectionWriter sectionWriter(std::istream& is);
 		  SectionWriter sectionWriter(const std::string& fn);
 		  SectionWriter sectionWriter(const char* fn);
 		  /// \ingroup lemon_io
 		  ///
 		  /// \brief Section writer class
 		  ///
 		  /// In the \ref lgf-format "LGF" file extra sections can be placed,
 		  /// which contain any data in arbitrary format. Such sections can be
 		  /// written with this class. A writing rule can be added to the
 		  /// class with two different functions. With the \c sectionLines()
 		  /// function a generator can write the section line-by-line, while
 		  /// with the \c sectionStream() member the section can be written to
 		  /// an output stream.
 		  class SectionWriter {
 		  private:
 		    std::ostream* _os;
 		    bool local_os;
 		    typedef std::vector<std::pair<std::string, _writer_bits::Section*> >
 		    Sections;
 		    Sections _sections;
 		  public:
 		    /// \brief Constructor
 		    ///
 		    /// Construct a section writer, which writes to the given output
 		    /// stream.
 		    SectionWriter(std::ostream& os)
 		      : _os(&os), local_os(false) {}
 		    /// \brief Constructor
 		    ///
 		    /// Construct a section writer, which writes into the given file.
 		    SectionWriter(const std::string& fn)
 		      : _os(new std::ofstream(fn.c_str())), local_os(true) {
 		      if (!(*_os)) {
 		        delete _os;
 		        throw IoError("Cannot write file", fn);
+		      }
+		    }
 		    /// \brief Constructor
 		    ///
 		    /// Construct a section writer, which writes into the given file.
 		    SectionWriter(const char* fn)
 		      : _os(new std::ofstream(fn)), local_os(true) {
 		      if (!(*_os)) {
 		        delete _os;
 		        throw IoError("Cannot write file", fn);
+		      }
+		    }
 		    /// \brief Destructor
 		    ~SectionWriter() {
 		      for (Sections::iterator it = _sections.begin();
 		           it != _sections.end(); ++it) {
 		        delete it->second;
+		      }
 		      if (local_os) {
 		        delete _os;
+		      }
+		    }
 		  private:
 		    friend SectionWriter sectionWriter(std::ostream& os);
 		    friend SectionWriter sectionWriter(const std::string& fn);
 		    friend SectionWriter sectionWriter(const char* fn);
 		    SectionWriter(SectionWriter& other)
 		      : _os(other._os), local_os(other.local_os) {
 		      other._os = 0;
 		      other.local_os = false;
 		      _sections.swap(other._sections);
+		    }
 		    SectionWriter& operator=(const SectionWriter&);
 		  public:
 		    /// \name Section writers
 		    /// @{
 		    /// \brief Add a section writer with line oriented writing
 		    ///
 		    /// The first parameter is the type descriptor of the section, the
 		    /// second is a generator with std::string values. At the writing
 		    /// process, the returned \c std::string will be written into the
 		    /// output file until it is an empty string.
 		    ///
 		    /// For example, an integer vector is written into a section.
 		    ///\code
 		    ///  @numbers
 		    ///  12 45 23 78
 		    ///  4 28 38 28
 		    ///  23 6 16
 		    ///\endcode
 		    ///
 		    /// The generator is implemented as a struct.
 		    ///\code
 		    ///  struct NumberSection {
 		    ///    std::vector<int>::const_iterator _it, _end;
 		    ///    NumberSection(const std::vector<int>& data)
 		    ///      : _it(data.begin()), _end(data.end()) {}
 		    ///    std::string operator()() {
 		    ///      int rem_in_line = 4;
 		    ///      std::ostringstream ls;
 		    ///      while (rem_in_line > 0 && _it != _end) {
 		    ///        ls << *(_it++) << ' ';
 		    ///        --rem_in_line;
 		    ///      }
 		    ///      return ls.str();
 		    ///    }
 		    ///  };
 		    ///
 		    ///  // ...
 		    ///
 		    ///  writer.sectionLines("numbers", NumberSection(vec));
 		    ///\endcode
 		    template <typename Functor>
 		    SectionWriter& sectionLines(const std::string& type, Functor functor) {
 		      LEMON_ASSERT(!type.empty(), "Type is empty.");
 		      _sections.push_back(std::make_pair(type,
 		        new _writer_bits::LineSection<Functor>(functor)));
 		      return *this;
+		    }
 		    /// \brief Add a section writer with stream oriented writing
 		    ///
 		    /// The first parameter is the type of the section, the second is
 		    /// a functor, which takes a \c std::ostream& parameter. The
 		    /// functor writes the section to the output stream.
 		    /// \warning The last line must be closed with end-line character.
 		    template <typename Functor>
 		    SectionWriter& sectionStream(const std::string& type, Functor functor) {
 		      LEMON_ASSERT(!type.empty(), "Type is empty.");
 		      _sections.push_back(std::make_pair(type,
 		         new _writer_bits::StreamSection<Functor>(functor)));
 		      return *this;
+		    }
 		    /// @}
 		  public:
 		    /// \name Execution of the writer
 		    /// @{
 		    /// \brief Start the batch processing
 		    ///
 		    /// This function starts the batch processing.
 		    void run() {
 		      LEMON_ASSERT(_os != 0, "This writer is assigned to an other writer");
 		      for (Sections::iterator it = _sections.begin();
 		           it != _sections.end(); ++it) {
 		        (*_os) << '@' << it->first << std::endl;
 		        it->second->process(*_os);
+		      }
+		    }
 		    /// \brief Give back the stream of the writer
 		    ///
 		    /// Returns the stream of the writer
 		    std::ostream& ostream() {
 		      return *_os;
+		    }
 		    /// @}
 		  };
 		  /// \brief Return a \ref SectionWriter class
 		  ///
 		  /// This function just returns a \ref SectionWriter class.
 		  /// \relates SectionWriter
 		  inline SectionWriter sectionWriter(std::ostream& os) {
 		    SectionWriter tmp(os);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref SectionWriter class
 		  ///
 		  /// This function just returns a \ref SectionWriter class.
 		  /// \relates SectionWriter
 		  inline SectionWriter sectionWriter(const std::string& fn) {
 		    SectionWriter tmp(fn);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref SectionWriter class
 		  ///
 		  /// This function just returns a \ref SectionWriter class.
 		  /// \relates SectionWriter
 		  inline SectionWriter sectionWriter(const char* fn) {
 		    SectionWriter tmp(fn);
 		    return tmp;
+		  }
+		}
 		#endif

lemon/path.h

Show inline comments

@@ -420,667 +420,683 @@
 		      Node *next, *prev;
 		    };
 		    Node *first, *last;
 		    std::allocator<Node> alloc;
 		  public:
 		    /// \brief Default constructor
 		    ///
 		    /// Default constructor
 		    ListPath() : first(0), last(0) {}
 		    /// \brief Template copy constructor
 		    ///
 		    /// This path can be initialized with any other path type. It just
 		    /// makes a copy of the given path.
 		    template <typename CPath>
 		    ListPath(const CPath& cpath) : first(0), last(0) {
 		      copyPath(*this, cpath);
+		    }
 		    /// \brief Destructor of the path
 		    ///
 		    /// Destructor of the path
 		    ~ListPath() {
 		      clear();
+		    }
 		    /// \brief Template copy assignment
 		    ///
 		    /// This path can be initialized with any other path type. It just
 		    /// makes a copy of the given path.
 		    template <typename CPath>
 		    ListPath& operator=(const CPath& cpath) {
 		      copyPath(*this, cpath);
 		      return *this;
+		    }
 		    /// \brief Iterator class to iterate on the arcs of the paths
 		    ///
 		    /// This class is used to iterate on the arcs of the paths
 		    ///
 		    /// Of course it converts to Digraph::Arc
 		    class ArcIt {
 		      friend class ListPath;
 		    public:
 		      /// Default constructor
 		      ArcIt() {}
 		      /// Invalid constructor
 		      ArcIt(Invalid) : path(0), node(0) {}
 		      /// \brief Initializate the constructor to the first arc of path
 		      ArcIt(const ListPath &_path)
 		        : path(&_path), node(_path.first) {}
 		    protected:
 		      ArcIt(const ListPath &_path, Node *_node)
 		        : path(&_path), node(_node) {}
 		    public:
 		      ///Conversion to Digraph::Arc
 		      operator const Arc&() const {
 		        return node->arc;
+		      }
 		      /// Next arc
 		      ArcIt& operator++() {
 		        node = node->next;
 		        return *this;
+		      }
 		      /// Comparison operator
 		      bool operator==(const ArcIt& e) const { return node==e.node; }
 		      /// Comparison operator
 		      bool operator!=(const ArcIt& e) const { return node!=e.node; }
 		      /// Comparison operator
 		      bool operator<(const ArcIt& e) const { return node<e.node; }
 		    private:
 		      const ListPath *path;
 		      Node *node;
 		    };
 		    /// \brief The nth arc.
 		    ///
 		    /// This function looks for the nth arc in O(n) time.
 		    /// \pre n is in the [0..length() - 1] range
 		    const Arc& nth(int n) const {
 		      Node *node = first;
 		      for (int i = 0; i < n; ++i) {
 		        node = node->next;
+		      }
 		      return node->arc;
+		    }
 		    /// \brief Initializes arc iterator to point to the nth arc.
 		    ArcIt nthIt(int n) const {
 		      Node *node = first;
 		      for (int i = 0; i < n; ++i) {
 		        node = node->next;
+		      }
 		      return ArcIt(*this, node);
+		    }
 		    /// \brief Length of the path.
 		    int length() const {
 		      int len = 0;
 		      Node *node = first;
 		      while (node != 0) {
 		        node = node->next;
 		        ++len;
+		      }
 		      return len;
+		    }
 		    /// \brief Return true if the path is empty.
 		    bool empty() const { return first == 0; }
 		    /// \brief Reset the path to an empty one.
 		    void clear() {
 		      while (first != 0) {
 		        last = first->next;
 		        alloc.destroy(first);
 		        alloc.deallocate(first, 1);
 		        first = last;
+		      }
+		    }
 		    /// \brief The first arc of the path
 		    const Arc& front() const {
 		      return first->arc;
+		    }
 		    /// \brief Add a new arc before the current path
 		    void addFront(const Arc& arc) {
 		      Node *node = alloc.allocate(1);
 		      alloc.construct(node, Node());
 		      node->prev = 0;
 		      node->next = first;
 		      node->arc = arc;
 		      if (first) {
 		        first->prev = node;
 		        first = node;
 		      } else {
 		        first = last = node;
+		      }
+		    }
 		    /// \brief Erase the first arc of the path
 		    void eraseFront() {
 		      Node *node = first;
 		      first = first->next;
 		      if (first) {
 		        first->prev = 0;
 		      } else {
 		        last = 0;
+		      }
 		      alloc.destroy(node);
 		      alloc.deallocate(node, 1);
+		    }
 		    /// \brief The last arc of the path.
 		    const Arc& back() const {
 		      return last->arc;
+		    }
 		    /// \brief Add a new arc behind the current path.
 		    void addBack(const Arc& arc) {
 		      Node *node = alloc.allocate(1);
 		      alloc.construct(node, Node());
 		      node->next = 0;
 		      node->prev = last;
 		      node->arc = arc;
 		      if (last) {
 		        last->next = node;
 		        last = node;
 		      } else {
 		        last = first = node;
+		      }
+		    }
 		    /// \brief Erase the last arc of the path
 		    void eraseBack() {
 		      Node *node = last;
 		      last = last->prev;
 		      if (last) {
 		        last->next = 0;
 		      } else {
 		        first = 0;
+		      }
 		      alloc.destroy(node);
 		      alloc.deallocate(node, 1);
+		    }
 		    /// \brief Splice a path to the back of the current path.
 		    ///
 		    /// It splices \c tpath to the back of the current path and \c
 		    /// tpath becomes empty. The time complexity of this function is
 		    /// O(1).
 		    void spliceBack(ListPath& tpath) {
 		      if (first) {
 		        if (tpath.first) {
 		          last->next = tpath.first;
 		          tpath.first->prev = last;
 		          last = tpath.last;
+		        }
 		      } else {
 		        first = tpath.first;
 		        last = tpath.last;
+		      }
 		      tpath.first = tpath.last = 0;
+		    }
 		    /// \brief Splice a path to the front of the current path.
 		    ///
 		    /// It splices \c tpath before the current path and \c tpath
 		    /// becomes empty. The time complexity of this function
 		    /// is O(1).
 		    void spliceFront(ListPath& tpath) {
 		      if (first) {
 		        if (tpath.first) {
 		          first->prev = tpath.last;
 		          tpath.last->next = first;
 		          first = tpath.first;
+		        }
 		      } else {
 		        first = tpath.first;
 		        last = tpath.last;
+		      }
 		      tpath.first = tpath.last = 0;
+		    }
 		    /// \brief Splice a path into the current path.
 		    ///
 		    /// It splices the \c tpath into the current path before the
 		    /// position of \c it iterator and \c tpath becomes empty. The
 		    /// time complexity of this function is O(1). If the \c it is
 		    /// \c INVALID then it will splice behind the current path.
 		    void splice(ArcIt it, ListPath& tpath) {
 		      if (it.node) {
 		        if (tpath.first) {
 		          tpath.first->prev = it.node->prev;
 		          if (it.node->prev) {
 		            it.node->prev->next = tpath.first;
 		          } else {
 		            first = tpath.first;
+		          }
 		          it.node->prev = tpath.last;
 		          tpath.last->next = it.node;
+		        }
 		      } else {
 		        if (first) {
 		          if (tpath.first) {
 		            last->next = tpath.first;
 		            tpath.first->prev = last;
 		            last = tpath.last;
+		          }
 		        } else {
 		          first = tpath.first;
 		          last = tpath.last;
+		        }
+		      }
 		      tpath.first = tpath.last = 0;
+		    }
 		    /// \brief Split the current path.
 		    ///
 		    /// It splits the current path into two parts. The part before
 		    /// the iterator \c it will remain in the current path and the part
 		    /// starting with
 		    /// \c it will put into \c tpath. If \c tpath have arcs
 		    /// before the operation they are removed first.  The time
 		    /// complexity of this function is O(1) plus the the time of emtying
 		    /// \c tpath. If \c it is \c INVALID then it just clears \c tpath
 		    void split(ArcIt it, ListPath& tpath) {
 		      tpath.clear();
 		      if (it.node) {
 		        tpath.first = it.node;
 		        tpath.last = last;
 		        if (it.node->prev) {
 		          last = it.node->prev;
 		          last->next = 0;
 		        } else {
 		          first = last = 0;
+		        }
 		        it.node->prev = 0;
+		      }
+		    }
 		    typedef True BuildTag;
 		    template <typename CPath>
 		    void build(const CPath& path) {
 		      for (typename CPath::ArcIt it(path); it != INVALID; ++it) {
 		        addBack(it);
+		      }
+		    }
 		    template <typename CPath>
 		    void buildRev(const CPath& path) {
 		      for (typename CPath::RevArcIt it(path); it != INVALID; ++it) {
 		        addFront(it);
+		      }
+		    }
 		  };
 		  /// \brief A structure for representing directed paths in a digraph.
 		  ///
 		  /// A structure for representing directed path in a digraph.
 		  /// \tparam _Digraph The digraph type in which the path is.
 		  ///
 		  /// In a sense, the path can be treated as a list of arcs. The
 		  /// lemon path type stores just this list. As a consequence it
 		  /// cannot enumerate the nodes in the path and the source node of
 		  /// a zero length path is undefined.
 		  ///
 		  /// This implementation is completly static, i.e. it can be copy constucted
 		  /// or copy assigned from another path, but otherwise it cannot be
 		  /// modified.
 		  ///
 		  /// Being the the most memory efficient path type in LEMON,
 		  /// it is intented to be
 		  /// used when you want to store a large number of paths.
 		  template <typename _Digraph>
 		  class StaticPath {
 		  public:
 		    typedef _Digraph Digraph;
 		    typedef typename Digraph::Arc Arc;
 		    /// \brief Default constructor
 		    ///
 		    /// Default constructor
 		    StaticPath() : len(0), arcs(0) {}
 		    /// \brief Template copy constructor
 		    ///
 		    /// This path can be initialized from any other path type.
 		    template <typename CPath>
 		    StaticPath(const CPath& cpath) : arcs(0) {
 		      copyPath(*this, cpath);
+		    }
 		    /// \brief Destructor of the path
 		    ///
 		    /// Destructor of the path
 		    ~StaticPath() {
 		      if (arcs) delete[] arcs;
+		    }
 		    /// \brief Template copy assignment
 		    ///
 		    /// This path can be made equal to any other path type. It simply
 		    /// makes a copy of the given path.
 		    template <typename CPath>
 		    StaticPath& operator=(const CPath& cpath) {
 		      copyPath(*this, cpath);
 		      return *this;
+		    }
 		    /// \brief Iterator class to iterate on the arcs of the paths
 		    ///
 		    /// This class is used to iterate on the arcs of the paths
 		    ///
 		    /// Of course it converts to Digraph::Arc
 		    class ArcIt {
 		      friend class StaticPath;
 		    public:
 		      /// Default constructor
 		      ArcIt() {}
 		      /// Invalid constructor
 		      ArcIt(Invalid) : path(0), idx(-1) {}
 		      /// Initializate the constructor to the first arc of path
 		      ArcIt(const StaticPath &_path)
 		        : path(&_path), idx(_path.empty() ? -1 : 0) {}
 		    private:
 		      /// Constructor with starting point
 		      ArcIt(const StaticPath &_path, int _idx)
 		        : idx(_idx), path(&_path) {}
 		    public:
 		      ///Conversion to Digraph::Arc
 		      operator const Arc&() const {
 		        return path->nth(idx);
+		      }
 		      /// Next arc
 		      ArcIt& operator++() {
 		        ++idx;
 		        if (idx >= path->length()) idx = -1;
 		        return *this;
+		      }
 		      /// Comparison operator
 		      bool operator==(const ArcIt& e) const { return idx==e.idx; }
 		      /// Comparison operator
 		      bool operator!=(const ArcIt& e) const { return idx!=e.idx; }
 		      /// Comparison operator
 		      bool operator<(const ArcIt& e) const { return idx<e.idx; }
 		    private:
 		      const StaticPath *path;
 		      int idx;
 		    };
 		    /// \brief The nth arc.
 		    ///
 		    /// \pre n is in the [0..length() - 1] range
 		    const Arc& nth(int n) const {
 		      return arcs[n];
+		    }
 		    /// \brief The arc iterator pointing to the nth arc.
 		    ArcIt nthIt(int n) const {
 		      return ArcIt(*this, n);
+		    }
 		    /// \brief The length of the path.
 		    int length() const { return len; }
 		    /// \brief Return true when the path is empty.
 		    int empty() const { return len == 0; }
 		    /// \brief Erase all arcs in the digraph.
 		    void clear() {
 		      len = 0;
 		      if (arcs) delete[] arcs;
 		      arcs = 0;
+		    }
 		    /// \brief The first arc of the path.
 		    const Arc& front() const {
 		      return arcs[0];
+		    }
 		    /// \brief The last arc of the path.
 		    const Arc& back() const {
 		      return arcs[len - 1];
+		    }
 		    typedef True BuildTag;
 		    template <typename CPath>
 		    void build(const CPath& path) {
 		      len = path.length();
 		      arcs = new Arc[len];
 		      int index = 0;
 		      for (typename CPath::ArcIt it(path); it != INVALID; ++it) {
 		        arcs[index] = it;
 		        ++index;
+		      }
+		    }
 		    template <typename CPath>
 		    void buildRev(const CPath& path) {
 		      len = path.length();
 		      arcs = new Arc[len];
 		      int index = len;
 		      for (typename CPath::RevArcIt it(path); it != INVALID; ++it) {
 		        --index;
 		        arcs[index] = it;
+		      }
+		    }
 		  private:
 		    int len;
 		    Arc* arcs;
 		  };
 		  ///////////////////////////////////////////////////////////////////////
 		  // Additional utilities
 		  ///////////////////////////////////////////////////////////////////////
 		  namespace _path_bits {
 		    template <typename Path, typename Enable = void>
 		    struct RevPathTagIndicator {
 		      static const bool value = false;
 		    };
 		    template <typename Path>
 		    struct RevPathTagIndicator<
 		      Path,
 		      typename enable_if<typename Path::RevPathTag, void>::type
 		      > {
 		      static const bool value = true;
 		    };
 		    template <typename Path, typename Enable = void>
 		    struct BuildTagIndicator {
 		      static const bool value = false;
 		    };
 		    template <typename Path>
 		    struct BuildTagIndicator<
 		      Path,
 		      typename enable_if<typename Path::BuildTag, void>::type
 		    > {
 		      static const bool value = true;
 		    };
 		    template <typename Target, typename Source,
 		              bool buildEnable = BuildTagIndicator<Target>::value,
 		              bool revEnable = RevPathTagIndicator<Source>::value>
-		    struct PathCopySelector {
+		              bool buildEnable = BuildTagIndicator<Target>::value>
 		    struct PathCopySelectorForward {
 		      static void copy(Target& target, const Source& source) {
 		        target.clear();
 		        for (typename Source::ArcIt it(source); it != INVALID; ++it) {
 		          target.addBack(it);
+		        }
+		      }
 		    };
 		    template <typename Target, typename Source>
-		    struct PathCopySelector<Target, Source, false, true> {
+		    struct PathCopySelectorForward<Target, Source, true> {
 		      static void copy(Target& target, const Source& source) {
 		        target.clear();
 		        target.build(source);
+		      }
 		    };
 		    template <typename Target, typename Source,
 		              bool buildEnable = BuildTagIndicator<Target>::value>
 		    struct PathCopySelectorBackward {
 		      static void copy(Target& target, const Source& source) {
 		        target.clear();
 		        for (typename Source::RevArcIt it(source); it != INVALID; ++it) {
 		          target.addFront(it);
+		        }
+		      }
 		    };
 		    template <typename Target, typename Source>
 		    struct PathCopySelector<Target, Source, true, false> {
 		      static void copy(Target& target, const Source& source) {
 		        target.clear();
 		        target.build(source);
+		      }
 		    };
 		    template <typename Target, typename Source>
-		    struct PathCopySelector<Target, Source, true, true> {
+		    struct PathCopySelectorBackward<Target, Source, true> {
 		      static void copy(Target& target, const Source& source) {
 		        target.clear();
 		        target.buildRev(source);
+		      }
 		    };
 		    template <typename Target, typename Source,
 		              bool revEnable = RevPathTagIndicator<Source>::value>
 		    struct PathCopySelector {
 		      static void copy(Target& target, const Source& source) {
 		        PathCopySelectorForward<Target, Source>::copy(target, source);
+		      }
 		    };
 		    template <typename Target, typename Source>
 		    struct PathCopySelector<Target, Source, true> {
 		      static void copy(Target& target, const Source& source) {
 		        PathCopySelectorBackward<Target, Source>::copy(target, source);
+		      }
 		    };
+		  }
 		  /// \brief Make a copy of a path.
 		  ///
 		  ///  This function makes a copy of a path.
 		  template <typename Target, typename Source>
 		  void copyPath(Target& target, const Source& source) {
 		    checkConcept<concepts::PathDumper<typename Source::Digraph>, Source>();
 		    _path_bits::PathCopySelector<Target, Source>::copy(target, source);
+		  }
 		  /// \brief Check the consistency of a path.
 		  ///
 		  /// This function checks that the target of each arc is the same
 		  /// as the source of the next one.
 		  ///
 		  template <typename Digraph, typename Path>
 		  bool checkPath(const Digraph& digraph, const Path& path) {
 		    typename Path::ArcIt it(path);
 		    if (it == INVALID) return true;
 		    typename Digraph::Node node = digraph.target(it);
 		    ++it;
 		    while (it != INVALID) {
 		      if (digraph.source(it) != node) return false;
 		      node = digraph.target(it);
 		      ++it;
+		    }
 		    return true;
+		  }
 		  /// \brief The source of a path
 		  ///
 		  /// This function returns the source of the given path.
 		  template <typename Digraph, typename Path>
 		  typename Digraph::Node pathSource(const Digraph& digraph, const Path& path) {
 		    return digraph.source(path.front());
+		  }
 		  /// \brief The target of a path
 		  ///
 		  /// This function returns the target of the given path.
 		  template <typename Digraph, typename Path>
 		  typename Digraph::Node pathTarget(const Digraph& digraph, const Path& path) {
 		    return digraph.target(path.back());
+		  }
 		  /// \brief Class which helps to iterate through the nodes of a path
 		  ///
 		  /// In a sense, the path can be treated as a list of arcs. The
 		  /// lemon path type stores only this list. As a consequence, it
 		  /// cannot enumerate the nodes in the path and the zero length paths
 		  /// cannot have a source node.
 		  ///
 		  /// This class implements the node iterator of a path structure. To
 		  /// provide this feature, the underlying digraph should be passed to
 		  /// the constructor of the iterator.
 		  template <typename Path>
 		  class PathNodeIt {
 		  private:
 		    const typename Path::Digraph *_digraph;
 		    typename Path::ArcIt _it;
 		    typename Path::Digraph::Node _nd;
 		  public:
 		    typedef typename Path::Digraph Digraph;
 		    typedef typename Digraph::Node Node;
 		    /// Default constructor
 		    PathNodeIt() {}
 		    /// Invalid constructor
 		    PathNodeIt(Invalid)
 		      : _digraph(0), _it(INVALID), _nd(INVALID) {}
 		    /// Constructor
 		    PathNodeIt(const Digraph& digraph, const Path& path)
 		      : _digraph(&digraph), _it(path) {
 		      _nd = (_it != INVALID ? _digraph->source(_it) : INVALID);
+		    }
 		    /// Constructor
 		    PathNodeIt(const Digraph& digraph, const Path& path, const Node& src)
 		      : _digraph(&digraph), _it(path), _nd(src) {}
 		    ///Conversion to Digraph::Node
 		    operator Node() const {
 		      return _nd;
+		    }
 		    /// Next node
 		    PathNodeIt& operator++() {
 		      if (_it == INVALID) _nd = INVALID;
 		      else {
 		        _nd = _digraph->target(_it);
 		        ++_it;
+		      }
 		      return *this;
+		    }
 		    /// Comparison operator
 		    bool operator==(const PathNodeIt& n) const {
 		      return _it == n._it && _nd == n._nd;
+		    }
 		    /// Comparison operator
 		    bool operator!=(const PathNodeIt& n) const {
 		      return _it != n._it || _nd != n._nd;
+		    }
 		    /// Comparison operator
 		    bool operator<(const PathNodeIt& n) const {
 		      return (_it < n._it && _nd != INVALID);
+		    }
 		  };
 		  ///@}
 		} // namespace lemon
 		#endif // LEMON_PATH_H

lemon/random.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2009
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		/*
 		 * This file contains the reimplemented version of the Mersenne Twister
 		 * Generator of Matsumoto and Nishimura.
+		 *
 		 * See the appropriate copyright notice below.
+		 *
 		 * Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
 		 * All rights reserved.
+		 *
 		 * Redistribution and use in source and binary forms, with or without
 		 * modification, are permitted provided that the following conditions
 		 * are met:
+		 *
 		 * 1. Redistributions of source code must retain the above copyright
 		 *    notice, this list of conditions and the following disclaimer.
+		 *
 		 * 2. Redistributions in binary form must reproduce the above copyright
 		 *    notice, this list of conditions and the following disclaimer in the
 		 *    documentation and/or other materials provided with the distribution.
+		 *
 		 * 3. The names of its contributors may not be used to endorse or promote
 		 *    products derived from this software without specific prior written
 		 *    permission.
+		 *
 		 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 		 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 		 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 		 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
 		 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 		 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 		 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 		 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 		 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 		 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 		 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 		 * OF THE POSSIBILITY OF SUCH DAMAGE.
+		 *
+		 *
 		 * Any feedback is very welcome.
 		 * http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
 		 * email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
 		 */
 		#ifndef LEMON_RANDOM_H
 		#define LEMON_RANDOM_H
 		#include <algorithm>
 		#include <iterator>
 		#include <vector>
 		#include <limits>
 		#include <fstream>
 		#include <lemon/math.h>
 		#include <lemon/dim2.h>
 		#ifndef WIN32
 		#include <sys/time.h>
 		#include <ctime>
 		#include <sys/types.h>
 		#include <unistd.h>
 		#else
 		#include <lemon/bits/windows.h>
 		#endif
 		///\ingroup misc
 		///\file
 		///\brief Mersenne Twister random number generator
 		namespace lemon {
 		  namespace _random_bits {
 		    template <typename _Word, int _bits = std::numeric_limits<_Word>::digits>
 		    struct RandomTraits {};
 		    template <typename _Word>
 		    struct RandomTraits<_Word, 32> {
 		      typedef _Word Word;
 		      static const int bits = 32;
 		      static const int length = 624;
 		      static const int shift = 397;
 		      static const Word mul = 0x6c078965u;
 		      static const Word arrayInit = 0x012BD6AAu;
 		      static const Word arrayMul1 = 0x0019660Du;
 		      static const Word arrayMul2 = 0x5D588B65u;
 		      static const Word mask = 0x9908B0DFu;
 		      static const Word loMask = (1u << 31) - 1;
 		      static const Word hiMask = ~loMask;
 		      static Word tempering(Word rnd) {
 		        rnd ^= (rnd >> 11);
 		        rnd ^= (rnd << 7) & 0x9D2C5680u;
 		        rnd ^= (rnd << 15) & 0xEFC60000u;
 		        rnd ^= (rnd >> 18);
 		        return rnd;
+		      }
 		    };
 		    template <typename _Word>
 		    struct RandomTraits<_Word, 64> {
 		      typedef _Word Word;
 		      static const int bits = 64;
 		      static const int length = 312;
 		      static const int shift = 156;
 		      static const Word mul = Word(0x5851F42Du) << 32 | Word(0x4C957F2Du);
 		      static const Word arrayInit = Word(0x00000000u) << 32 |Word(0x012BD6AAu);
 		      static const Word arrayMul1 = Word(0x369DEA0Fu) << 32 |Word(0x31A53F85u);
 		      static const Word arrayMul2 = Word(0x27BB2EE6u) << 32 |Word(0x87B0B0FDu);
 		      static const Word mask = Word(0xB5026F5Au) << 32 | Word(0xA96619E9u);
 		      static const Word loMask = (Word(1u) << 31) - 1;
 		      static const Word hiMask = ~loMask;
 		      static Word tempering(Word rnd) {
 		        rnd ^= (rnd >> 29) & (Word(0x55555555u) << 32 | Word(0x55555555u));
 		        rnd ^= (rnd << 17) & (Word(0x71D67FFFu) << 32 | Word(0xEDA60000u));
 		        rnd ^= (rnd << 37) & (Word(0xFFF7EEE0u) << 32 | Word(0x00000000u));
 		        rnd ^= (rnd >> 43);
 		        return rnd;
+		      }
 		    };
 		    template <typename _Word>
 		    class RandomCore {
 		    public:
 		      typedef _Word Word;
 		    private:
 		      static const int bits = RandomTraits<Word>::bits;
 		      static const int length = RandomTraits<Word>::length;
 		      static const int shift = RandomTraits<Word>::shift;
 		    public:
 		      void initState() {
 		        static const Word seedArray[4] = {
 x12345u, 0x23456u, 0x34567u, 0x45678u
 		        };
 		        initState(seedArray, seedArray + 4);
+		      }
 		      void initState(Word seed) {
 		        static const Word mul = RandomTraits<Word>::mul;
 		        current = state;
 		        Word *curr = state + length - 1;
 		        curr[0] = seed; --curr;
 		        for (int i = 1; i < length; ++i) {
 		          curr[0] = (mul * ( curr[1] ^ (curr[1] >> (bits - 2)) ) + i);
 		          --curr;
+		        }
+		      }
 		      template <typename Iterator>
 		      void initState(Iterator begin, Iterator end) {
 		        static const Word init = RandomTraits<Word>::arrayInit;
 		        static const Word mul1 = RandomTraits<Word>::arrayMul1;
 		        static const Word mul2 = RandomTraits<Word>::arrayMul2;
 		        Word *curr = state + length - 1; --curr;
 		        Iterator it = begin; int cnt = 0;
 		        int num;
 		        initState(init);
 		        num = length > end - begin ? length : end - begin;
 		        while (num--) {
 		          curr[0] = (curr[0] ^ ((curr[1] ^ (curr[1] >> (bits - 2))) * mul1))
 		            + *it + cnt;
 		          ++it; ++cnt;
 		          if (it == end) {
 		            it = begin; cnt = 0;
+		          }
 		          if (curr == state) {
 		            curr = state + length - 1; curr[0] = state[0];
+		          }
 		          --curr;
+		        }
 		        num = length - 1; cnt = length - (curr - state) - 1;
 		        while (num--) {
 		          curr[0] = (curr[0] ^ ((curr[1] ^ (curr[1] >> (bits - 2))) * mul2))
 		            - cnt;
 		          --curr; ++cnt;
 		          if (curr == state) {
 		            curr = state + length - 1; curr[0] = state[0]; --curr;
 		            cnt = 1;
+		          }
+		        }
 		        state[length - 1] = Word(1) << (bits - 1);
+		      }
 		      void copyState(const RandomCore& other) {
 		        std::copy(other.state, other.state + length, state);
 		        current = state + (other.current - other.state);
+		      }
 		      Word operator()() {
 		        if (current == state) fillState();
 		        --current;
 		        Word rnd = *current;
 		        return RandomTraits<Word>::tempering(rnd);
+		      }
 		    private:
 		      void fillState() {
 		        static const Word mask[2] = { 0x0ul, RandomTraits<Word>::mask };
 		        static const Word loMask = RandomTraits<Word>::loMask;
 		        static const Word hiMask = RandomTraits<Word>::hiMask;
 		        current = state + length;
 		        register Word *curr = state + length - 1;
 		        register long num;
 		        num = length - shift;
 		        while (num--) {
 		          curr[0] = (((curr[0] & hiMask) | (curr[-1] & loMask)) >> 1) ^
 		            curr[- shift] ^ mask[curr[-1] & 1ul];
 		          --curr;
+		        }
 		        num = shift - 1;
 		        while (num--) {
 		          curr[0] = (((curr[0] & hiMask) | (curr[-1] & loMask)) >> 1) ^
 		            curr[length - shift] ^ mask[curr[-1] & 1ul];
 		          --curr;
+		        }
 		        state[0] = (((state[0] & hiMask) | (curr[length - 1] & loMask)) >> 1) ^
 		          curr[length - shift] ^ mask[curr[length - 1] & 1ul];
+		      }
 		      Word *current;
 		      Word state[length];
 		    };
 		    template <typename Result,
 		              int shift = (std::numeric_limits<Result>::digits + 1) / 2>
 		    struct Masker {
 		      static Result mask(const Result& result) {
 		        return Masker<Result, (shift + 1) / 2>::
 		          mask(static_cast<Result>(result | (result >> shift)));
+		      }
 		    };
 		    template <typename Result>
 		    struct Masker<Result, 1> {
 		      static Result mask(const Result& result) {
 		        return static_cast<Result>(result | (result >> 1));
+		      }
 		    };
 		    template <typename Result, typename Word,
 		              int rest = std::numeric_limits<Result>::digits, int shift = 0,
 		              bool last = rest <= std::numeric_limits<Word>::digits>
 		    struct IntConversion {
 		      static const int bits = std::numeric_limits<Word>::digits;
 		      static Result convert(RandomCore<Word>& rnd) {
 		        return static_cast<Result>(rnd() >> (bits - rest)) << shift;
+		      }
 		    };
 		    template <typename Result, typename Word, int rest, int shift>
 		    struct IntConversion<Result, Word, rest, shift, false> {
 		      static const int bits = std::numeric_limits<Word>::digits;
 		      static Result convert(RandomCore<Word>& rnd) {
 		        return (static_cast<Result>(rnd()) << shift) |
 		          IntConversion<Result, Word, rest - bits, shift + bits>::convert(rnd);
+		      }
 		    };
 		    template <typename Result, typename Word,
 		              bool one_word = (std::numeric_limits<Word>::digits <
 		                               std::numeric_limits<Result>::digits) >
 		    struct Mapping {
 		      static Result map(RandomCore<Word>& rnd, const Result& bound) {
 		        Word max = Word(bound - 1);
 		        Result mask = Masker<Result>::mask(bound - 1);
 		        Result num;
 		        do {
 		          num = IntConversion<Result, Word>::convert(rnd) & mask;
 		        } while (num > max);
 		        return num;
+		      }
 		    };
 		    template <typename Result, typename Word>
 		    struct Mapping<Result, Word, false> {
 		      static Result map(RandomCore<Word>& rnd, const Result& bound) {
 		        Word max = Word(bound - 1);
 		        Word mask = Masker<Word, (std::numeric_limits<Result>::digits + 1) / 2>
 		          ::mask(max);
 		        Word num;
 		        do {
 		          num = rnd() & mask;
 		        } while (num > max);
 		        return num;
+		      }
 		    };
-		    template <typename Result, int exp, bool pos = (exp >= 0)>
 		    template <typename Result, int exp>
 		    struct ShiftMultiplier {
 		      static const Result multiplier() {
 		        Result res = ShiftMultiplier<Result, exp / 2>::multiplier();
 		        res *= res;
 		        if ((exp & 1) == 1) res *= static_cast<Result>(2.0);
 		        return res;
+		      }
 		    };
 		    template <typename Result, int exp>
 		    struct ShiftMultiplier<Result, exp, false> {
 		      static const Result multiplier() {
 		        Result res = ShiftMultiplier<Result, exp / 2>::multiplier();
 		        res *= res;
 		        if ((exp & 1) == 1) res *= static_cast<Result>(0.5);
 		        return res;
+		      }
 		    };
 		    template <typename Result>
-		    struct ShiftMultiplier<Result, 0, true> {
 		    struct ShiftMultiplier<Result, 0> {
 		      static const Result multiplier() {
 		        return static_cast<Result>(1.0);
+		      }
 		    };
 		    template <typename Result>
-		    struct ShiftMultiplier<Result, -20, true> {
 		    struct ShiftMultiplier<Result, 20> {
 		      static const Result multiplier() {
 		        return static_cast<Result>(1.0/1048576.0);
+		      }
 		    };
 		    template <typename Result>
-		    struct ShiftMultiplier<Result, -32, true> {
 		    struct ShiftMultiplier<Result, 32> {
 		      static const Result multiplier() {
-		        return static_cast<Result>(1.0/424967296.0);
+		        return static_cast<Result>(1.0/4294967296.0);
+		      }
 		    };
 		    template <typename Result>
-		    struct ShiftMultiplier<Result, -53, true> {
 		    struct ShiftMultiplier<Result, 53> {
 		      static const Result multiplier() {
 		        return static_cast<Result>(1.0/9007199254740992.0);
+		      }
 		    };
 		    template <typename Result>
-		    struct ShiftMultiplier<Result, -64, true> {
 		    struct ShiftMultiplier<Result, 64> {
 		      static const Result multiplier() {
 		        return static_cast<Result>(1.0/18446744073709551616.0);
+		      }
 		    };
 		    template <typename Result, int exp>
 		    struct Shifting {
 		      static Result shift(const Result& result) {
 		        return result * ShiftMultiplier<Result, exp>::multiplier();
+		      }
 		    };
 		    template <typename Result, typename Word,
 		              int rest = std::numeric_limits<Result>::digits, int shift = 0,
 		              bool last = rest <= std::numeric_limits<Word>::digits>
 		    struct RealConversion{
 		      static const int bits = std::numeric_limits<Word>::digits;
 		      static Result convert(RandomCore<Word>& rnd) {
-		        return Shifting<Result, - shift - rest>::
+		        return Shifting<Result, shift + rest>::
 		          shift(static_cast<Result>(rnd() >> (bits - rest)));
+		      }
 		    };
 		    template <typename Result, typename Word, int rest, int shift>
 		    struct RealConversion<Result, Word, rest, shift, false> {
 		      static const int bits = std::numeric_limits<Word>::digits;
 		      static Result convert(RandomCore<Word>& rnd) {
-		        return Shifting<Result, - shift - bits>::
+		        return Shifting<Result, shift + bits>::
 		          shift(static_cast<Result>(rnd())) +
 		          RealConversion<Result, Word, rest-bits, shift + bits>::
 		          convert(rnd);
+		      }
 		    };
 		    template <typename Result, typename Word>
 		    struct Initializer {
 		      template <typename Iterator>
 		      static void init(RandomCore<Word>& rnd, Iterator begin, Iterator end) {
 		        std::vector<Word> ws;
 		        for (Iterator it = begin; it != end; ++it) {
 		          ws.push_back(Word(*it));
+		        }
 		        rnd.initState(ws.begin(), ws.end());
+		      }
 		      static void init(RandomCore<Word>& rnd, Result seed) {
 		        rnd.initState(seed);
+		      }
 		    };
 		    template <typename Word>
 		    struct BoolConversion {
 		      static bool convert(RandomCore<Word>& rnd) {
 		        return (rnd() & 1) == 1;
+		      }
 		    };
 		    template <typename Word>
 		    struct BoolProducer {
 		      Word buffer;
 		      int num;
 		      BoolProducer() : num(0) {}
 		      bool convert(RandomCore<Word>& rnd) {
 		        if (num == 0) {
 		          buffer = rnd();
 		          num = RandomTraits<Word>::bits;
+		        }
 		        bool r = (buffer & 1);
 		        buffer >>= 1;
 		        --num;
 		        return r;
+		      }
 		    };
+		  }
 		  /// \ingroup misc
 		  ///
 		  /// \brief Mersenne Twister random number generator
 		  ///
 		  /// The Mersenne Twister is a twisted generalized feedback
 		  /// shift-register generator of Matsumoto and Nishimura. The period
 		  /// of this generator is \f$ 2^{19937} - 1 \f$ and it is
 		  /// equi-distributed in 623 dimensions for 32-bit numbers. The time
 		  /// performance of this generator is comparable to the commonly used
 		  /// generators.
 		  ///
 		  /// This implementation is specialized for both 32-bit and 64-bit
 		  /// architectures. The generators differ sligthly in the
 		  /// initialization and generation phase so they produce two
 		  /// completly different sequences.
 		  ///
 		  /// The generator gives back random numbers of serveral types. To
 		  /// get a random number from a range of a floating point type you
 		  /// can use one form of the \c operator() or the \c real() member
 		  /// function. If you want to get random number from the {0, 1, ...,
 		  /// n-1} integer range use the \c operator[] or the \c integer()
 		  /// method. And to get random number from the whole range of an
 		  /// integer type you can use the argumentless \c integer() or \c
 		  /// uinteger() functions. After all you can get random bool with
 		  /// equal chance of true and false or given probability of true
 		  /// result with the \c boolean() member functions.
 		  ///
 		  ///\code
 		  /// // The commented code is identical to the other
 		  /// double a = rnd();                     // [0.0, 1.0)
 		  /// // double a = rnd.real();             // [0.0, 1.0)
 		  /// double b = rnd(100.0);                // [0.0, 100.0)
 		  /// // double b = rnd.real(100.0);        // [0.0, 100.0)
 		  /// double c = rnd(1.0, 2.0);             // [1.0, 2.0)
 		  /// // double c = rnd.real(1.0, 2.0);     // [1.0, 2.0)
 		  /// int d = rnd[100000];                  // 0..99999
 		  /// // int d = rnd.integer(100000);       // 0..99999
 		  /// int e = rnd[6] + 1;                   // 1..6
 		  /// // int e = rnd.integer(1, 1 + 6);     // 1..6
 		  /// int b = rnd.uinteger<int>();          // 0 .. 2^31 - 1
 		  /// int c = rnd.integer<int>();           // - 2^31 .. 2^31 - 1
 		  /// bool g = rnd.boolean();               // P(g = true) = 0.5
 		  /// bool h = rnd.boolean(0.8);            // P(h = true) = 0.8
 		  ///\endcode
 		  ///
 		  /// LEMON provides a global instance of the random number
 		  /// generator which name is \ref lemon::rnd "rnd". Usually it is a
 		  /// good programming convenience to use this global generator to get
 		  /// random numbers.
 		  class Random {
 		  private:
 		    // Architecture word
 		    typedef unsigned long Word;
 		    _random_bits::RandomCore<Word> core;
 		    _random_bits::BoolProducer<Word> bool_producer;
 		  public:
 		    ///\name Initialization
 		    ///
 		    /// @{
 		    /// \brief Default constructor
 		    ///
 		    /// Constructor with constant seeding.
 		    Random() { core.initState(); }
 		    /// \brief Constructor with seed
 		    ///
 		    /// Constructor with seed. The current number type will be converted
 		    /// to the architecture word type.
 		    template <typename Number>
 		    Random(Number seed) {
 		      _random_bits::Initializer<Number, Word>::init(core, seed);
+		    }
 		    /// \brief Constructor with array seeding
 		    ///
 		    /// Constructor with array seeding. The given range should contain
 		    /// any number type and the numbers will be converted to the
 		    /// architecture word type.
 		    template <typename Iterator>
 		    Random(Iterator begin, Iterator end) {
 		      typedef typename std::iterator_traits<Iterator>::value_type Number;
 		      _random_bits::Initializer<Number, Word>::init(core, begin, end);
+		    }
 		    /// \brief Copy constructor
 		    ///
 		    /// Copy constructor. The generated sequence will be identical to
 		    /// the other sequence. It can be used to save the current state
 		    /// of the generator and later use it to generate the same
 		    /// sequence.
 		    Random(const Random& other) {
 		      core.copyState(other.core);
+		    }
 		    /// \brief Assign operator
 		    ///
 		    /// Assign operator. The generated sequence will be identical to
 		    /// the other sequence. It can be used to save the current state
 		    /// of the generator and later use it to generate the same
 		    /// sequence.
 		    Random& operator=(const Random& other) {
 		      if (&other != this) {
 		        core.copyState(other.core);
+		      }
 		      return *this;
+		    }
 		    /// \brief Seeding random sequence
 		    ///
 		    /// Seeding the random sequence. The current number type will be
 		    /// converted to the architecture word type.
 		    template <typename Number>
 		    void seed(Number seed) {
 		      _random_bits::Initializer<Number, Word>::init(core, seed);
+		    }
 		    /// \brief Seeding random sequence
 		    ///
 		    /// Seeding the random sequence. The given range should contain
 		    /// any number type and the numbers will be converted to the
 		    /// architecture word type.
 		    template <typename Iterator>
 		    void seed(Iterator begin, Iterator end) {
 		      typedef typename std::iterator_traits<Iterator>::value_type Number;
 		      _random_bits::Initializer<Number, Word>::init(core, begin, end);
+		    }
 		    /// \brief Seeding from file or from process id and time
 		    ///
 		    /// By default, this function calls the \c seedFromFile() member
 		    /// function with the <tt>/dev/urandom</tt> file. If it does not success,
 		    /// it uses the \c seedFromTime().
 		    /// \return Currently always true.
 		    bool seed() {
 		#ifndef WIN32
 		      if (seedFromFile("/dev/urandom", 0)) return true;
 		#endif
 		      if (seedFromTime()) return true;
 		      return false;
+		    }
 		    /// \brief Seeding from file
 		    ///
 		    /// Seeding the random sequence from file. The linux kernel has two
 		    /// devices, <tt>/dev/random</tt> and <tt>/dev/urandom</tt> which
 		    /// could give good seed values for pseudo random generators (The
 		    /// difference between two devices is that the <tt>random</tt> may
 		    /// block the reading operation while the kernel can give good
 		    /// source of randomness, while the <tt>urandom</tt> does not
 		    /// block the input, but it could give back bytes with worse
 		    /// entropy).
 		    /// \param file The source file
 		    /// \param offset The offset, from the file read.
 		    /// \return True when the seeding successes.
 		#ifndef WIN32
 		    bool seedFromFile(const std::string& file = "/dev/urandom", int offset = 0)
 		#else
 		    bool seedFromFile(const std::string& file = "", int offset = 0)
 		#endif
+		    {
 		      std::ifstream rs(file.c_str());
 		      const int size = 4;
 		      Word buf[size];
 		      if (offset != 0 && !rs.seekg(offset)) return false;
 		      if (!rs.read(reinterpret_cast<char*>(buf), sizeof(buf))) return false;
 		      seed(buf, buf + size);
 		      return true;
+		    }
 		    /// \brief Seding from process id and time
 		    ///
 		    /// Seding from process id and time. This function uses the
 		    /// current process id and the current time for initialize the
 		    /// random sequence.
 		    /// \return Currently always true.
 		    bool seedFromTime() {
 		#ifndef WIN32
 		      timeval tv;
 		      gettimeofday(&tv, 0);
 		      seed(getpid() + tv.tv_sec + tv.tv_usec);
 		#else
 		      seed(bits::getWinRndSeed());
 		#endif
 		      return true;
+		    }
 		    /// @}
 		    ///\name Uniform distributions
 		    ///
 		    /// @{
 		    /// \brief Returns a random real number from the range [0, 1)
 		    ///
 		    /// It returns a random real number from the range [0, 1). The
 		    /// default Number type is \c double.
 		    template <typename Number>
 		    Number real() {
 		      return _random_bits::RealConversion<Number, Word>::convert(core);
+		    }
 		    double real() {
 		      return real<double>();
+		    }
 		    /// \brief Returns a random real number from the range [0, 1)
 		    ///
 		    /// It returns a random double from the range [0, 1).
 		    double operator()() {
 		      return real<double>();
+		    }
 		    /// \brief Returns a random real number from the range [0, b)
 		    ///
 		    /// It returns a random real number from the range [0, b).
 		    double operator()(double b) {
 		      return real<double>() * b;
+		    }
 		    /// \brief Returns a random real number from the range [a, b)
 		    ///
 		    /// It returns a random real number from the range [a, b).
 		    double operator()(double a, double b) {
 		      return real<double>() * (b - a) + a;
+		    }
 		    /// \brief Returns a random integer from a range
 		    ///
 		    /// It returns a random integer from the range {0, 1, ..., b - 1}.
 		    template <typename Number>
 		    Number integer(Number b) {
 		      return _random_bits::Mapping<Number, Word>::map(core, b);
+		    }
 		    /// \brief Returns a random integer from a range
 		    ///
 		    /// It returns a random integer from the range {a, a + 1, ..., b - 1}.
 		    template <typename Number>
 		    Number integer(Number a, Number b) {
 		      return _random_bits::Mapping<Number, Word>::map(core, b - a) + a;
+		    }
 		    /// \brief Returns a random integer from a range
 		    ///
 		    /// It returns a random integer from the range {0, 1, ..., b - 1}.
 		    template <typename Number>
 		    Number operator[](Number b) {
 		      return _random_bits::Mapping<Number, Word>::map(core, b);
+		    }
 		    /// \brief Returns a random non-negative integer
 		    ///
 		    /// It returns a random non-negative integer uniformly from the
 		    /// whole range of the current \c Number type. The default result
 		    /// type of this function is <tt>unsigned int</tt>.
 		    template <typename Number>
 		    Number uinteger() {
 		      return _random_bits::IntConversion<Number, Word>::convert(core);
+		    }
 		    unsigned int uinteger() {
 		      return uinteger<unsigned int>();
+		    }
 		    /// \brief Returns a random integer
 		    ///
 		    /// It returns a random integer uniformly from the whole range of
 		    /// the current \c Number type. The default result type of this
 		    /// function is \c int.
 		    template <typename Number>
 		    Number integer() {
 		      static const int nb = std::numeric_limits<Number>::digits +
 		        (std::numeric_limits<Number>::is_signed ? 1 : 0);
 		      return _random_bits::IntConversion<Number, Word, nb>::convert(core);
+		    }
 		    int integer() {
 		      return integer<int>();
+		    }
 		    /// \brief Returns a random bool
 		    ///
 		    /// It returns a random bool. The generator holds a buffer for
 		    /// random bits. Every time when it become empty the generator makes
 		    /// a new random word and fill the buffer up.
 		    bool boolean() {
 		      return bool_producer.convert(core);
+		    }
 		    /// @}
 		    ///\name Non-uniform distributions
 		    ///
 		    ///@{
 		    /// \brief Returns a random bool with given probability of true result.
 		    ///
 		    /// It returns a random bool with given probability of true result.
 		    bool boolean(double p) {
 		      return operator()() < p;
+		    }
 		    /// Standard normal (Gauss) distribution
 		    /// Standard normal (Gauss) distribution.
 		    /// \note The Cartesian form of the Box-Muller
 		    /// transformation is used to generate a random normal distribution.
 		    double gauss()
+		    {
 		      double V1,V2,S;
 		      do {
 		        V1=2*real<double>()-1;
 		        V2=2*real<double>()-1;
 		        S=V1*V1+V2*V2;
 		      } while(S>=1);
 		      return std::sqrt(-2*std::log(S)/S)*V1;
+		    }
 		    /// Normal (Gauss) distribution with given mean and standard deviation
 		    /// Normal (Gauss) distribution with given mean and standard deviation.
 		    /// \sa gauss()
 		    double gauss(double mean,double std_dev)
+		    {
 		      return gauss()*std_dev+mean;
+		    }
 		    /// Lognormal distribution
 		    /// Lognormal distribution. The parameters are the mean and the standard
 		    /// deviation of <tt>exp(X)</tt>.
 		    ///
 		    double lognormal(double n_mean,double n_std_dev)
+		    {
 		      return std::exp(gauss(n_mean,n_std_dev));
+		    }
 		    /// Lognormal distribution
 		    /// Lognormal distribution. The parameter is an <tt>std::pair</tt> of
 		    /// the mean and the standard deviation of <tt>exp(X)</tt>.
 		    ///
 		    double lognormal(const std::pair<double,double> &params)
+		    {
 		      return std::exp(gauss(params.first,params.second));
+		    }
 		    /// Compute the lognormal parameters from mean and standard deviation
 		    /// This function computes the lognormal parameters from mean and
 		    /// standard deviation. The return value can direcly be passed to
 		    /// lognormal().
 		    std::pair<double,double> lognormalParamsFromMD(double mean,
 		                                                   double std_dev)
+		    {
 		      double fr=std_dev/mean;
 		      fr*=fr;
 		      double lg=std::log(1+fr);
 		      return std::pair<double,double>(std::log(mean)-lg/2.0,std::sqrt(lg));
+		    }
 		    /// Lognormal distribution with given mean and standard deviation
 		    /// Lognormal distribution with given mean and standard deviation.
 		    ///
 		    double lognormalMD(double mean,double std_dev)
+		    {
 		      return lognormal(lognormalParamsFromMD(mean,std_dev));
+		    }
 		    /// Exponential distribution with given mean
 		    /// This function generates an exponential distribution random number
 		    /// with mean <tt>1/lambda</tt>.
 		    ///
 		    double exponential(double lambda=1.0)
+		    {
 		      return -std::log(1.0-real<double>())/lambda;
+		    }
 		    /// Gamma distribution with given integer shape
 		    /// This function generates a gamma distribution random number.
 		    ///
 		    ///\param k shape parameter (<tt>k>0</tt> integer)
 		    double gamma(int k)
+		    {
 		      double s = 0;
 		      for(int i=0;i<k;i++) s-=std::log(1.0-real<double>());
 		      return s;
+		    }
 		    /// Gamma distribution with given shape and scale parameter
 		    /// This function generates a gamma distribution random number.
 		    ///
 		    ///\param k shape parameter (<tt>k>0</tt>)
 		    ///\param theta scale parameter
 		    ///
 		    double gamma(double k,double theta=1.0)
+		    {
 		      double xi,nu;
 		      const double delta = k-std::floor(k);
 		      const double v0=E/(E-delta);
 		      do {
 		        double V0=1.0-real<double>();
 		        double V1=1.0-real<double>();
 		        double V2=1.0-real<double>();
 		        if(V2<=v0)
+		          {
 		            xi=std::pow(V1,1.0/delta);
 		            nu=V0*std::pow(xi,delta-1.0);
+		          }
 		        else
+		          {
 		            xi=1.0-std::log(V1);
 		            nu=V0*std::exp(-xi);
+		          }
 		      } while(nu>std::pow(xi,delta-1.0)*std::exp(-xi));
 		      return theta*(xi+gamma(int(std::floor(k))));
+		    }
 		    /// Weibull distribution
 		    /// This function generates a Weibull distribution random number.
 		    ///
 		    ///\param k shape parameter (<tt>k>0</tt>)
 		    ///\param lambda scale parameter (<tt>lambda>0</tt>)
 		    ///
 		    double weibull(double k,double lambda)
+		    {
 		      return lambda*pow(-std::log(1.0-real<double>()),1.0/k);
+		    }
 		    /// Pareto distribution
 		    /// This function generates a Pareto distribution random number.
 		    ///
 		    ///\param k shape parameter (<tt>k>0</tt>)
 		    ///\param x_min location parameter (<tt>x_min>0</tt>)
 		    ///
 		    double pareto(double k,double x_min)
+		    {
 		      return exponential(gamma(k,1.0/x_min))+x_min;
+		    }
 		    /// Poisson distribution
 		    /// This function generates a Poisson distribution random number with
 		    /// parameter \c lambda.
 		    ///
 		    /// The probability mass function of this distribusion is
 		    /// \f[ \frac{e^{-\lambda}\lambda^k}{k!} \f]
 		    /// \note The algorithm is taken from the book of Donald E. Knuth titled
 		    /// ''Seminumerical Algorithms'' (1969). Its running time is linear in the
 		    /// return value.
 		    int poisson(double lambda)
+		    {

lemon/tolerance.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2009
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_TOLERANCE_H
 		#define LEMON_TOLERANCE_H
 		///\ingroup misc
 		///\file
 		///\brief A basic tool to handle the anomalies of calculation with
 		///floating point numbers.
 		///
 		namespace lemon {
 		  /// \addtogroup misc
 		  /// @{
 		  ///\brief A class to provide a basic way to
 		  ///handle the comparison of numbers that are obtained
 		  ///as a result of a probably inexact computation.
 		  ///
 		  ///\ref Tolerance is a class to provide a basic way to
 		  ///handle the comparison of numbers that are obtained
 		  ///as a result of a probably inexact computation.
 		  ///
 		  ///This is an abstract class, it should be specialized for all
 		  ///numerical data types. These specialized classes like
 		  ///The general implementation is suitable only if the data type is exact,
 		  ///like the integer types, otherwise a specialized version must be
 		  ///implemented. These specialized classes like
 		  ///Tolerance<double> may offer additional tuning parameters.
 		  ///
 		  ///\sa Tolerance<float>
 		  ///\sa Tolerance<double>
 		  ///\sa Tolerance<long double>
 		  ///\sa Tolerance<int>
 		  ///\sa Tolerance<long long int>
 		  ///\sa Tolerance<unsigned int>
 		  ///\sa Tolerance<unsigned long long int>
 		  template<class T>
 		  class Tolerance
+		  {
 		  public:
 		    typedef T Value;
 		    ///\name Comparisons
 		    ///The concept is that these bool functions return \c true only if
 		    ///the related comparisons hold even if some numerical error appeared
 		    ///during the computations.
 		    ///@{
 		    ///Returns \c true if \c a is \e surely strictly less than \c b
-		    static bool less(Value a,Value b) {return false;}
+		    static bool less(Value a,Value b) {return a<b;}
 		    ///Returns \c true if \c a is \e surely different from \c b
-		    static bool different(Value a,Value b) {return false;}
+		    static bool different(Value a,Value b) {return a!=b;}
 		    ///Returns \c true if \c a is \e surely positive
-		    static bool positive(Value a) {return false;}
+		    static bool positive(Value a) {return static_cast<Value>(0) < a;}
 		    ///Returns \c true if \c a is \e surely negative
-		    static bool negative(Value a) {return false;}
+		    static bool negative(Value a) {return a < static_cast<Value>(0);}
 		    ///Returns \c true if \c a is \e surely non-zero
-		    static bool nonZero(Value a) {return false;}
+		    static bool nonZero(Value a) {return a != static_cast<Value>(0);}
 		    ///@}
 		    ///Returns the zero value.
-		    static Value zero() {return T();}
+		    static Value zero() {return static_cast<Value>(0);}
 		    //   static bool finite(Value a) {}
 		    //   static Value big() {}
 		    //   static Value negativeBig() {}
 		  };
 		  ///Float specialization of Tolerance.
 		  ///Float specialization of Tolerance.
 		  ///\sa Tolerance
 		  ///\relates Tolerance
 		  template<>
 		  class Tolerance<float>
+		  {
 		    static float def_epsilon;
 		    float _epsilon;
 		  public:
 		    ///\e
 		    typedef float Value;
 		    ///Constructor setting the epsilon tolerance to the default value.
 		    Tolerance() : _epsilon(def_epsilon) {}
 		    ///Constructor setting the epsilon tolerance to the given value.
 		    Tolerance(float e) : _epsilon(e) {}
 		    ///Returns the epsilon value.
 		    Value epsilon() const {return _epsilon;}
 		    ///Sets the epsilon value.
 		    void epsilon(Value e) {_epsilon=e;}
 		    ///Returns the default epsilon value.
 		    static Value defaultEpsilon() {return def_epsilon;}
 		    ///Sets the default epsilon value.
 		    static void defaultEpsilon(Value e) {def_epsilon=e;}
 		    ///\name Comparisons
 		    ///See \ref lemon::Tolerance "Tolerance" for more details.
 		    ///@{
 		    ///Returns \c true if \c a is \e surely strictly less than \c b
 		    bool less(Value a,Value b) const {return a+_epsilon<b;}
 		    ///Returns \c true if \c a is \e surely different from \c b
 		    bool different(Value a,Value b) const { return less(a,b)||less(b,a); }
 		    ///Returns \c true if \c a is \e surely positive
 		    bool positive(Value a) const { return _epsilon<a; }
 		    ///Returns \c true if \c a is \e surely negative
 		    bool negative(Value a) const { return -_epsilon>a; }
 		    ///Returns \c true if \c a is \e surely non-zero
 		    bool nonZero(Value a) const { return positive(a)||negative(a); }
 		    ///@}
 		    ///Returns zero
 		    static Value zero() {return 0;}
 		  };
 		  ///Double specialization of Tolerance.
 		  ///Double specialization of Tolerance.
 		  ///\sa Tolerance
 		  ///\relates Tolerance
 		  template<>
 		  class Tolerance<double>
+		  {
 		    static double def_epsilon;
 		    double _epsilon;
 		  public:
 		    ///\e
 		    typedef double Value;
 		    ///Constructor setting the epsilon tolerance to the default value.
 		    Tolerance() : _epsilon(def_epsilon) {}
 		    ///Constructor setting the epsilon tolerance to the given value.
 		    Tolerance(double e) : _epsilon(e) {}
 		    ///Returns the epsilon value.
 		    Value epsilon() const {return _epsilon;}
 		    ///Sets the epsilon value.
 		    void epsilon(Value e) {_epsilon=e;}
 		    ///Returns the default epsilon value.
 		    static Value defaultEpsilon() {return def_epsilon;}
 		    ///Sets the default epsilon value.
 		    static void defaultEpsilon(Value e) {def_epsilon=e;}
 		    ///\name Comparisons
 		    ///See \ref lemon::Tolerance "Tolerance" for more details.
 		    ///@{
 		    ///Returns \c true if \c a is \e surely strictly less than \c b
 		    bool less(Value a,Value b) const {return a+_epsilon<b;}
 		    ///Returns \c true if \c a is \e surely different from \c b
 		    bool different(Value a,Value b) const { return less(a,b)||less(b,a); }
 		    ///Returns \c true if \c a is \e surely positive
 		    bool positive(Value a) const { return _epsilon<a; }
 		    ///Returns \c true if \c a is \e surely negative
 		    bool negative(Value a) const { return -_epsilon>a; }
 		    ///Returns \c true if \c a is \e surely non-zero
 		    bool nonZero(Value a) const { return positive(a)||negative(a); }
 		    ///@}
 		    ///Returns zero
 		    static Value zero() {return 0;}
 		  };
 		  ///Long double specialization of Tolerance.
 		  ///Long double specialization of Tolerance.
 		  ///\sa Tolerance
 		  ///\relates Tolerance
 		  template<>
 		  class Tolerance<long double>
+		  {
 		    static long double def_epsilon;
 		    long double _epsilon;
 		  public:
 		    ///\e
 		    typedef long double Value;
 		    ///Constructor setting the epsilon tolerance to the default value.
 		    Tolerance() : _epsilon(def_epsilon) {}
 		    ///Constructor setting the epsilon tolerance to the given value.
 		    Tolerance(long double e) : _epsilon(e) {}
 		    ///Returns the epsilon value.
 		    Value epsilon() const {return _epsilon;}
 		    ///Sets the epsilon value.
 		    void epsilon(Value e) {_epsilon=e;}
 		    ///Returns the default epsilon value.
 		    static Value defaultEpsilon() {return def_epsilon;}
 		    ///Sets the default epsilon value.
 		    static void defaultEpsilon(Value e) {def_epsilon=e;}
 		    ///\name Comparisons
 		    ///See \ref lemon::Tolerance "Tolerance" for more details.
 		    ///@{
 		    ///Returns \c true if \c a is \e surely strictly less than \c b
 		    bool less(Value a,Value b) const {return a+_epsilon<b;}
 		    ///Returns \c true if \c a is \e surely different from \c b
 		    bool different(Value a,Value b) const { return less(a,b)||less(b,a); }
 		    ///Returns \c true if \c a is \e surely positive
 		    bool positive(Value a) const { return _epsilon<a; }
 		    ///Returns \c true if \c a is \e surely negative
 		    bool negative(Value a) const { return -_epsilon>a; }
 		    ///Returns \c true if \c a is \e surely non-zero
 		    bool nonZero(Value a) const { return positive(a)||negative(a); }
 		    ///@}
 		    ///Returns zero
 		    static Value zero() {return 0;}
 		  };
 		  ///Integer specialization of Tolerance.
 		  ///Integer specialization of Tolerance.
 		  ///\sa Tolerance
 		  template<>
 		  class Tolerance<int>
+		  {
 		  public:
 		    ///\e
 		    typedef int Value;
 		    ///\name Comparisons
 		    ///See \ref lemon::Tolerance "Tolerance" for more details.
 		    ///@{
 		    ///Returns \c true if \c a is \e surely strictly less than \c b
 		    static bool less(Value a,Value b) { return a<b;}
 		    ///Returns \c true if \c a is \e surely different from \c b
 		    static bool different(Value a,Value b) { return a!=b; }
 		    ///Returns \c true if \c a is \e surely positive
 		    static bool positive(Value a) { return 0<a; }
 		    ///Returns \c true if \c a is \e surely negative
 		    static bool negative(Value a) { return 0>a; }
 		    ///Returns \c true if \c a is \e surely non-zero
 		    static bool nonZero(Value a) { return a!=0; }
 		    ///@}
 		    ///Returns zero
 		    static Value zero() {return 0;}
 		  };
 		  ///Unsigned integer specialization of Tolerance.
 		  ///Unsigned integer specialization of Tolerance.
 		  ///\sa Tolerance
 		  template<>
 		  class Tolerance<unsigned int>
+		  {
 		  public:
 		    ///\e
 		    typedef unsigned int Value;
 		    ///\name Comparisons
 		    ///See \ref lemon::Tolerance "Tolerance" for more details.
 		    ///@{
 		    ///Returns \c true if \c a is \e surely strictly less than \c b
 		    static bool less(Value a,Value b) { return a<b;}
 		    ///Returns \c true if \c a is \e surely different from \c b
 		    static bool different(Value a,Value b) { return a!=b; }
 		    ///Returns \c true if \c a is \e surely positive
 		    static bool positive(Value a) { return 0<a; }
 		    ///Returns \c true if \c a is \e surely negative
 		    static bool negative(Value) { return false; }
 		    ///Returns \c true if \c a is \e surely non-zero
 		    static bool nonZero(Value a) { return a!=0; }
 		    ///@}
 		    ///Returns zero
 		    static Value zero() {return 0;}
 		  };
 		  ///Long integer specialization of Tolerance.
 		  ///Long integer specialization of Tolerance.
 		  ///\sa Tolerance
 		  template<>
 		  class Tolerance<long int>
+		  {
 		  public:
 		    ///\e
 		    typedef long int Value;
 		    ///\name Comparisons
 		    ///See \ref lemon::Tolerance "Tolerance" for more details.
 		    ///@{
 		    ///Returns \c true if \c a is \e surely strictly less than \c b
 		    static bool less(Value a,Value b) { return a<b;}
 		    ///Returns \c true if \c a is \e surely different from \c b
 		    static bool different(Value a,Value b) { return a!=b; }
 		    ///Returns \c true if \c a is \e surely positive
 		    static bool positive(Value a) { return 0<a; }
 		    ///Returns \c true if \c a is \e surely negative
 		    static bool negative(Value a) { return 0>a; }
 		    ///Returns \c true if \c a is \e surely non-zero
 		    static bool nonZero(Value a) { return a!=0;}
 		    ///@}
 		    ///Returns zero
 		    static Value zero() {return 0;}
 		  };
 		  ///Unsigned long integer specialization of Tolerance.
 		  ///Unsigned long integer specialization of Tolerance.
 		  ///\sa Tolerance
 		  template<>
 		  class Tolerance<unsigned long int>
+		  {
 		  public:
 		    ///\e
 		    typedef unsigned long int Value;
 		    ///\name Comparisons
 		    ///See \ref lemon::Tolerance "Tolerance" for more details.
 		    ///@{
 		    ///Returns \c true if \c a is \e surely strictly less than \c b
 		    static bool less(Value a,Value b) { return a<b;}
 		    ///Returns \c true if \c a is \e surely different from \c b
 		    static bool different(Value a,Value b) { return a!=b; }
 		    ///Returns \c true if \c a is \e surely positive
 		    static bool positive(Value a) { return 0<a; }
 		    ///Returns \c true if \c a is \e surely negative
 		    static bool negative(Value) { return false; }
 		    ///Returns \c true if \c a is \e surely non-zero
 		    static bool nonZero(Value a) { return a!=0;}
 		    ///@}
 		    ///Returns zero
 		    static Value zero() {return 0;}
 		  };
 		#if defined __GNUC__ && !defined __STRICT_ANSI__
 		  ///Long long integer specialization of Tolerance.
 		  ///Long long integer specialization of Tolerance.
 		  ///\warning This class (more exactly, type <tt>long long</tt>)
 		  ///is not ansi compatible.
 		  ///\sa Tolerance
 		  template<>
 		  class Tolerance<long long int>
+		  {
 		  public:
 		    ///\e
 		    typedef long long int Value;
 		    ///\name Comparisons
 		    ///See \ref lemon::Tolerance "Tolerance" for more details.
 		    ///@{
 		    ///Returns \c true if \c a is \e surely strictly less than \c b
 		    static bool less(Value a,Value b) { return a<b;}
 		    ///Returns \c true if \c a is \e surely different from \c b
 		    static bool different(Value a,Value b) { return a!=b; }
 		    ///Returns \c true if \c a is \e surely positive
 		    static bool positive(Value a) { return 0<a; }
 		    ///Returns \c true if \c a is \e surely negative
 		    static bool negative(Value a) { return 0>a; }
 		    ///Returns \c true if \c a is \e surely non-zero
 		    static bool nonZero(Value a) { return a!=0;}
 		    ///@}
 		    ///Returns zero
 		    static Value zero() {return 0;}
 		  };
 		  ///Unsigned long long integer specialization of Tolerance.
 		  ///Unsigned long long integer specialization of Tolerance.
 		  ///\warning This class (more exactly, type <tt>unsigned long long</tt>)
 		  ///is not ansi compatible.
 		  ///\sa Tolerance
 		  template<>
 		  class Tolerance<unsigned long long int>
+		  {
 		  public:
 		    ///\e
 		    typedef unsigned long long int Value;
 		    ///\name Comparisons
 		    ///See \ref lemon::Tolerance "Tolerance" for more details.
 		    ///@{
 		    ///Returns \c true if \c a is \e surely strictly less than \c b
 		    static bool less(Value a,Value b) { return a<b;}
 		    ///Returns \c true if \c a is \e surely different from \c b
 		    static bool different(Value a,Value b) { return a!=b; }
 		    ///Returns \c true if \c a is \e surely positive
 		    static bool positive(Value a) { return 0<a; }
 		    ///Returns \c true if \c a is \e surely negative
 		    static bool negative(Value) { return false; }
 		    ///Returns \c true if \c a is \e surely non-zero
 		    static bool nonZero(Value a) { return a!=0;}
 		    ///@}
 		    ///Returns zero
 		    static Value zero() {return 0;}
 		  };
 		#endif
 		  /// @}
 		} //namespace lemon
 		#endif //LEMON_TOLERANCE_H

0 comments (0 inline)

RhodeCode

Login to your account