LEMON/LEMON-official Changeset - r327:12626fc94ccf

Repositories » LEMON » LEMON-official

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

Changeset - r327:12626fc94ccf

« 315:c175e3
« 326:de38fc

328:8c4d38 »

r327:12626fc94ccf

Thu, 09 Oct 2008 15:37:44

[Not Reviewed]

0 comments (0 inline)

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

Merge from trunk

1 38 2

merge 1.0

4 files changed with 1141 insertions and 956 deletions:

doc/migration.dox

143

tools/lemon-0.x-to-1.x.sh

127

Makefile.am

README

configure.ac

demo/arg_parser_demo.cc

demo/graph_to_eps_demo.cc

doc/Makefile.am

doc/groups.dox

doc/lgf.dox

doc/mainpage.dox

lemon/arg_parser.cc

lemon/arg_parser.h

lemon/bfs.h

lemon/bits/alteration_notifier.h

209

223

lemon/bits/array_map.h

lemon/bits/base_extender.h

lemon/bits/bezier.h

lemon/bits/default_map.h

lemon/bits/enable_if.h

lemon/bits/graph_extender.h

lemon/bits/map_extender.h

lemon/bits/traits.h

lemon/bits/vector_map.h

lemon/color.h

lemon/concepts/graph_components.h

lemon/concepts/maps.h

lemon/core.h

lemon/dfs.h

lemon/dijkstra.h

lemon/dim2.h

lemon/graph_to_eps.h

lemon/lgf_reader.h

lemon/lgf_writer.h

lemon/list_graph.h

lemon/maps.h

lemon/path.h

lemon/smart_graph.h

lemon/time_measure.h

tools/Makefile.am

benchmark/Makefile.am

↑ Collapse diff ↑

doc/migration.dox

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		namespace lemon {
 		/*!
 		\page migration Migration from the 0.x Series
 		This guide gives an in depth description on what has changed compared
 		to the 0.x release series.
 		Many of these changes adjusted automatically by the
 		<tt>script/lemon-0.x-to-1.x.sh</tt> tool. Those requiring manual
 		update are typeset <b>boldface</b>.
 		\section migration-graph Graph Related Name Changes
 		- \ref concepts::Digraph "Directed graphs" are called \c Digraph and
 		  they have <tt>Arc</tt>s (instead of <tt>Edge</tt>s), while
 		  \ref concepts::Graph "undirected graphs" are called \c Graph
 		  (instead of \c UGraph) and they have <tt>Edge</tt>s (instead of
 		  <tt>UEdge</tt>s). These changes reflected thoroughly everywhere in
 		  the library. Namely,
 		  - \c Graph -> \c Digraph
 		    - \c %ListGraph -> \c ListDigraph, \c %SmartGraph -> \c SmartDigraph etc.
 		  - \c UGraph -> \c Graph
 		    - \c ListUGraph -> \c ListGraph, \c SmartUGraph -> \c SmartGraph etc.
 		  - \c Edge -> \c Arc, \c UEdge -> \c Edge
 		  - \c EdgeMap -> \c ArcMap, \c UEdgeMap -> \c EdgeMap
 		  - \c EdgeIt -> \c ArcIt, \c UEdgeIt -> \c EdgeIt
 		  - Class names and function names containing the words \c graph,
 		    \c ugraph, \e edge or \e arc should also be updated.
 		- <b>The two endpoints of an (\e undirected) \c Edge can be obtained by the
 		  <tt>u()</tt> and <tt>v()</tt> member function of the graph
 		  (instead of <tt>source()</tt> and <tt>target()</tt>). This change
 		  must be done by hand.</b>
 		  \n Of course, you can still use <tt>source()</tt> and <tt>target()</tt>
 		  for <tt>Arc</tt>s (directed edges).
 		\warning
 		<b>The <tt>script/lemon-0.x-to-1.x.sh</tt> tool replaces all instances of
 		the words \c graph, \c digraph, \c edge and \c arc, so it replaces them
 		in strings, comments etc. as well as in all identifiers.</b>
 		\section migration-lgf LGF tools
 		 - The \ref lgf-format "LGF file format" has changed,
 		   <tt>\@nodeset</tt> has changed to <tt>\@nodes</tt>,
 		   <tt>\@edgeset</tt> and <tt>\@uedgeset</tt> to <tt>\@arcs</tt> or
 		   <tt>\@edges</tt>, which become completely equivalents. The
 		   <tt>\@nodes</tt>, <tt>\@edges</tt> and <tt>\@uedges</tt> sections are
 		   removed from the format, the content of them should be
 		   the part of <tt>\@attributes</tt> section. The data fields in
 		   the sections must follow a strict format, they must be either character
 		   sequences without whitespaces or quoted strings.
 		 - The <tt>LemonReader</tt> and <tt>LemonWriter</tt> core interfaces
 		   are no longer available.
 		 - The implementation of the general section readers and writers has changed
 		   they are simple functors now. Beside the old
 		   stream based section handling, currently line oriented section
 		   reading and writing are also supported. In the
 		   section readers the lines must be counted manually. The sections
 		   should be read and written with the SectionWriter and SectionReader
 		   classes.
 		 - Instead of the item readers and writers, item converters should be
 		   used. The converters are functors, which map the type to
 		   std::string or std::string to the type. The converters for standard
 		   containers hasn't yet been implemented in the new LEMON. The converters
 		   can return strings in any format, because if it is necessary, the LGF
 		   writer and reader will quote and unquote the given value.
 		 - The DigraphReader and DigraphWriter can used similarly to the
 .x series, however the <tt>read</tt> or <tt>write</tt> prefix of
 		   the member functions are removed.
 		 - The new LEMON supports the function like interface, the \c
 		   digraphReader and \c digraphWriter functions are more convenient than
 		   using the classes directly.
 		\section migration-search BFS, DFS and Dijkstra
 		- <b>Using the function interface of BFS, DFS and %Dijkstra both source and
 		  target nodes can be given as parameters of the <tt>run()</tt> function
 		  (instead of \c bfs(), \c dfs() or \c dijkstra() itself).</b>
 		- \ref named-templ-param "Named class template parameters" of \c Bfs,
 		  \c Dfs, \c Dijkstra, \c BfsVisit, \c DfsVisit are renamed to start
 		  with "Set" instead of "Def". Namely,
 		  - \c DefPredMap -> \c SetPredMap
 		  - \c DefDistMap -> \c SetDistMap
 		  - \c DefReachedMap -> \c SetReachedMap
 		  - \c DefProcessedMap -> \c SetProcessedMap
 		  - \c DefHeap -> \c SetHeap
 		  - \c DefStandardHeap -> \c SetStandardHeap
 		  - \c DefOperationTraits -> \c SetOperationTraits
 		  - \c DefProcessedMapToBeDefaultMap -> \c SetStandardProcessedMap
 		\section migration-error Exceptions and Debug tools
 		<b>The class hierarchy of exceptions has largely been simplified. Now,
 		only the i/o related tools may throw exceptions. All other exceptions
 		have been replaced with either the \c LEMON_ASSERT or the \c LEMON_DEBUG
 		macros.</b>
 		<b>On the other hand, the parameter order of constructors of the
 		exceptions has been changed. See \ref IoError and \ref FormatError for
 		more details.</b>
 		\section migration-other Others
 		- <b>The contents of <tt>graph_utils.h</tt> are moved to <tt>core.h</tt>
 		  and <tt>maps.h</tt>. <tt>core.h</tt> is included by all graph types,
 		  therefore it usually do not have to be included directly.</b>
 		- <b><tt>path_utils.h</tt> is merged to \c path.h.</b>
 		- <b>The semantic of the assignment operations and copy constructors of maps
 		  are still under discussion. So, you must copy them by hand (i.e. copy
 		  each entry one-by-one)</b>
 		- <b>The parameters of the graph copying tools (i.e. \c GraphCopy,
 		  \c DigraphCopy) have to be given in the from-to order.</b>
 		- \c copyDigraph() and \c copyGraph() are renamed to \c digraphCopy()
 		  and \c graphCopy(), respectively.
 		- <b>The interface of \ref DynArcLookUp has changed. It is now the same as
 		  of \ref ArcLookUp and \ref AllArcLookUp</b>
 		- Some map types should also been renamed. Namely,
 		  - \c IntegerMap -> \c RangeMap
 		  - \c StdMap -> \c SparseMap
 		  - \c FunctorMap -> \c FunctorToMap
 		  - \c MapFunctor -> \c MapToFunctor
 		  - \c ForkWriteMap -> \c ForkMap
 		  - \c StoreBoolMap -> \c LoggerBoolMap
 		- \c dim2::BoundingBox -> \c dim2::Box
 		*/
+		}

tools/lemon-0.x-to-1.x.sh

Show inline comments

 		#!/bin/bash
 		set -e
 		if [ $# -eq 0 -o x$1 = "x-h" -o x$1 = "x-help" -o x$1 = "x--help" ]; then
 			echo "Usage:"
 			echo "  $0 source-file"
 			exit
 		fi
 		TMP=`mktemp`
 		sed	-e "s/undirected graph/_gr_aph_label_/g"\
 			-e "s/undirected edge/_ed_ge_label_/g"\
 			-e "s/graph_/_gr_aph_label__/g"\
 			-e "s/_graph/__gr_aph_label_/g"\
 			-e "s/UGraph/_Gr_aph_label_/g"\
 			-e "s/uGraph/_gr_aph_label_/g"\
 			-e "s/ugraph/_gr_aph_label_/g"\
 			-e "s/Graph/_Digr_aph_label_/g"\
 			-e "s/graph/_digr_aph_label_/g"\
 			-e "s/UEdge/_Ed_ge_label_/g"\
 			-e "s/uEdge/_ed_ge_label_/g"\
 			-e "s/uedge/_ed_ge_label_/g"\
 			-e "s/IncEdgeIt/_In_cEd_geIt_label_/g"\
 			-e "s/Edge/_Ar_c_label_/g"\
 			-e "s/edge/_ar_c_label_/g"\
 			-e "s/ANode/_Re_d_label_/g"\
 			-e "s/BNode/_Blu_e_label_/g"\
 			-e "s/A-Node/_Re_d_label_/g"\
 			-e "s/B-Node/_Blu_e_label_/g"\
 			-e "s/anode/_re_d_label_/g"\
 			-e "s/bnode/_blu_e_label_/g"\
 			-e "s/aNode/_re_d_label_/g"\
 			-e "s/bNode/_blu_e_label_/g"\
 			-e "s/_Digr_aph_label_/Digraph/g"\
 			-e "s/_digr_aph_label_/digraph/g"\
 			-e "s/_Gr_aph_label_/Graph/g"\
 			-e "s/_gr_aph_label_/graph/g"\
 			-e "s/_Ar_c_label_/Arc/g"\
 			-e "s/_ar_c_label_/arc/g"\
 			-e "s/_Ed_ge_label_/Edge/g"\
 			-e "s/_ed_ge_label_/edge/g"\
 			-e "s/_In_cEd_geIt_label_/IncEdgeIt/g"\
 			-e "s/_Re_d_label_/Red/g"\
 			-e "s/_Blu_e_label_/Blue/g"\
 			-e "s/_re_d_label_/red/g"\
 			-e "s/_blu_e_label_/blue/g"\
 			-e "s/\(\W\)DefPredMap\(\W\)/\1SetPredMap\2/g"\
 			-e "s/\(\W\)DefPredMap$/\1SetPredMap/g"\
 			-e "s/^DefPredMap\(\W\)/SetPredMap\1/g"\
 			-e "s/^DefPredMap$/SetPredMap/g"\
 			-e "s/\(\W\)DefDistMap\(\W\)/\1SetDistMap\2/g"\
 			-e "s/\(\W\)DefDistMap$/\1SetDistMap/g"\
 			-e "s/^DefDistMap\(\W\)/SetDistMap\1/g"\
 			-e "s/^DefDistMap$/SetDistMap/g"\
 			-e "s/\(\W\)DefReachedMap\(\W\)/\1SetReachedMap\2/g"\
 			-e "s/\(\W\)DefReachedMap$/\1SetReachedMap/g"\
 			-e "s/^DefReachedMap\(\W\)/SetReachedMap\1/g"\
 			-e "s/^DefReachedMap$/SetReachedMap/g"\
 			-e "s/\(\W\)DefProcessedMap\(\W\)/\1SetProcessedMap\2/g"\
 			-e "s/\(\W\)DefProcessedMap$/\1SetProcessedMap/g"\
 			-e "s/^DefProcessedMap\(\W\)/SetProcessedMap\1/g"\
 			-e "s/^DefProcessedMap$/SetProcessedMap/g"\
 			-e "s/\(\W\)DefHeap\(\W\)/\1SetHeap\2/g"\
 			-e "s/\(\W\)DefHeap$/\1SetHeap/g"\
 			-e "s/^DefHeap\(\W\)/SetHeap\1/g"\
 			-e "s/^DefHeap$/SetHeap/g"\
 			-e "s/\(\W\)DefStandardHeap\(\W\)/\1SetStandradHeap\2/g"\
 			-e "s/\(\W\)DefStandardHeap$/\1SetStandradHeap/g"\
 			-e "s/^DefStandardHeap\(\W\)/SetStandradHeap\1/g"\
 			-e "s/^DefStandardHeap$/SetStandradHeap/g"\
 			-e "s/\(\W\)DefOperationTraits\(\W\)/\1SetOperationTraits\2/g"\
 			-e "s/\(\W\)DefOperationTraits$/\1SetOperationTraits/g"\
 			-e "s/^DefOperationTraits\(\W\)/SetOperationTraits\1/g"\
 			-e "s/^DefOperationTraits$/SetOperationTraits/g"\
 			-e "s/\(\W\)DefProcessedMapToBeDefaultMap\(\W\)/\1SetStandardProcessedMap\2/g"\
 			-e "s/\(\W\)DefProcessedMapToBeDefaultMap$/\1SetStandardProcessedMap/g"\
 			-e "s/^DefProcessedMapToBeDefaultMap\(\W\)/SetStandardProcessedMap\1/g"\
 			-e "s/^DefProcessedMapToBeDefaultMap$/SetStandardProcessedMap/g"\
 			-e "s/\(\W\)IntegerMap\(\W\)/\1RangeMap\2/g"\
 			-e "s/\(\W\)IntegerMap$/\1RangeMap/g"\
 			-e "s/^IntegerMap\(\W\)/RangeMap\1/g"\
 			-e "s/^IntegerMap$/RangeMap/g"\
 			-e "s/\(\W\)integerMap\(\W\)/\1rangeMap\2/g"\
 			-e "s/\(\W\)integerMap$/\1rangeMap/g"\
 			-e "s/^integerMap\(\W\)/rangeMap\1/g"\
 			-e "s/^integerMap$/rangeMap/g"\
 			-e "s/\(\W\)copyGraph\(\W\)/\1graphCopy\2/g"\
 			-e "s/\(\W\)copyGraph$/\1graphCopy/g"\
 			-e "s/^copyGraph\(\W\)/graphCopy\1/g"\
 			-e "s/^copyGraph$/graphCopy/g"\
 			-e "s/\(\W\)copyDigraph\(\W\)/\1digraphCopy\2/g"\
 			-e "s/\(\W\)copyDigraph$/\1digraphCopy/g"\
 			-e "s/^copyDigraph\(\W\)/digraphCopy\1/g"\
 			-e "s/^copyDigraph$/digraphCopy/g"\
 			-e "s/\(\W\)\([sS]\)tdMap\(\W\)/\1\2parseMap\3/g"\
 			-e "s/\(\W\)\([sS]\)tdMap$/\1\2parseMap/g"\
 			-e "s/^\([sS]\)tdMap\(\W\)/\1parseMap\2/g"\
 			-e "s/^\([sS]\)tdMap$/\1parseMap/g"\
 			-e "s/\(\W\)\([Ff]\)unctorMap\(\W\)/\1\2unctorToMap\3/g"\
 			-e "s/\(\W\)\([Ff]\)unctorMap$/\1\2unctorToMap/g"\
 			-e "s/^\([Ff]\)unctorMap\(\W\)/\1unctorToMap\2/g"\
 			-e "s/^\([Ff]\)unctorMap$/\1unctorToMap/g"\
 			-e "s/\(\W\)\([Mm]\)apFunctor\(\W\)/\1\2apToFunctor\3/g"\
 			-e "s/\(\W\)\([Mm]\)apFunctor$/\1\2apToFunctor/g"\
 			-e "s/^\([Mm]\)apFunctor\(\W\)/\1apToFunctor\2/g"\
 			-e "s/^\([Mm]\)apFunctor$/\1apToFunctor/g"\
 			-e "s/\(\W\)\([Ff]\)orkWriteMap\(\W\)/\1\2orkMap\3/g"\
 			-e "s/\(\W\)\([Ff]\)orkWriteMap$/\1\2orkMap/g"\
 			-e "s/^\([Ff]\)orkWriteMap\(\W\)/\1orkMap\2/g"\
 			-e "s/^\([Ff]\)orkWriteMap$/\1orkMap/g"\
 			-e "s/\(\W\)StoreBoolMap\(\W\)/\1LoggerBoolMap\2/g"\
 			-e "s/\(\W\)StoreBoolMap$/\1LoggerBoolMap/g"\
 			-e "s/^StoreBoolMap\(\W\)/LoggerBoolMap\1/g"\
 			-e "s/^StoreBoolMap$/LoggerBoolMap/g"\
 			-e "s/\(\W\)storeBoolMap\(\W\)/\1loggerBoolMap\2/g"\
 			-e "s/\(\W\)storeBoolMap$/\1loggerBoolMap/g"\
 			-e "s/^storeBoolMap\(\W\)/loggerBoolMap\1/g"\
 			-e "s/^storeBoolMap$/loggerBoolMap/g"\
 			-e "s/\(\W\)BoundingBox\(\W\)/\1Box\2/g"\
 			-e "s/\(\W\)BoundingBox$/\1Box/g"\
 			-e "s/^BoundingBox\(\W\)/Box\1/g"\
 			-e "s/^BoundingBox$/Box/g"\
 		<$1 > $TMP
 		mv $TMP $1
 		 No newline at end of file

Makefile.am

Show inline comments

@@ -23,16 +23,16 @@
 		noinst_HEADERS =
 		noinst_PROGRAMS =
 		bin_PROGRAMS =
 		check_PROGRAMS =
 		dist_bin_SCRIPTS =
 		TESTS =
 		XFAIL_TESTS =
 		include lemon/Makefile.am
 		include test/Makefile.am
 		include doc/Makefile.am
 		include demo/Makefile.am
 		include benchmark/Makefile.am
 		include tools/Makefile.am
 		MRPROPERFILES = \
 			aclocal.m4 \

README

Show inline comments

@@ -36,11 +36,7 @@
 		test/
 		   Contains programs to check the integrity and correctness of LEMON.
 		benchmark/
 		   Contains programs for measuring the performance of algorithms.
 		tools/
 		   Various utilities related to LEMON.

configure.ac

Show inline comments

@@ -80,21 +80,8 @@
 		  AC_MSG_RESULT([no])
 		fi
 		AM_CONDITIONAL([WANT_TOOLS], [test x"$enable_tools" != x"no"])
 		dnl Disable/enable building the benchmarks.
 		AC_ARG_ENABLE([benchmark],
 		AS_HELP_STRING([--enable-benchmark], [build the benchmarks])
 		AS_HELP_STRING([--disable-benchmark], [do not build the benchmarks @<:@default@:>@]),
 		              [], [enable_benchmark=no])
 		AC_MSG_CHECKING([whether to build the benchmarks])
 		if test x"$enable_benchmark" != x"no"; then
 		  AC_MSG_RESULT([yes])
 		else
 		  AC_MSG_RESULT([no])
 		fi
 		AM_CONDITIONAL([WANT_BENCHMARK], [test x"$enable_benchmark" != 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.
@@ -131,9 +118,8 @@
 		#echo GLPK support.................. : $lx_glpk_found
 		#echo CPLEX support................. : $lx_cplex_found
 		#echo SOPLEX support................ : $lx_soplex_found
 		#echo
 		echo Build benchmarks.............. : $enable_benchmark
 		echo Build demo programs........... : $enable_demo
 		echo Build additional tools........ : $enable_tools
 		echo
 		echo The packace will be installed in

demo/arg_parser_demo.cc

Show inline comments

@@ -26,9 +26,9 @@
 		#include <lemon/arg_parser.h>
 		using namespace lemon;
-		int main(int argc, const char **argv)
 		int main(int argc, char **argv)
+		{
 		  // Initialize the argument parser
 		  ArgParser ap(argc, argv);
 		  int i;

demo/graph_to_eps_demo.cc

Show inline comments

@@ -25,9 +25,9 @@
 		/// <tt>.eps</tt> files demonstrating the capability of \ref
 		/// graphToEps(), and showing how to draw directed graphs,
 		/// how to handle parallel egdes, how to change the properties (like
 		/// color, shape, size, title etc.) of nodes and arcs individually
-		/// using appropriate \ref maps-page "graph maps".
 		/// using appropriate graph maps.
 		///
 		/// \include graph_to_eps_demo.cc
 		#include<lemon/list_graph.h>

doc/Makefile.am

Show inline comments

@@ -5,8 +5,9 @@
 			doc/groups.dox \
 			doc/lgf.dox \
 			doc/license.dox \
 			doc/mainpage.dox \
 			doc/migration.dox \
 			doc/named-param.dox \
 			doc/namespaces.dox \
 			doc/html \
 			doc/CMakeLists.txt

doc/groups.dox

Show inline comments

@@ -41,9 +41,11 @@
 		some graph features like arc/edge or node deletion.
 		You are free to use the graph structure that fit your requirements
 		the best, most graph algorithms and auxiliary data structures can be used
-		with any graph structures.
+		with any graph structure.
 		<b>See also:</b> \ref graph_concepts "Graph Structure Concepts".
 		*/
 		/**
 		@defgroup maps Maps
@@ -51,10 +53,12 @@
 		\brief Map structures implemented in LEMON.
 		This group describes the map structures implemented in LEMON.
 		LEMON provides several special purpose maps that e.g. combine
+		LEMON provides several special purpose maps and map adaptors that e.g. combine
 		new maps from existing ones.
 		<b>See also:</b> \ref map_concepts "Map Concepts".
 		*/
 		/**
 		@defgroup graph_maps Graph Maps
@@ -64,9 +68,8 @@
 		This group describes maps that are specifically designed to assign
 		values to the nodes and arcs of graphs.
 		*/
 		/**
 		\defgroup map_adaptors Map Adaptors
 		\ingroup maps
 		\brief Tools to create new maps from existing ones
@@ -81,9 +84,9 @@
 		The typical usage of this classes is passing implicit maps to
 		algorithms.  If a function type algorithm is called then the function
 		type map adaptors can be used comfortable. For example let's see the
-		usage of map adaptors with the \c digraphToEps() function.
+		usage of map adaptors with the \c graphToEps() function.
 		\code
 		  Color nodeColor(int deg) {
 		    if (deg >= 2) {
 		      return Color(0.5, 0.0, 0.5);
@@ -95,15 +98,15 @@
+		  }
 		  Digraph::NodeMap<int> degree_map(graph);
-		  digraphToEps(graph, "graph.eps")
+		  graphToEps(graph, "graph.eps")
 		    .coords(coords).scaleToA4().undirected()
 		    .nodeColors(composeMap(functorToMap(nodeColor), degree_map))
 		    .run();
 		\endcode
 		The \c functorToMap() function makes an \c int to \c Color map from the
-		\e nodeColor() function. The \c composeMap() compose the \e degree_map
+		\c nodeColor() function. The \c composeMap() compose the \c degree_map
 		and the previously created map. The composed map is a proper function to
 		get the color of each node.
 		The usage with class type algorithms is little bit harder. In this
@@ -142,9 +145,8 @@
 		efficient to have e.g. the Dijkstra algorithm to store its result in
 		any kind of path structure.
 		\sa lemon::concepts::Path
 		*/
 		/**
 		@defgroup auxdat Auxiliary Data Structures
@@ -154,9 +156,8 @@
 		This group describes some data structures implemented in LEMON in
 		order to make it easier to implement combinatorial algorithms.
 		*/
 		/**
 		@defgroup algs Algorithms
 		\brief This group describes the several algorithms
 		implemented in LEMON.
@@ -170,28 +171,29 @@
 		@ingroup algs
 		\brief Common graph search algorithms.
 		This group describes the common graph search algorithms like
-		Breadth-first search (Bfs) and Depth-first search (Dfs).
+		Breadth-First Search (BFS) and Depth-First Search (DFS).
 		*/
 		/**
-		@defgroup shortest_path Shortest Path algorithms
+		@defgroup shortest_path Shortest Path Algorithms
 		@ingroup algs
 		\brief Algorithms for finding shortest paths.
 		This group describes the algorithms for finding shortest paths in graphs.
 		*/
 		/**
-		@defgroup spantree Minimum Spanning Tree algorithms
+		@defgroup spantree Minimum Spanning Tree Algorithms
 		@ingroup algs
 		\brief Algorithms for finding a minimum cost spanning tree in a graph.
 		This group describes the algorithms for finding a minimum cost spanning
 		tree in a graph
 		*/
 		@ingroup algs
 		/**
 		@defgroup utils Tools and Utilities
 		\brief Tools and utilities for programming in LEMON
@@ -215,9 +217,9 @@
 		debugging and testing.
 		*/
 		/**
-		@defgroup timecount Time measuring and Counting
+		@defgroup timecount Time Measuring and Counting
 		@ingroup misc
 		\brief Simple tools for measuring the performance of algorithms.
 		This group describes simple tools for measuring the performance
@@ -238,29 +240,29 @@
 		This group describes the tools for importing and exporting graphs
 		and graph related data. Now it supports the LEMON format
 		and the encapsulated postscript (EPS) format.
 		postscript (EPS) format.
 		*/
 		/**
 		@defgroup lemon_io LEMON Input-Output
 		@ingroup io_group
-		\brief Reading and writing \ref lgf-format "LEMON Graph Format".
 		\brief Reading and writing LEMON Graph Format.
 		This group describes methods for reading and writing
 		\ref lgf-format "LEMON Graph Format".
 		*/
 		/**
-		@defgroup eps_io Postscript exporting
+		@defgroup eps_io Postscript Exporting
 		@ingroup io_group
 		\brief General \c EPS drawer and graph exporter
 		This group describes general \c EPS drawing methods and special
 		graph exporting tools.
 		*/
 		/**
 		@defgroup concept Concepts
 		\brief Skeleton classes and concept checking classes
@@ -286,12 +288,10 @@
 		  that makes it possible to check whether a certain implementation of a
 		  concept indeed provides all the required features.
 		- Finally, They can serve as a skeleton of a new implementation of a concept.
 		*/
 		/**
 		@defgroup graph_concepts Graph Structure Concepts
 		@ingroup concept
 		\brief Skeleton and concept checking classes for graph structures
@@ -299,8 +299,10 @@
 		This group describes the skeletons and concept checking classes of LEMON's
 		graph structures and helper classes used to implement these.
 		*/
 		This group describes the skeletons and concept checking classes of maps.
 		/**
 		\anchor demoprograms
 		@defgroup demos Demo programs

doc/lgf.dox

Show inline comments

@@ -77,9 +77,9 @@
 3   12
 3   18
 		\endcode
 		The \c \@edges is just a synonym of \c \@arcs. The @arcs section can
+		The \c \@edges is just a synonym of \c \@arcs. The \@arcs section can
 		also store the edge set of an undirected graph. In such case there is
 		a conventional method for store arc maps in the file, if two columns
 		has the same caption with \c '+' and \c '-' prefix, then these columns
 		can be regarded as the values of an arc map.

doc/mainpage.dox

Show inline comments

@@ -42,12 +42,13 @@
 		\subsection howtoread How to read the documentation
 		If you
 		want to see how LEMON works, see
-		some \ref demoprograms "demo programs"!
+		some \ref demoprograms "demo programs".
 		If you know what you are looking for then try to find it under the
 		<a class="el" href="modules.html">Modules</a>
 		section.
+		If you are a user of the old (0.x) series of LEMON, please check out the
 		\ref migration "Migration Guide" for the backward incompatibilities.
 		*/

lemon/arg_parser.cc

Show inline comments

@@ -25,14 +25,13 @@
    (static_cast<ArgParser*>(p))->showHelp();
    exit(1);
  }

  ArgParser::ArgParser(int argc, const char **argv) :_argc(argc), _argv(argv),
                                                     _command_name(argv[0]) {
  ArgParser::ArgParser(int argc, const char * const *argv)
    :_argc(argc), _argv(argv), _command_name(argv[0]) {
    funcOption("-help","Print a short help message",_showHelp,this);
    synonym("help","-help");
    synonym("h","-help");

  }

  ArgParser::~ArgParser()
  {

lemon/arg_parser.h

Show inline comments

@@ -45,9 +45,9 @@
 		    static void _showHelp(void *p);
 		  protected:
 		    int _argc;
 		    const char **_argv;
+		    const char * const *_argv;
 		    enum OptType { UNKNOWN=0, BOOL=1, STRING=2, DOUBLE=3, INTEGER=4, FUNC=5 };
 		    class ParData {
@@ -118,9 +118,9 @@
 		  public:
 		    ///Constructor
 		    ArgParser(int argc, const char **argv);
+		    ArgParser(int argc, const char * const *argv);
 		    ~ArgParser();
 		    ///\name Options

lemon/bfs.h

Show inline comments

@@ -48,13 +48,13 @@
 		    ///The type of the map that stores the predecessor
 		    ///arcs of the shortest paths.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
-		    ///Instantiates a \ref PredMap.
 		    ///Instantiates a PredMap.
-		    ///This function instantiates a \ref PredMap.
 		    ///This function instantiates a PredMap.
 		    ///\param g is the digraph, to which we would like to define the
-		    ///\ref PredMap.
 		    ///PredMap.
 		    static PredMap *createPredMap(const Digraph &g)
+		    {
 		      return new PredMap(g);
+		    }
@@ -63,13 +63,13 @@
 		    ///The type of the map that indicates which nodes are processed.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
-		    ///Instantiates a \ref ProcessedMap.
 		    ///Instantiates a ProcessedMap.
-		    ///This function instantiates a \ref ProcessedMap.
 		    ///This function instantiates a ProcessedMap.
 		    ///\param g is the digraph, to which
-		    ///we would like to define the \ref ProcessedMap
 		    ///we would like to define the ProcessedMap
 		#ifdef DOXYGEN
 		    static ProcessedMap *createProcessedMap(const Digraph &g)
 		#else
 		    static ProcessedMap *createProcessedMap(const Digraph &)
@@ -82,13 +82,13 @@
 		    ///The type of the map that indicates which nodes are reached.
 		    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
 		    typedef typename Digraph::template NodeMap<bool> ReachedMap;
-		    ///Instantiates a \ref ReachedMap.
 		    ///Instantiates a ReachedMap.
-		    ///This function instantiates a \ref ReachedMap.
 		    ///This function instantiates a ReachedMap.
 		    ///\param g is the digraph, to which
-		    ///we would like to define the \ref ReachedMap.
 		    ///we would like to define the ReachedMap.
 		    static ReachedMap *createReachedMap(const Digraph &g)
+		    {
 		      return new ReachedMap(g);
+		    }
@@ -97,13 +97,13 @@
 		    ///The type of the map that stores the distances of the nodes.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    typedef typename Digraph::template NodeMap<int> DistMap;
-		    ///Instantiates a \ref DistMap.
 		    ///Instantiates a DistMap.
-		    ///This function instantiates a \ref DistMap.
 		    ///This function instantiates a DistMap.
 		    ///\param g is the digraph, to which we would like to define the
-		    ///\ref DistMap.
 		    ///DistMap.
 		    static DistMap *createDistMap(const Digraph &g)
+		    {
 		      return new DistMap(g);
+		    }
@@ -226,12 +226,12 @@
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
-		    ///\ref PredMap type.
 		    ///PredMap type.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
-		    ///\ref PredMap type.
 		    ///PredMap type.
 		    template <class T>
 		    struct SetPredMap : public Bfs< Digraph, SetPredMapTraits<T> > {
 		      typedef Bfs< Digraph, SetPredMapTraits<T> > Create;
 		    };
@@ -245,12 +245,12 @@
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
-		    ///\ref DistMap type.
 		    ///DistMap type.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
-		    ///\ref DistMap type.
 		    ///DistMap type.
 		    template <class T>
 		    struct SetDistMap : public Bfs< Digraph, SetDistMapTraits<T> > {
 		      typedef Bfs< Digraph, SetDistMapTraits<T> > Create;
 		    };
@@ -264,12 +264,12 @@
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
-		    ///\ref ReachedMap type.
 		    ///ReachedMap type.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
-		    ///\ref ReachedMap type.
 		    ///ReachedMap type.
 		    template <class T>
 		    struct SetReachedMap : public Bfs< Digraph, SetReachedMapTraits<T> > {
 		      typedef Bfs< Digraph, SetReachedMapTraits<T> > Create;
 		    };
@@ -283,12 +283,12 @@
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
-		    ///\ref ProcessedMap type.
 		    ///ProcessedMap type.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
-		    ///\ref ProcessedMap type.
 		    ///ProcessedMap type.
 		    template <class T>
 		    struct SetProcessedMap : public Bfs< Digraph, SetProcessedMapTraits<T> > {
 		      typedef Bfs< Digraph, SetProcessedMapTraits<T> > Create;
 		    };
@@ -301,12 +301,12 @@
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
-		    ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
 		    ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
-		    ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
 		    ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
 		    ///If you don't set it explicitly, it will be automatically allocated.
 		    struct SetStandardProcessedMap :
 		      public Bfs< Digraph, SetStandardProcessedMapTraits > {
 		      typedef Bfs< Digraph, SetStandardProcessedMapTraits > Create;
@@ -834,13 +834,13 @@
 		    ///The type of the map that stores the predecessor
 		    ///arcs of the shortest paths.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
-		    ///Instantiates a \ref PredMap.
 		    ///Instantiates a PredMap.
-		    ///This function instantiates a \ref PredMap.
 		    ///This function instantiates a PredMap.
 		    ///\param g is the digraph, to which we would like to define the
-		    ///\ref PredMap.
 		    ///PredMap.
 		    static PredMap *createPredMap(const Digraph &g)
+		    {
 		      return new PredMap(g);
+		    }
@@ -850,13 +850,13 @@
 		    ///The type of the map that indicates which nodes are processed.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    ///By default it is a NullMap.
 		    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
-		    ///Instantiates a \ref ProcessedMap.
 		    ///Instantiates a ProcessedMap.
-		    ///This function instantiates a \ref ProcessedMap.
 		    ///This function instantiates a ProcessedMap.
 		    ///\param g is the digraph, to which
-		    ///we would like to define the \ref ProcessedMap.
 		    ///we would like to define the ProcessedMap.
 		#ifdef DOXYGEN
 		    static ProcessedMap *createProcessedMap(const Digraph &g)
 		#else
 		    static ProcessedMap *createProcessedMap(const Digraph &)
@@ -869,13 +869,13 @@
 		    ///The type of the map that indicates which nodes are reached.
 		    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
 		    typedef typename Digraph::template NodeMap<bool> ReachedMap;
-		    ///Instantiates a \ref ReachedMap.
 		    ///Instantiates a ReachedMap.
-		    ///This function instantiates a \ref ReachedMap.
 		    ///This function instantiates a ReachedMap.
 		    ///\param g is the digraph, to which
-		    ///we would like to define the \ref ReachedMap.
 		    ///we would like to define the ReachedMap.
 		    static ReachedMap *createReachedMap(const Digraph &g)
+		    {
 		      return new ReachedMap(g);
+		    }
@@ -884,13 +884,13 @@
 		    ///The type of the map that stores the distances of the nodes.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    typedef typename Digraph::template NodeMap<int> DistMap;
-		    ///Instantiates a \ref DistMap.
 		    ///Instantiates a DistMap.
-		    ///This function instantiates a \ref DistMap.
 		    ///This function instantiates a DistMap.
 		    ///\param g is the digraph, to which we would like to define
-		    ///the \ref DistMap
 		    ///the DistMap
 		    static DistMap *createDistMap(const Digraph &g)
+		    {
 		      return new DistMap(g);
+		    }
@@ -901,9 +901,9 @@
 		    ///It must meet the \ref concepts::Path "Path" concept.
 		    typedef lemon::Path<Digraph> Path;
 		  };
-		  /// Default traits class used by \ref BfsWizard
 		  /// Default traits class used by BfsWizard
 		  /// To make it easier to use Bfs algorithm
 		  /// we have created a wizard class.
 		  /// This \ref BfsWizard class needs default traits,
@@ -1067,12 +1067,12 @@
 		      static PredMap *createPredMap(const Digraph &) { return 0; };
 		      SetPredMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-func-param "Named parameter"
-		    ///for setting \ref PredMap object.
 		    ///for setting PredMap object.
 		    ///
 		    ///\ref named-func-param "Named parameter"
-		    ///for setting \ref PredMap object.
 		    ///for setting PredMap object.
 		    template<class T>
 		    BfsWizard<SetPredMapBase<T> > predMap(const T &t)
+		    {
 		      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
@@ -1085,12 +1085,12 @@
 		      static ReachedMap *createReachedMap(const Digraph &) { return 0; };
 		      SetReachedMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-func-param "Named parameter"
-		    ///for setting \ref ReachedMap object.
 		    ///for setting ReachedMap object.
 		    ///
 		    /// \ref named-func-param "Named parameter"
-		    ///for setting \ref ReachedMap object.
 		    ///for setting ReachedMap object.
 		    template<class T>
 		    BfsWizard<SetReachedMapBase<T> > reachedMap(const T &t)
+		    {
 		      Base::_reached=reinterpret_cast<void*>(const_cast<T*>(&t));
@@ -1103,12 +1103,12 @@
 		      static DistMap *createDistMap(const Digraph &) { return 0; };
 		      SetDistMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-func-param "Named parameter"
-		    ///for setting \ref DistMap object.
 		    ///for setting DistMap object.
 		    ///
 		    /// \ref named-func-param "Named parameter"
-		    ///for setting \ref DistMap object.
 		    ///for setting DistMap object.
 		    template<class T>
 		    BfsWizard<SetDistMapBase<T> > distMap(const T &t)
+		    {
 		      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
@@ -1121,12 +1121,12 @@
 		      static ProcessedMap *createProcessedMap(const Digraph &) { return 0; };
 		      SetProcessedMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-func-param "Named parameter"
-		    ///for setting \ref ProcessedMap object.
 		    ///for setting ProcessedMap object.
 		    ///
 		    /// \ref named-func-param "Named parameter"
-		    ///for setting \ref ProcessedMap object.
 		    ///for setting ProcessedMap object.
 		    template<class T>
 		    BfsWizard<SetProcessedMapBase<T> > processedMap(const T &t)
+		    {
 		      Base::_processed=reinterpret_cast<void*>(const_cast<T*>(&t));
@@ -1266,13 +1266,13 @@
 		    /// The type of the map that indicates which nodes are reached.
 		    /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
 		    typedef typename Digraph::template NodeMap<bool> ReachedMap;
-		    /// \brief Instantiates a \ref ReachedMap.
 		    /// \brief Instantiates a ReachedMap.
 		    ///
-		    /// This function instantiates a \ref ReachedMap.
 		    /// This function instantiates a ReachedMap.
 		    /// \param digraph is the digraph, to which
-		    /// we would like to define the \ref ReachedMap.
 		    /// we would like to define the ReachedMap.
 		    static ReachedMap *createReachedMap(const Digraph &digraph) {
 		      return new ReachedMap(digraph);
+		    }

lemon/bits/alteration_notifier.h

Show inline comments

@@ -23,78 +23,77 @@
 		#include <list>
 		#include <lemon/core.h>
 		///\ingroup graphbits
 		///\file
-		///\brief Observer notifier for graph alteration observers.
+		//\ingroup graphbits
 		//\file
 		//\brief Observer notifier for graph alteration observers.
 		namespace lemon {
 		  /// \ingroup graphbits
 		  ///
 		  /// \brief Notifier class to notify observes about alterations in
 		  /// a container.
 		  ///
 		  /// The simple graph's can be refered as two containers, one node container
 		  /// and one edge container. But they are not standard containers they
 		  /// does not store values directly they are just key continars for more
 		  /// value containers which are the node and edge maps.
 		  ///
 		  /// The graph's node and edge sets can be changed as we add or erase
 		  /// nodes and edges in the graph. LEMON would like to handle easily
 		  /// that the node and edge maps should contain values for all nodes or
 		  /// edges. If we want to check on every indicing if the map contains
 		  /// the current indicing key that cause a drawback in the performance
 		  /// in the library. We use another solution we notify all maps about
 		  /// an alteration in the graph, which cause only drawback on the
 		  /// alteration of the graph.
 		  ///
 		  /// This class provides an interface to the container. The \e first() and \e
 		  /// next() member functions make possible to iterate on the keys of the
 		  /// container. The \e id() function returns an integer id for each key.
 		  /// The \e maxId() function gives back an upper bound of the ids.
 		  ///
 		  /// For the proper functonality of this class, we should notify it
 		  /// about each alteration in the container. The alterations have four type
 		  /// as \e add(), \e erase(), \e build() and \e clear(). The \e add() and
 		  /// \e erase() signals that only one or few items added or erased to or
 		  /// from the graph. If all items are erased from the graph or from an empty
 		  /// graph a new graph is builded then it can be signaled with the
 		  /// clear() and build() members. Important rule that if we erase items
 		  /// from graph we should first signal the alteration and after that erase
 		  /// them from the container, on the other way on item addition we should
 		  /// first extend the container and just after that signal the alteration.
 		  ///
 		  /// The alteration can be observed with a class inherited from the
 		  /// \e ObserverBase nested class. The signals can be handled with
 		  /// overriding the virtual functions defined in the base class.  The
 		  /// observer base can be attached to the notifier with the
 		  /// \e attach() member and can be detached with detach() function. The
 		  /// alteration handlers should not call any function which signals
 		  /// an other alteration in the same notifier and should not
 		  /// detach any observer from the notifier.
 		  ///
 		  /// Alteration observers try to be exception safe. If an \e add() or
 		  /// a \e clear() function throws an exception then the remaining
 		  /// observeres will not be notified and the fulfilled additions will
 		  /// be rolled back by calling the \e erase() or \e clear()
 		  /// functions. Thence the \e erase() and \e clear() should not throw
 		  /// exception. Actullay, it can be throw only
 		  /// \ref AlterationObserver::ImmediateDetach ImmediateDetach
 		  /// exception which detach the observer from the notifier.
 		  ///
 		  /// There are some place when the alteration observing is not completly
 		  /// reliable. If we want to carry out the node degree in the graph
 		  /// as in the \ref InDegMap and we use the reverseEdge that cause
 		  /// unreliable functionality. Because the alteration observing signals
 		  /// only erasing and adding but not the reversing it will stores bad
 		  /// degrees. The sub graph adaptors cannot signal the alterations because
 		  /// just a setting in the filter map can modify the graph and this cannot
 		  /// be watched in any way.
 		  ///
 		  /// \param _Container The container which is observed.
 		  /// \param _Item The item type which is obserbved.
 		  // \ingroup graphbits
 		  //
 		  // \brief Notifier class to notify observes about alterations in
 		  // a container.
 		  //
 		  // The simple graph's can be refered as two containers, one node container
 		  // and one edge container. But they are not standard containers they
 		  // does not store values directly they are just key continars for more
 		  // value containers which are the node and edge maps.
 		  //
 		  // The graph's node and edge sets can be changed as we add or erase
 		  // nodes and edges in the graph. LEMON would like to handle easily
 		  // that the node and edge maps should contain values for all nodes or
 		  // edges. If we want to check on every indicing if the map contains
 		  // the current indicing key that cause a drawback in the performance
 		  // in the library. We use another solution we notify all maps about
 		  // an alteration in the graph, which cause only drawback on the
 		  // alteration of the graph.
 		  //
 		  // This class provides an interface to the container. The \e first() and \e
 		  // next() member functions make possible to iterate on the keys of the
 		  // container. The \e id() function returns an integer id for each key.
 		  // The \e maxId() function gives back an upper bound of the ids.
 		  //
 		  // For the proper functonality of this class, we should notify it
 		  // about each alteration in the container. The alterations have four type
 		  // as \e add(), \e erase(), \e build() and \e clear(). The \e add() and
 		  // \e erase() signals that only one or few items added or erased to or
 		  // from the graph. If all items are erased from the graph or from an empty
 		  // graph a new graph is builded then it can be signaled with the
 		  // clear() and build() members. Important rule that if we erase items
 		  // from graph we should first signal the alteration and after that erase
 		  // them from the container, on the other way on item addition we should
 		  // first extend the container and just after that signal the alteration.
 		  //
 		  // The alteration can be observed with a class inherited from the
 		  // \e ObserverBase nested class. The signals can be handled with
 		  // overriding the virtual functions defined in the base class.  The
 		  // observer base can be attached to the notifier with the
 		  // \e attach() member and can be detached with detach() function. The
 		  // alteration handlers should not call any function which signals
 		  // an other alteration in the same notifier and should not
 		  // detach any observer from the notifier.
 		  //
 		  // Alteration observers try to be exception safe. If an \e add() or
 		  // a \e clear() function throws an exception then the remaining
 		  // observeres will not be notified and the fulfilled additions will
 		  // be rolled back by calling the \e erase() or \e clear()
 		  // functions. Thence the \e erase() and \e clear() should not throw
 		  // exception. Actullay, it can be throw only \ref ImmediateDetach
 		  // exception which detach the observer from the notifier.
 		  //
 		  // There are some place when the alteration observing is not completly
 		  // reliable. If we want to carry out the node degree in the graph
 		  // as in the \ref InDegMap and we use the reverseEdge that cause
 		  // unreliable functionality. Because the alteration observing signals
 		  // only erasing and adding but not the reversing it will stores bad
 		  // degrees. The sub graph adaptors cannot signal the alterations because
 		  // just a setting in the filter map can modify the graph and this cannot
 		  // be watched in any way.
 		  //
 		  // \param _Container The container which is observed.
 		  // \param _Item The item type which is obserbved.
 		  template <typename _Container, typename _Item>
 		  class AlterationNotifier {
 		  public:
@@ -103,94 +102,89 @@
 		    typedef _Container Container;
 		    typedef _Item Item;
 		    /// \brief Exception which can be called from \e clear() and
 		    /// \e erase().
 		    ///
 		    /// From the \e clear() and \e erase() function only this
 		    /// exception is allowed to throw. The exception immediatly
 		    /// detaches the current observer from the notifier. Because the
 		    /// \e clear() and \e erase() should not throw other exceptions
 		    /// it can be used to invalidate the observer.
 		    // \brief Exception which can be called from \e clear() and
 		    // \e erase().
 		    //
 		    // From the \e clear() and \e erase() function only this
 		    // exception is allowed to throw. The exception immediatly
 		    // detaches the current observer from the notifier. Because the
 		    // \e clear() and \e erase() should not throw other exceptions
 		    // it can be used to invalidate the observer.
 		    struct ImmediateDetach {};
 		    /// \brief ObserverBase is the base class for the observers.
 		    ///
 		    /// ObserverBase is the abstract base class for the observers.
 		    /// It will be notified about an item was inserted into or
 		    /// erased from the graph.
 		    ///
 		    /// The observer interface contains some pure virtual functions
 		    /// to override. The add() and erase() functions are
 		    /// to notify the oberver when one item is added or
 		    /// erased.
 		    ///
 		    /// The build() and clear() members are to notify the observer
 		    /// about the container is built from an empty container or
 		    /// is cleared to an empty container.
+		    // \brief ObserverBase is the base class for the observers.
 		    //
 		    // ObserverBase is the abstract base class for the observers.
 		    // It will be notified about an item was inserted into or
 		    // erased from the graph.
 		    //
 		    // The observer interface contains some pure virtual functions
 		    // to override. The add() and erase() functions are
 		    // to notify the oberver when one item is added or
 		    // erased.
 		    //
 		    // The build() and clear() members are to notify the observer
 		    // about the container is built from an empty container or
 		    // is cleared to an empty container.
 		    class ObserverBase {
 		    protected:
 		      typedef AlterationNotifier Notifier;
 		      friend class AlterationNotifier;
 		      /// \brief Default constructor.
 		      ///
 		      /// Default constructor for ObserverBase.
 		      ///
 		      // \brief Default constructor.
 		      //
 		      // Default constructor for ObserverBase.
 		      ObserverBase() : _notifier(0) {}
 		      /// \brief Constructor which attach the observer into notifier.
 		      ///
-		      /// Constructor which attach the observer into notifier.
+		      // \brief Constructor which attach the observer into notifier.
 		      //
 		      // Constructor which attach the observer into notifier.
 		      ObserverBase(AlterationNotifier& nf) {
 		        attach(nf);
+		      }
 		      /// \brief Constructor which attach the obserever to the same notifier.
 		      ///
 		      /// Constructor which attach the obserever to the same notifier as
 		      /// the other observer is attached to.
 		      // \brief Constructor which attach the obserever to the same notifier.
 		      //
 		      // Constructor which attach the obserever to the same notifier as
 		      // the other observer is attached to.
 		      ObserverBase(const ObserverBase& copy) {
 		        if (copy.attached()) {
 		          attach(*copy.notifier());
+		        }
+		      }
-		      /// \brief Destructor
 		      // \brief Destructor
 		      virtual ~ObserverBase() {
 		        if (attached()) {
 		          detach();
+		        }
+		      }
 		      /// \brief Attaches the observer into an AlterationNotifier.
 		      ///
 		      /// This member attaches the observer into an AlterationNotifier.
 		      ///
 		      // \brief Attaches the observer into an AlterationNotifier.
 		      //
 		      // This member attaches the observer into an AlterationNotifier.
 		      void attach(AlterationNotifier& nf) {
 		        nf.attach(*this);
+		      }
 		      /// \brief Detaches the observer into an AlterationNotifier.
 		      ///
 		      /// This member detaches the observer from an AlterationNotifier.
 		      ///
 		      // \brief Detaches the observer into an AlterationNotifier.
 		      //
 		      // This member detaches the observer from an AlterationNotifier.
 		      void detach() {
 		        _notifier->detach(*this);
+		      }
 		      /// \brief Gives back a pointer to the notifier which the map
 		      /// attached into.
 		      ///
 		      /// This function gives back a pointer to the notifier which the map
 		      /// attached into.
 		      ///
 		      // \brief Gives back a pointer to the notifier which the map
 		      // attached into.
 		      //
 		      // This function gives back a pointer to the notifier which the map
 		      // attached into.
 		      Notifier* notifier() const { return const_cast<Notifier*>(_notifier); }
-		      /// Gives back true when the observer is attached into a notifier.
 		      // Gives back true when the observer is attached into a notifier.
 		      bool attached() const { return _notifier != 0; }
 		    private:
@@ -200,55 +194,54 @@
 		      Notifier* _notifier;
 		      typename std::list<ObserverBase*>::iterator _index;
 		      /// \brief The member function to notificate the observer about an
 		      /// item is added to the container.
 		      ///
 		      /// The add() member function notificates the observer about an item
 		      /// is added to the container. It have to be overrided in the
 		      /// subclasses.
 		      // \brief The member function to notificate the observer about an
 		      // item is added to the container.
 		      //
 		      // The add() member function notificates the observer about an item
 		      // is added to the container. It have to be overrided in the
 		      // subclasses.
 		      virtual void add(const Item&) = 0;
 		      /// \brief The member function to notificate the observer about
 		      /// more item is added to the container.
 		      ///
 		      /// The add() member function notificates the observer about more item
 		      /// is added to the container. It have to be overrided in the
 		      /// subclasses.
 		      // \brief The member function to notificate the observer about
 		      // more item is added to the container.
 		      //
 		      // The add() member function notificates the observer about more item
 		      // is added to the container. It have to be overrided in the
 		      // subclasses.
 		      virtual void add(const std::vector<Item>& items) = 0;
 		      /// \brief The member function to notificate the observer about an
 		      /// item is erased from the container.
 		      ///
 		      /// The erase() member function notificates the observer about an
 		      /// item is erased from the container. It have to be overrided in
 		      /// the subclasses.
 		      // \brief The member function to notificate the observer about an
 		      // item is erased from the container.
 		      //
 		      // The erase() member function notificates the observer about an
 		      // item is erased from the container. It have to be overrided in
 		      // the subclasses.
 		      virtual void erase(const Item&) = 0;
 		      /// \brief The member function to notificate the observer about
 		      /// more item is erased from the container.
 		      ///
 		      /// The erase() member function notificates the observer about more item
 		      /// is erased from the container. It have to be overrided in the
 		      /// subclasses.
 		      // \brief The member function to notificate the observer about
 		      // more item is erased from the container.
 		      //
 		      // The erase() member function notificates the observer about more item
 		      // is erased from the container. It have to be overrided in the
 		      // subclasses.
 		      virtual void erase(const std::vector<Item>& items) = 0;
 		      /// \brief The member function to notificate the observer about the
 		      /// container is built.
 		      ///
 		      /// The build() member function notificates the observer about the
 		      /// container is built from an empty container. It have to be
 		      /// overrided in the subclasses.
+		      // \brief The member function to notificate the observer about the
 		      // container is built.
 		      //
 		      // The build() member function notificates the observer about the
 		      // container is built from an empty container. It have to be
 		      // overrided in the subclasses.
 		      virtual void build() = 0;
 		      /// \brief The member function to notificate the observer about all
 		      /// items are erased from the container.
 		      ///
 		      /// The clear() member function notificates the observer about all
 		      /// items are erased from the container. It have to be overrided in
 		      /// the subclasses.
 		      // \brief The member function to notificate the observer about all
 		      // items are erased from the container.
 		      //
 		      // The clear() member function notificates the observer about all
 		      // items are erased from the container. It have to be overrided in
 		      // the subclasses.
 		      virtual void clear() = 0;
 		    };
@@ -261,43 +254,42 @@
 		  public:
 		    /// \brief Default constructor.
 		    ///
 		    /// The default constructor of the AlterationNotifier.
 		    /// It creates an empty notifier.
 		    // \brief Default constructor.
 		    //
 		    // The default constructor of the AlterationNotifier.
 		    // It creates an empty notifier.
 		    AlterationNotifier()
 		      : container(0) {}
 		    /// \brief Constructor.
 		    ///
-		    /// Constructor with the observed container parameter.
+		    // \brief Constructor.
 		    //
 		    // Constructor with the observed container parameter.
 		    AlterationNotifier(const Container& _container)
 		      : container(&_container) {}
 		    /// \brief Copy Constructor of the AlterationNotifier.
 		    ///
 		    /// Copy constructor of the AlterationNotifier.
 		    /// It creates only an empty notifier because the copiable
-		    /// notifier's observers have to be registered still into that notifier.
+		    // \brief Copy Constructor of the AlterationNotifier.
 		    //
 		    // Copy constructor of the AlterationNotifier.
 		    // It creates only an empty notifier because the copiable
 		    // notifier's observers have to be registered still into that notifier.
 		    AlterationNotifier(const AlterationNotifier& _notifier)
 		      : container(_notifier.container) {}
 		    /// \brief Destructor.
 		    ///
 		    /// Destructor of the AlterationNotifier.
 		    ///
 		    // \brief Destructor.
 		    //
 		    // Destructor of the AlterationNotifier.
 		    ~AlterationNotifier() {
 		      typename Observers::iterator it;
 		      for (it = _observers.begin(); it != _observers.end(); ++it) {
 		        (*it)->_notifier = 0;
+		      }
+		    }
 		    /// \brief Sets the container.
 		    ///
-		    /// Sets the container.
+		    // \brief Sets the container.
 		    //
 		    // Sets the container.
 		    void setContainer(const Container& _container) {
 		      container = &_container;
+		    }
@@ -306,36 +298,34 @@
 		    AlterationNotifier& operator=(const AlterationNotifier&);
 		  public:
 		    /// \brief First item in the container.
 		    ///
 		    /// Returns the first item in the container. It is
 		    /// for start the iteration on the container.
 		    // \brief First item in the container.
 		    //
 		    // Returns the first item in the container. It is
 		    // for start the iteration on the container.
 		    void first(Item& item) const {
 		      container->first(item);
+		    }
 		    /// \brief Next item in the container.
 		    ///
 		    /// Returns the next item in the container. It is
 		    /// for iterate on the container.
 		    // \brief Next item in the container.
 		    //
 		    // Returns the next item in the container. It is
 		    // for iterate on the container.
 		    void next(Item& item) const {
 		      container->next(item);
+		    }
 		    /// \brief Returns the id of the item.
 		    ///
-		    /// Returns the id of the item provided by the container.
+		    // \brief Returns the id of the item.
 		    //
 		    // Returns the id of the item provided by the container.
 		    int id(const Item& item) const {
 		      return container->id(item);
+		    }
 		    /// \brief Returns the maximum id of the container.
 		    ///
-		    /// Returns the maximum id of the container.
+		    // \brief Returns the maximum id of the container.
 		    //
 		    // Returns the maximum id of the container.
 		    int maxId() const {
 		      return container->maxId(Item());
+		    }
@@ -353,14 +343,13 @@
+		    }
 		  public:
 		    /// \brief Notifies all the registed observers about an item added to
 		    /// the container.
 		    ///
 		    /// It notifies all the registed observers about an item added to
 		    /// the container.
 		    ///
 		    // \brief Notifies all the registed observers about an item added to
 		    // the container.
 		    //
 		    // It notifies all the registed observers about an item added to
 		    // the container.
 		    void add(const Item& item) {
 		      typename Observers::reverse_iterator it;
 		      try {
 		        for (it = _observers.rbegin(); it != _observers.rend(); ++it) {
@@ -374,14 +363,13 @@
 		        throw;
+		      }
+		    }
 		    /// \brief Notifies all the registed observers about more item added to
 		    /// the container.
 		    ///
 		    /// It notifies all the registed observers about more item added to
 		    /// the container.
 		    ///
 		    // \brief Notifies all the registed observers about more item added to
 		    // the container.
 		    //
 		    // It notifies all the registed observers about more item added to
 		    // the container.
 		    void add(const std::vector<Item>& items) {
 		      typename Observers::reverse_iterator it;
 		      try {
 		        for (it = _observers.rbegin(); it != _observers.rend(); ++it) {
@@ -395,14 +383,13 @@
 		        throw;
+		      }
+		    }
 		    /// \brief Notifies all the registed observers about an item erased from
 		    /// the container.
 		    ///
 		    /// It notifies all the registed observers about an item erased from
 		    /// the container.
 		    ///
 		    // \brief Notifies all the registed observers about an item erased from
 		    // the container.
 		    //
 		    // It notifies all the registed observers about an item erased from
 		    // the container.
 		    void erase(const Item& item) throw() {
 		      typename Observers::iterator it = _observers.begin();
 		      while (it != _observers.end()) {
 		        try {
@@ -415,14 +402,13 @@
+		        }
+		      }
+		    }
 		    /// \brief Notifies all the registed observers about more item erased
 		    /// from the container.
 		    ///
 		    /// It notifies all the registed observers about more item erased from
 		    /// the container.
 		    ///
 		    // \brief Notifies all the registed observers about more item erased
 		    // from the container.
 		    //
 		    // It notifies all the registed observers about more item erased from
 		    // the container.
 		    void erase(const std::vector<Item>& items) {
 		      typename Observers::iterator it = _observers.begin();
 		      while (it != _observers.end()) {
 		        try {
@@ -435,13 +421,13 @@
+		        }
+		      }
+		    }
 		    /// \brief Notifies all the registed observers about the container is
 		    /// built.
 		    ///
 		    /// Notifies all the registed observers about the container is built
-		    /// from an empty container.
+		    // \brief Notifies all the registed observers about the container is
 		    // built.
 		    //
 		    // Notifies all the registed observers about the container is built
 		    // from an empty container.
 		    void build() {
 		      typename Observers::reverse_iterator it;
 		      try {
 		        for (it = _observers.rbegin(); it != _observers.rend(); ++it) {
@@ -455,13 +441,13 @@
 		        throw;
+		      }
+		    }
 		    /// \brief Notifies all the registed observers about all items are
 		    /// erased.
 		    ///
 		    /// Notifies all the registed observers about all items are erased
-		    /// from the container.
+		    // \brief Notifies all the registed observers about all items are
 		    // erased.
 		    //
 		    // Notifies all the registed observers about all items are erased
 		    // from the container.
 		    void clear() {
 		      typename Observers::iterator it = _observers.begin();
 		      while (it != _observers.end()) {
 		        try {

lemon/bits/array_map.h

Show inline comments

@@ -25,60 +25,60 @@
 		#include <lemon/bits/alteration_notifier.h>
 		#include <lemon/concept_check.h>
 		#include <lemon/concepts/maps.h>
 		/// \ingroup graphbits
 		/// \file
-		/// \brief Graph map based on the array storage.
+		// \ingroup graphbits
 		// \file
 		// \brief Graph map based on the array storage.
 		namespace lemon {
 		  /// \ingroup graphbits
 		  ///
 		  /// \brief Graph map based on the array storage.
 		  ///
 		  /// The ArrayMap template class is graph map structure what
 		  /// automatically updates the map when a key is added to or erased from
 		  /// the map. This map uses the allocators to implement
 		  /// the container functionality.
 		  ///
 		  /// The template parameters are the Graph the current Item type and
-		  /// the Value type of the map.
+		  // \ingroup graphbits
 		  //
 		  // \brief Graph map based on the array storage.
 		  //
 		  // The ArrayMap template class is graph map structure what
 		  // automatically updates the map when a key is added to or erased from
 		  // the map. This map uses the allocators to implement
 		  // the container functionality.
 		  //
 		  // The template parameters are the Graph the current Item type and
 		  // the Value type of the map.
 		  template <typename _Graph, typename _Item, typename _Value>
 		  class ArrayMap
 		    : public ItemSetTraits<_Graph, _Item>::ItemNotifier::ObserverBase {
 		  public:
-		    /// The graph type of the maps.
 		    // The graph type of the maps.
 		    typedef _Graph Graph;
-		    /// The item type of the map.
 		    // The item type of the map.
 		    typedef _Item Item;
-		    /// The reference map tag.
 		    // The reference map tag.
 		    typedef True ReferenceMapTag;
-		    /// The key type of the maps.
 		    // The key type of the maps.
 		    typedef _Item Key;
-		    /// The value type of the map.
 		    // The value type of the map.
 		    typedef _Value Value;
-		    /// The const reference type of the map.
 		    // The const reference type of the map.
 		    typedef const _Value& ConstReference;
-		    /// The reference type of the map.
 		    // The reference type of the map.
 		    typedef _Value& Reference;
-		    /// The notifier type.
 		    // The notifier type.
 		    typedef typename ItemSetTraits<_Graph, _Item>::ItemNotifier Notifier;
-		    /// The MapBase of the Map which imlements the core regisitry function.
 		    // The MapBase of the Map which imlements the core regisitry function.
 		    typedef typename Notifier::ObserverBase Parent;
 		  private:
 		    typedef std::allocator<Value> Allocator;
 		  public:
 		    /// \brief Graph initialized map constructor.
 		    ///
-		    /// Graph initialized map constructor.
+		    // \brief Graph initialized map constructor.
 		    //
 		    // Graph initialized map constructor.
 		    explicit ArrayMap(const Graph& graph) {
 		      Parent::attach(graph.notifier(Item()));
 		      allocate_memory();
 		      Notifier* nf = Parent::notifier();
@@ -88,11 +88,11 @@
 		        allocator.construct(&(values[id]), Value());
+		      }
+		    }
 		    /// \brief Constructor to use default value to initialize the map.
 		    ///
-		    /// It constructs a map and initialize all of the the map.
+		    // \brief Constructor to use default value to initialize the map.
 		    //
 		    // It constructs a map and initialize all of the the map.
 		    ArrayMap(const Graph& graph, const Value& value) {
 		      Parent::attach(graph.notifier(Item()));
 		      allocate_memory();
 		      Notifier* nf = Parent::notifier();
@@ -103,11 +103,11 @@
+		      }
+		    }
 		  private:
 		    /// \brief Constructor to copy a map of the same map type.
 		    ///
-		    /// Constructor to copy a map of the same map type.
+		    // \brief Constructor to copy a map of the same map type.
 		    //
 		    // Constructor to copy a map of the same map type.
 		    ArrayMap(const ArrayMap& copy) : Parent() {
 		      if (copy.attached()) {
 		        attach(*copy.notifier());
+		      }
@@ -121,26 +121,26 @@
 		        allocator.construct(&(values[id]), copy.values[id]);
+		      }
+		    }
 		    /// \brief Assign operator.
 		    ///
 		    /// This operator assigns for each item in the map the
 		    /// value mapped to the same item in the copied map.
 		    /// The parameter map should be indiced with the same
 		    /// itemset because this assign operator does not change
-		    /// the container of the map.
+		    // \brief Assign operator.
 		    //
 		    // This operator assigns for each item in the map the
 		    // value mapped to the same item in the copied map.
 		    // The parameter map should be indiced with the same
 		    // itemset because this assign operator does not change
 		    // the container of the map.
 		    ArrayMap& operator=(const ArrayMap& cmap) {
 		      return operator=<ArrayMap>(cmap);
+		    }
 		    /// \brief Template assign operator.
 		    ///
 		    /// The given parameter should be conform to the ReadMap
 		    /// concecpt and could be indiced by the current item set of
 		    /// the NodeMap. In this case the value for each item
 		    /// is assigned by the value of the given ReadMap.
 		    // \brief Template assign operator.
 		    //
 		    // The given parameter should be conform to the ReadMap
 		    // concecpt and could be indiced by the current item set of
 		    // the NodeMap. In this case the value for each item
 		    // is assigned by the value of the given ReadMap.
 		    template <typename CMap>
 		    ArrayMap& operator=(const CMap& cmap) {
 		      checkConcept<concepts::ReadMap<Key, _Value>, CMap>();
 		      const typename Parent::Notifier* nf = Parent::notifier();
@@ -151,11 +151,11 @@
 		      return *this;
+		    }
 		  public:
 		    /// \brief The destructor of the map.
 		    ///
-		    /// The destructor of the map.
+		    // \brief The destructor of the map.
 		    //
 		    // The destructor of the map.
 		    virtual ~ArrayMap() {
 		      if (attached()) {
 		        clear();
 		        detach();
@@ -169,40 +169,40 @@
 		    using Parent::attached;
 		  public:
 		    /// \brief The subscript operator.
 		    ///
 		    /// The subscript operator. The map can be subscripted by the
 		    /// actual keys of the graph.
 		    // \brief The subscript operator.
 		    //
 		    // The subscript operator. The map can be subscripted by the
 		    // actual keys of the graph.
 		    Value& operator[](const Key& key) {
 		      int id = Parent::notifier()->id(key);
 		      return values[id];
+		    }
 		    /// \brief The const subscript operator.
 		    ///
 		    /// The const subscript operator. The map can be subscripted by the
 		    /// actual keys of the graph.
 		    // \brief The const subscript operator.
 		    //
 		    // The const subscript operator. The map can be subscripted by the
 		    // actual keys of the graph.
 		    const Value& operator[](const Key& key) const {
 		      int id = Parent::notifier()->id(key);
 		      return values[id];
+		    }
 		    /// \brief Setter function of the map.
 		    ///
 		    /// Setter function of the map. Equivalent with map[key] = val.
 		    /// This is a compatibility feature with the not dereferable maps.
 		    // \brief Setter function of the map.
 		    //
 		    // Setter function of the map. Equivalent with map[key] = val.
 		    // This is a compatibility feature with the not dereferable maps.
 		    void set(const Key& key, const Value& val) {
 		      (*this)[key] = val;
+		    }
 		  protected:
 		    /// \brief Adds a new key to the map.
 		    ///
 		    /// It adds a new key to the map. It called by the observer notifier
 		    /// and it overrides the add() member function of the observer base.
 		    // \brief Adds a new key to the map.
 		    //
 		    // It adds a new key to the map. It called by the observer notifier
 		    // and it overrides the add() member function of the observer base.
 		    virtual void add(const Key& key) {
 		      Notifier* nf = Parent::notifier();
 		      int id = nf->id(key);
 		      if (id >= capacity) {
@@ -225,12 +225,12 @@
+		      }
 		      allocator.construct(&(values[id]), Value());
+		    }
 		    /// \brief Adds more new keys to the map.
 		    ///
 		    /// It adds more new keys to the map. It called by the observer notifier
 		    /// and it overrides the add() member function of the observer base.
 		    // \brief Adds more new keys to the map.
 		    //
 		    // It adds more new keys to the map. It called by the observer notifier
 		    // and it overrides the add() member function of the observer base.
 		    virtual void add(const std::vector<Key>& keys) {
 		      Notifier* nf = Parent::notifier();
 		      int max_id = -1;
 		      for (int i = 0; i < int(keys.size()); ++i) {
@@ -269,32 +269,32 @@
 		        allocator.construct(&(values[id]), Value());
+		      }
+		    }
 		    /// \brief Erase a key from the map.
 		    ///
 		    /// Erase a key from the map. It called by the observer notifier
 		    /// and it overrides the erase() member function of the observer base.
 		    // \brief Erase a key from the map.
 		    //
 		    // Erase a key from the map. It called by the observer notifier
 		    // and it overrides the erase() member function of the observer base.
 		    virtual void erase(const Key& key) {
 		      int id = Parent::notifier()->id(key);
 		      allocator.destroy(&(values[id]));
+		    }
 		    /// \brief Erase more keys from the map.
 		    ///
 		    /// Erase more keys from the map. It called by the observer notifier
 		    /// and it overrides the erase() member function of the observer base.
 		    // \brief Erase more keys from the map.
 		    //
 		    // Erase more keys from the map. It called by the observer notifier
 		    // and it overrides the erase() member function of the observer base.
 		    virtual void erase(const std::vector<Key>& keys) {
 		      for (int i = 0; i < int(keys.size()); ++i) {
 		        int id = Parent::notifier()->id(keys[i]);
 		        allocator.destroy(&(values[id]));
+		      }
+		    }
 		    /// \brief Buildes the map.
 		    ///
 		    /// It buildes the map. It called by the observer notifier
 		    /// and it overrides the build() member function of the observer base.
 		    // \brief Buildes the map.
 		    //
 		    // It buildes the map. It called by the observer notifier
 		    // and it overrides the build() member function of the observer base.
 		    virtual void build() {
 		      Notifier* nf = Parent::notifier();
 		      allocate_memory();
 		      Item it;
@@ -303,12 +303,12 @@
 		        allocator.construct(&(values[id]), Value());
+		      }
+		    }
 		    /// \brief Clear the map.
 		    ///
 		    /// It erase all items from the map. It called by the observer notifier
 		    /// and it overrides the clear() member function of the observer base.
 		    // \brief Clear the map.
 		    //
 		    // It erase all items from the map. It called by the observer notifier
 		    // and it overrides the clear() member function of the observer base.
 		    virtual void clear() {
 		      Notifier* nf = Parent::notifier();
 		      if (capacity != 0) {
 		        Item it;

lemon/bits/base_extender.h

Show inline comments

@@ -27,16 +27,16 @@
 		#include <lemon/concept_check.h>
 		#include <lemon/concepts/maps.h>
 		///\ingroup digraphbits
 		///\file
-		///\brief Extenders for the digraph types
+		//\ingroup digraphbits
 		//\file
 		//\brief Extenders for the digraph types
 		namespace lemon {
 		  /// \ingroup digraphbits
 		  ///
-		  /// \brief BaseDigraph to BaseGraph extender
+		  // \ingroup digraphbits
 		  //
 		  // \brief BaseDigraph to BaseGraph extender
 		  template <typename Base>
 		  class UndirDigraphExtender : public Base {
 		  public:
@@ -73,39 +73,39 @@
 		          (!(that.forward<forward) && Edge(*this)<Edge(that));
+		      }
 		    };
-		    /// First node of the edge
 		    // First node of the edge
 		    Node u(const Edge &e) const {
 		      return Parent::source(e);
+		    }
-		    /// Source of the given arc
 		    // Source of the given arc
 		    Node source(const Arc &e) const {
 		      return e.forward ? Parent::source(e) : Parent::target(e);
+		    }
-		    /// Second node of the edge
 		    // Second node of the edge
 		    Node v(const Edge &e) const {
 		      return Parent::target(e);
+		    }
-		    /// Target of the given arc
 		    // Target of the given arc
 		    Node target(const Arc &e) const {
 		      return e.forward ? Parent::target(e) : Parent::source(e);
+		    }
 		    /// \brief Directed arc from an edge.
 		    ///
 		    /// Returns a directed arc corresponding to the specified edge.
 		    /// If the given bool is true, the first node of the given edge and
-		    /// the source node of the returned arc are the same.
+		    // \brief Directed arc from an edge.
 		    //
 		    // Returns a directed arc corresponding to the specified edge.
 		    // If the given bool is true, the first node of the given edge and
 		    // the source node of the returned arc are the same.
 		    static Arc direct(const Edge &e, bool d) {
 		      return Arc(e, d);
+		    }
 		    /// Returns whether the given directed arc has the same orientation
 		    /// as the corresponding edge.
 		    // Returns whether the given directed arc has the same orientation
 		    // as the corresponding edge.
 		    static bool direction(const Arc &a) { return a.forward; }
 		    using Parent::first;
 		    using Parent::next;

lemon/bits/bezier.h

Show inline comments

@@ -18,13 +18,13 @@
 		#ifndef LEMON_BEZIER_H
 		#define LEMON_BEZIER_H
 		///\ingroup misc
 		///\file
 		///\brief Classes to compute with Bezier curves.
 		///
-		///Up to now this file is used internally by \ref graph_to_eps.h
+		//\ingroup misc
 		//\file
 		//\brief Classes to compute with Bezier curves.
 		//
 		//Up to now this file is used internally by \ref graph_to_eps.h
 		#include<lemon/dim2.h>
 		namespace lemon {

lemon/bits/default_map.h

Show inline comments

@@ -18,16 +18,15 @@
 		#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.
+		//\ingroup graphbits
 		//\file
 		//\brief Graph maps that construct and destruct their elements dynamically.
 		namespace lemon {
@@ -148,9 +147,9 @@
 		//   };
 		// #endif
-		  /// \e
+		  // DefaultMap class
 		  template <typename _Graph, typename _Item, typename _Value>
 		  class DefaultMap
 		    : public DefaultMapSelector<_Graph, _Item, _Value>::Map {
 		  public:

lemon/bits/enable_if.h

Show inline comments

@@ -34,31 +34,31 @@
 		#ifndef LEMON_BITS_ENABLE_IF_H
 		#define LEMON_BITS_ENABLE_IF_H
 		///\file
 		///\brief Miscellaneous basic utilities
 		//\file
 		//\brief Miscellaneous basic utilities
 		namespace lemon
+		{
-		  /// Basic type for defining "tags". A "YES" condition for \c enable_if.
 		  // Basic type for defining "tags". A "YES" condition for \c enable_if.
 		  /// Basic type for defining "tags". A "YES" condition for \c enable_if.
 		  ///
-		  ///\sa False
+		  // Basic type for defining "tags". A "YES" condition for \c enable_if.
 		  //
 		  //\sa False
 		  struct True {
-		    ///\e
 		    //\e
 		    static const bool value = true;
 		  };
-		  /// Basic type for defining "tags". A "NO" condition for \c enable_if.
 		  // Basic type for defining "tags". A "NO" condition for \c enable_if.
 		  /// Basic type for defining "tags". A "NO" condition for \c enable_if.
 		  ///
-		  ///\sa True
+		  // Basic type for defining "tags". A "NO" condition for \c enable_if.
 		  //
 		  //\sa True
 		  struct False {
-		    ///\e
 		    //\e
 		    static const bool value = false;
 		  };

lemon/bits/graph_extender.h

Show inline comments

@@ -26,16 +26,16 @@
 		#include <lemon/concept_check.h>
 		#include <lemon/concepts/maps.h>
 		///\ingroup graphbits
 		///\file
-		///\brief Extenders for the digraph types
+		//\ingroup graphbits
 		//\file
 		//\brief Extenders for the digraph types
 		namespace lemon {
 		  /// \ingroup graphbits
 		  ///
-		  /// \brief Extender for the Digraphs
+		  // \ingroup graphbits
 		  //
 		  // \brief Extender for the Digraphs
 		  template <typename Base>
 		  class DigraphExtender : public Base {
 		  public:
@@ -185,32 +185,32 @@
+		      }
 		    };
 		    /// \brief Base node of the iterator
 		    ///
-		    /// Returns the base node (i.e. the source in this case) of the iterator
+		    // \brief Base node of the iterator
 		    //
 		    // Returns the base node (i.e. the source in this case) of the iterator
 		    Node baseNode(const OutArcIt &arc) const {
 		      return Parent::source(arc);
+		    }
 		    /// \brief Running node of the iterator
 		    ///
 		    /// Returns the running node (i.e. the target in this case) of the
 		    /// iterator
 		    // \brief Running node of the iterator
 		    //
 		    // Returns the running node (i.e. the target in this case) of the
 		    // iterator
 		    Node runningNode(const OutArcIt &arc) const {
 		      return Parent::target(arc);
+		    }
 		    /// \brief Base node of the iterator
 		    ///
-		    /// Returns the base node (i.e. the target in this case) of the iterator
+		    // \brief Base node of the iterator
 		    //
 		    // Returns the base node (i.e. the target in this case) of the iterator
 		    Node baseNode(const InArcIt &arc) const {
 		      return Parent::target(arc);
+		    }
 		    /// \brief Running node of the iterator
 		    ///
 		    /// Returns the running node (i.e. the source in this case) of the
 		    /// iterator
 		    // \brief Running node of the iterator
 		    //
 		    // Returns the running node (i.e. the source in this case) of the
 		    // iterator
 		    Node runningNode(const InArcIt &arc) const {
 		      return Parent::source(arc);
+		    }
@@ -324,11 +324,11 @@
 		      node_notifier.clear();
+		    }
 		  };
 		  /// \ingroup _graphbits
 		  ///
-		  /// \brief Extender for the Graphs
+		  // \ingroup _graphbits
 		  //
 		  // \brief Extender for the Graphs
 		  template <typename Base>
 		  class GraphExtender : public Base {
 		  public:
@@ -554,45 +554,45 @@
 		        return *this;
+		      }
 		    };
 		    /// \brief Base node of the iterator
 		    ///
-		    /// Returns the base node (ie. the source in this case) of the iterator
+		    // \brief Base node of the iterator
 		    //
 		    // Returns the base node (ie. the source in this case) of the iterator
 		    Node baseNode(const OutArcIt &arc) const {
 		      return Parent::source(static_cast<const Arc&>(arc));
+		    }
 		    /// \brief Running node of the iterator
 		    ///
 		    /// Returns the running node (ie. the target in this case) of the
 		    /// iterator
 		    // \brief Running node of the iterator
 		    //
 		    // Returns the running node (ie. the target in this case) of the
 		    // iterator
 		    Node runningNode(const OutArcIt &arc) const {
 		      return Parent::target(static_cast<const Arc&>(arc));
+		    }
 		    /// \brief Base node of the iterator
 		    ///
-		    /// Returns the base node (ie. the target in this case) of the iterator
+		    // \brief Base node of the iterator
 		    //
 		    // Returns the base node (ie. the target in this case) of the iterator
 		    Node baseNode(const InArcIt &arc) const {
 		      return Parent::target(static_cast<const Arc&>(arc));
+		    }
 		    /// \brief Running node of the iterator
 		    ///
 		    /// Returns the running node (ie. the source in this case) of the
 		    /// iterator
 		    // \brief Running node of the iterator
 		    //
 		    // Returns the running node (ie. the source in this case) of the
 		    // iterator
 		    Node runningNode(const InArcIt &arc) const {
 		      return Parent::source(static_cast<const Arc&>(arc));
+		    }
 		    /// Base node of the iterator
 		    ///
-		    /// Returns the base node of the iterator
+		    // Base node of the iterator
 		    //
 		    // Returns the base node of the iterator
 		    Node baseNode(const IncEdgeIt &edge) const {
 		      return edge._direction ? u(edge) : v(edge);
+		    }
 		    /// Running node of the iterator
 		    ///
-		    /// Returns the running node of the iterator
+		    // Running node of the iterator
 		    //
 		    // Returns the running node of the iterator
 		    Node runningNode(const IncEdgeIt &edge) const {
 		      return edge._direction ? v(edge) : u(edge);
+		    }

lemon/bits/map_extender.h

Show inline comments

@@ -25,16 +25,16 @@
 		#include <lemon/concept_check.h>
 		#include <lemon/concepts/maps.h>
 		///\file
 		///\brief Extenders for iterable maps.
 		//\file
 		//\brief Extenders for iterable maps.
 		namespace lemon {
 		  /// \ingroup graphbits
 		  ///
-		  /// \brief Extender for maps
+		  // \ingroup graphbits
 		  //
 		  // \brief Extender for maps
 		  template <typename _Map>
 		  class MapExtender : public _Map {
 		  public:
@@ -170,11 +170,11 @@
 		    };
 		  };
 		  /// \ingroup graphbits
 		  ///
-		  /// \brief Extender for maps which use a subset of the items.
+		  // \ingroup graphbits
 		  //
 		  // \brief Extender for maps which use a subset of the items.
 		  template <typename _Graph, typename _Map>
 		  class SubMapExtender : public _Map {
 		  public:

lemon/bits/traits.h

Show inline comments

@@ -18,11 +18,11 @@
 		#ifndef LEMON_BITS_TRAITS_H
 		#define LEMON_BITS_TRAITS_H
 		///\file
 		///\brief Traits for graphs and maps
-		///
+		//\file
 		//\brief Traits for graphs and maps
 		//
 		#include <lemon/bits/enable_if.h>
 		namespace lemon {

lemon/bits/vector_map.h

Show inline comments

@@ -27,108 +27,108 @@
 		#include <lemon/concept_check.h>
 		#include <lemon/concepts/maps.h>
 		///\ingroup graphbits
 		///
 		///\file
 		///\brief Vector based graph maps.
 		//\ingroup graphbits
 		//
 		//\file
 		//\brief Vector based graph maps.
 		namespace lemon {
 		  /// \ingroup graphbits
 		  ///
 		  /// \brief Graph map based on the std::vector storage.
 		  ///
 		  /// The VectorMap template class is graph map structure what
 		  /// automatically updates the map when a key is added to or erased from
 		  /// the map. This map type uses the std::vector to store the values.
 		  ///
 		  /// \tparam _Graph The graph this map is attached to.
 		  /// \tparam _Item The item type of the graph items.
-		  /// \tparam _Value The value type of the map.
+		  // \ingroup graphbits
 		  //
 		  // \brief Graph map based on the std::vector storage.
 		  //
 		  // The VectorMap template class is graph map structure what
 		  // automatically updates the map when a key is added to or erased from
 		  // the map. This map type uses the std::vector to store the values.
 		  //
 		  // \tparam _Graph The graph this map is attached to.
 		  // \tparam _Item The item type of the graph items.
 		  // \tparam _Value The value type of the map.
 		  template <typename _Graph, typename _Item, typename _Value>
 		  class VectorMap
 		    : public ItemSetTraits<_Graph, _Item>::ItemNotifier::ObserverBase {
 		  private:
-		    /// The container type of the map.
 		    // The container type of the map.
 		    typedef std::vector<_Value> Container;
 		  public:
-		    /// The graph type of the map.
 		    // The graph type of the map.
 		    typedef _Graph Graph;
-		    /// The item type of the map.
 		    // The item type of the map.
 		    typedef _Item Item;
-		    /// The reference map tag.
 		    // The reference map tag.
 		    typedef True ReferenceMapTag;
-		    /// The key type of the map.
 		    // The key type of the map.
 		    typedef _Item Key;
-		    /// The value type of the map.
 		    // The value type of the map.
 		    typedef _Value Value;
-		    /// The notifier type.
 		    // The notifier type.
 		    typedef typename ItemSetTraits<_Graph, _Item>::ItemNotifier Notifier;
-		    /// The map type.
 		    // The map type.
 		    typedef VectorMap Map;
-		    /// The base class of the map.
 		    // The base class of the map.
 		    typedef typename Notifier::ObserverBase Parent;
-		    /// The reference type of the map;
 		    // The reference type of the map;
 		    typedef typename Container::reference Reference;
-		    /// The const reference type of the map;
 		    // The const reference type of the map;
 		    typedef typename Container::const_reference ConstReference;
 		    /// \brief Constructor to attach the new map into the notifier.
 		    ///
 		    /// It constructs a map and attachs it into the notifier.
 		    /// It adds all the items of the graph to the map.
 		    // \brief Constructor to attach the new map into the notifier.
 		    //
 		    // It constructs a map and attachs it into the notifier.
 		    // It adds all the items of the graph to the map.
 		    VectorMap(const Graph& graph) {
 		      Parent::attach(graph.notifier(Item()));
 		      container.resize(Parent::notifier()->maxId() + 1);
+		    }
 		    /// \brief Constructor uses given value to initialize the map.
 		    ///
 		    /// It constructs a map uses a given value to initialize the map.
 		    /// It adds all the items of the graph to the map.
 		    // \brief Constructor uses given value to initialize the map.
 		    //
 		    // It constructs a map uses a given value to initialize the map.
 		    // It adds all the items of the graph to the map.
 		    VectorMap(const Graph& graph, const Value& value) {
 		      Parent::attach(graph.notifier(Item()));
 		      container.resize(Parent::notifier()->maxId() + 1, value);
+		    }
 		  private:
 		    /// \brief Copy constructor
 		    ///
-		    /// Copy constructor.
+		    // \brief Copy constructor
 		    //
 		    // Copy constructor.
 		    VectorMap(const VectorMap& _copy) : Parent() {
 		      if (_copy.attached()) {
 		        Parent::attach(*_copy.notifier());
 		        container = _copy.container;
+		      }
+		    }
 		    /// \brief Assign operator.
 		    ///
 		    /// This operator assigns for each item in the map the
 		    /// value mapped to the same item in the copied map.
 		    /// The parameter map should be indiced with the same
 		    /// itemset because this assign operator does not change
-		    /// the container of the map.
+		    // \brief Assign operator.
 		    //
 		    // This operator assigns for each item in the map the
 		    // value mapped to the same item in the copied map.
 		    // The parameter map should be indiced with the same
 		    // itemset because this assign operator does not change
 		    // the container of the map.
 		    VectorMap& operator=(const VectorMap& cmap) {
 		      return operator=<VectorMap>(cmap);
+		    }
 		    /// \brief Template assign operator.
 		    ///
 		    /// The given parameter should be conform to the ReadMap
 		    /// concecpt and could be indiced by the current item set of
 		    /// the NodeMap. In this case the value for each item
 		    /// is assigned by the value of the given ReadMap.
 		    // \brief Template assign operator.
 		    //
 		    // The given parameter should be conform to the ReadMap
 		    // concecpt and could be indiced by the current item set of
 		    // the NodeMap. In this case the value for each item
 		    // is assigned by the value of the given ReadMap.
 		    template <typename CMap>
 		    VectorMap& operator=(const CMap& cmap) {
 		      checkConcept<concepts::ReadMap<Key, _Value>, CMap>();
 		      const typename Parent::Notifier* nf = Parent::notifier();
@@ -140,49 +140,49 @@
+		    }
 		  public:
 		    /// \brief The subcript operator.
 		    ///
 		    /// The subscript operator. The map can be subscripted by the
 		    /// actual items of the graph.
 		    // \brief The subcript operator.
 		    //
 		    // The subscript operator. The map can be subscripted by the
 		    // actual items of the graph.
 		    Reference operator[](const Key& key) {
 		      return container[Parent::notifier()->id(key)];
+		    }
 		    /// \brief The const subcript operator.
 		    ///
 		    /// The const subscript operator. The map can be subscripted by the
 		    /// actual items of the graph.
 		    // \brief The const subcript operator.
 		    //
 		    // The const subscript operator. The map can be subscripted by the
 		    // actual items of the graph.
 		    ConstReference operator[](const Key& key) const {
 		      return container[Parent::notifier()->id(key)];
+		    }
 		    /// \brief The setter function of the map.
 		    ///
-		    /// It the same as operator[](key) = value expression.
+		    // \brief The setter function of the map.
 		    //
 		    // It the same as operator[](key) = value expression.
 		    void set(const Key& key, const Value& value) {
 		      (*this)[key] = value;
+		    }
 		  protected:
 		    /// \brief Adds a new key to the map.
 		    ///
 		    /// It adds a new key to the map. It called by the observer notifier
 		    /// and it overrides the add() member function of the observer base.
 		    // \brief Adds a new key to the map.
 		    //
 		    // It adds a new key to the map. It called by the observer notifier
 		    // and it overrides the add() member function of the observer base.
 		    virtual void add(const Key& key) {
 		      int id = Parent::notifier()->id(key);
 		      if (id >= int(container.size())) {
 		        container.resize(id + 1);
+		      }
+		    }
 		    /// \brief Adds more new keys to the map.
 		    ///
 		    /// It adds more new keys to the map. It called by the observer notifier
 		    /// and it overrides the add() member function of the observer base.
 		    // \brief Adds more new keys to the map.
 		    //
 		    // It adds more new keys to the map. It called by the observer notifier
 		    // and it overrides the add() member function of the observer base.
 		    virtual void add(const std::vector<Key>& keys) {
 		      int max = container.size() - 1;
 		      for (int i = 0; i < int(keys.size()); ++i) {
 		        int id = Parent::notifier()->id(keys[i]);
@@ -192,40 +192,40 @@
+		      }
 		      container.resize(max + 1);
+		    }
 		    /// \brief Erase a key from the map.
 		    ///
 		    /// Erase a key from the map. It called by the observer notifier
 		    /// and it overrides the erase() member function of the observer base.
 		    // \brief Erase a key from the map.
 		    //
 		    // Erase a key from the map. It called by the observer notifier
 		    // and it overrides the erase() member function of the observer base.
 		    virtual void erase(const Key& key) {
 		      container[Parent::notifier()->id(key)] = Value();
+		    }
 		    /// \brief Erase more keys from the map.
 		    ///
 		    /// Erase more keys from the map. It called by the observer notifier
 		    /// and it overrides the erase() member function of the observer base.
 		    // \brief Erase more keys from the map.
 		    //
 		    // Erase more keys from the map. It called by the observer notifier
 		    // and it overrides the erase() member function of the observer base.
 		    virtual void erase(const std::vector<Key>& keys) {
 		      for (int i = 0; i < int(keys.size()); ++i) {
 		        container[Parent::notifier()->id(keys[i])] = Value();
+		      }
+		    }
 		    /// \brief Buildes the map.
 		    ///
 		    /// It buildes the map. It called by the observer notifier
 		    /// and it overrides the build() member function of the observer base.
 		    // \brief Buildes the map.
 		    //
 		    // It buildes the map. It called by the observer notifier
 		    // and it overrides the build() member function of the observer base.
 		    virtual void build() {
 		      int size = Parent::notifier()->maxId() + 1;
 		      container.reserve(size);
 		      container.resize(size);
+		    }
 		    /// \brief Clear the map.
 		    ///
 		    /// It erase all items from the map. It called by the observer notifier
 		    /// and it overrides the clear() member function of the observer base.
 		    // \brief Clear the map.
 		    //
 		    // It erase all items from the map. It called by the observer notifier
 		    // and it overrides the clear() member function of the observer base.
 		    virtual void clear() {
 		      container.clear();
+		    }

lemon/color.h

Show inline comments

@@ -91,9 +91,9 @@
 		  extern const Color DARK_MAGENTA;
 		  /// Dark cyan color constant
 		  extern const Color DARK_CYAN;
-		  ///Map <tt>int</tt>s to different \ref Color "Color"s
+		  ///Map <tt>int</tt>s to different <tt>Color</tt>s
 		  ///This map assigns one of the predefined \ref Color "Color"s to
 		  ///each <tt>int</tt>. It is possible to change the colors as well as
 		  ///their number. The integer range is cyclically mapped to the

lemon/concepts/graph_components.h

Show inline comments

@@ -981,9 +981,9 @@
 		    /// \brief Class describing the concept of graph maps
 		    ///
 		    /// This class describes the common interface of the graph maps
-		    /// (NodeMap, ArcMap), that is \ref maps-page "maps" which can be used to
+		    /// (NodeMap, ArcMap), that is maps that can be used to
 		    /// associate data to graph descriptors (nodes or arcs).
 		    template <typename _Graph, typename _Item, typename _Value>
 		    class GraphMap : public ReadWriteMap<_Item, _Value> {
 		    public:

lemon/concepts/maps.h

Show inline comments

@@ -21,17 +21,17 @@
 		#include <lemon/core.h>
 		#include <lemon/concept_check.h>
-		///\ingroup concept
+		///\ingroup map_concepts
 		///\file
 		///\brief The concept of maps.
 		namespace lemon {
 		  namespace concepts {
-		    /// \addtogroup concept
+		    /// \addtogroup map_concepts
 		    /// @{
 		    /// Readable map concept

lemon/core.h

Show inline comments

@@ -57,9 +57,9 @@
 		  /// \addtogroup gutils
 		  /// @{
-		  ///Create convenient typedefs for the digraph types and iterators
+		  ///Create convenience typedefs for the digraph types and iterators
 		  ///This \c \#define creates convenient type definitions for the following
 		  ///types of \c Digraph: \c Node,  \c NodeIt, \c Arc, \c ArcIt, \c InArcIt,
 		  ///\c OutArcIt, \c BoolNodeMap, \c IntNodeMap, \c DoubleNodeMap,
@@ -79,11 +79,11 @@
 		  typedef Digraph::NodeMap<int> IntNodeMap;                             \
 		  typedef Digraph::NodeMap<double> DoubleNodeMap;                       \
 		  typedef Digraph::ArcMap<bool> BoolArcMap;                             \
 		  typedef Digraph::ArcMap<int> IntArcMap;                               \
-		  typedef Digraph::ArcMap<double> DoubleArcMap;
 		  typedef Digraph::ArcMap<double> DoubleArcMap
-		  ///Create convenient typedefs for the digraph types and iterators
+		  ///Create convenience typedefs for the digraph types and iterators
 		  ///\see DIGRAPH_TYPEDEFS
 		  ///
 		  ///\note Use this macro, if the graph type is a dependent type,
@@ -99,11 +99,11 @@
 		  typedef typename Digraph::template NodeMap<int> IntNodeMap;           \
 		  typedef typename Digraph::template NodeMap<double> DoubleNodeMap;     \
 		  typedef typename Digraph::template ArcMap<bool> BoolArcMap;           \
 		  typedef typename Digraph::template ArcMap<int> IntArcMap;             \
-		  typedef typename Digraph::template ArcMap<double> DoubleArcMap;
 		  typedef typename Digraph::template ArcMap<double> DoubleArcMap
-		  ///Create convenient typedefs for the graph types and iterators
+		  ///Create convenience typedefs for the graph types and iterators
 		  ///This \c \#define creates the same convenient type definitions as defined
 		  ///by \ref DIGRAPH_TYPEDEFS(Graph) and six more, namely it creates
 		  ///\c Edge, \c EdgeIt, \c IncEdgeIt, \c BoolEdgeMap, \c IntEdgeMap,
@@ -118,11 +118,11 @@
 		  typedef Graph::EdgeIt EdgeIt;                                         \
 		  typedef Graph::IncEdgeIt IncEdgeIt;                                   \
 		  typedef Graph::EdgeMap<bool> BoolEdgeMap;                             \
 		  typedef Graph::EdgeMap<int> IntEdgeMap;                               \
-		  typedef Graph::EdgeMap<double> DoubleEdgeMap;
 		  typedef Graph::EdgeMap<double> DoubleEdgeMap
-		  ///Create convenient typedefs for the graph types and iterators
+		  ///Create convenience typedefs for the graph types and iterators
 		  ///\see GRAPH_TYPEDEFS
 		  ///
 		  ///\note Use this macro, if the graph type is a dependent type,
@@ -133,9 +133,9 @@
 		  typedef typename Graph::EdgeIt EdgeIt;                                \
 		  typedef typename Graph::IncEdgeIt IncEdgeIt;                          \
 		  typedef typename Graph::template EdgeMap<bool> BoolEdgeMap;           \
 		  typedef typename Graph::template EdgeMap<int> IntEdgeMap;             \
-		  typedef typename Graph::template EdgeMap<double> DoubleEdgeMap;
 		  typedef typename Graph::template EdgeMap<double> DoubleEdgeMap
 		  /// \brief Function to count the items in a graph.
 		  ///
 		  /// This function counts the items (nodes, arcs etc.) in a graph.
@@ -1553,9 +1553,9 @@
 		    ///
 		    ///\note This is a dynamic data structure, therefore the data
 		    ///structure is updated after each graph alteration. Thus although
 		    ///this data structure is theoretically faster than \ref ArcLookUp
-		    ///and \ref AllArcLookup, it often provides worse performance than
+		    ///and \ref AllArcLookUp, it often provides worse performance than
 		    ///them.
 		    Arc operator()(Node s, Node t, Arc p = INVALID) const  {
 		      if (p == INVALID) {
 		        Arc a = _head[s];
@@ -1698,10 +1698,10 @@
+		    }
 		    ///Find an arc between two nodes.
 		    ///Find an arc between two nodes in time <em>O</em>(log<em>d</em>), where
 		    ///<em>d</em> is the number of outgoing arcs of \c s.
 		    ///Find an arc between two nodes in time <em>O</em>(log<em>d</em>),
 		    ///where <em>d</em> is the number of outgoing arcs of \c s.
 		    ///\param s The source node.
 		    ///\param t The target node.
 		    ///\return An arc from \c s to \c t if there exists,
 		    ///\ref INVALID otherwise.
@@ -1816,10 +1816,10 @@
 		    ///int n = 0;
 		    ///for(Arc a = ae(u,v); a != INVALID; a=ae(u,v,a)) n++;
 		    ///\endcode
 		    ///
 		    ///Finding the first arc take <em>O</em>(log<em>d</em>) time, where
 		    ///<em>d</em> is the number of outgoing arcs of \c s. Then, the
 		    ///Finding the first arc take <em>O</em>(log<em>d</em>) time,
 		    ///where <em>d</em> is the number of outgoing arcs of \c s. Then the
 		    ///consecutive arcs are found in constant time.
 		    ///
 		    ///\warning If you change the digraph, refresh() must be called before using
 		    ///this operator. If you change the outgoing arcs of

lemon/dfs.h

Show inline comments

@@ -49,13 +49,13 @@
 		    ///The type of the map that stores the predecessor
 		    ///arcs of the %DFS paths.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
-		    ///Instantiates a \ref PredMap.
 		    ///Instantiates a PredMap.
-		    ///This function instantiates a \ref PredMap.
 		    ///This function instantiates a PredMap.
 		    ///\param g is the digraph, to which we would like to define the
-		    ///\ref PredMap.
 		    ///PredMap.
 		    static PredMap *createPredMap(const Digraph &g)
+		    {
 		      return new PredMap(g);
+		    }
@@ -64,13 +64,13 @@
 		    ///The type of the map that indicates which nodes are processed.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
-		    ///Instantiates a \ref ProcessedMap.
 		    ///Instantiates a ProcessedMap.
-		    ///This function instantiates a \ref ProcessedMap.
 		    ///This function instantiates a ProcessedMap.
 		    ///\param g is the digraph, to which
-		    ///we would like to define the \ref ProcessedMap
 		    ///we would like to define the ProcessedMap
 		#ifdef DOXYGEN
 		    static ProcessedMap *createProcessedMap(const Digraph &g)
 		#else
 		    static ProcessedMap *createProcessedMap(const Digraph &)
@@ -83,13 +83,13 @@
 		    ///The type of the map that indicates which nodes are reached.
 		    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
 		    typedef typename Digraph::template NodeMap<bool> ReachedMap;
-		    ///Instantiates a \ref ReachedMap.
 		    ///Instantiates a ReachedMap.
-		    ///This function instantiates a \ref ReachedMap.
 		    ///This function instantiates a ReachedMap.
 		    ///\param g is the digraph, to which
-		    ///we would like to define the \ref ReachedMap.
 		    ///we would like to define the ReachedMap.
 		    static ReachedMap *createReachedMap(const Digraph &g)
+		    {
 		      return new ReachedMap(g);
+		    }
@@ -98,13 +98,13 @@
 		    ///The type of the map that stores the distances of the nodes.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    typedef typename Digraph::template NodeMap<int> DistMap;
-		    ///Instantiates a \ref DistMap.
 		    ///Instantiates a DistMap.
-		    ///This function instantiates a \ref DistMap.
 		    ///This function instantiates a DistMap.
 		    ///\param g is the digraph, to which we would like to define the
-		    ///\ref DistMap.
 		    ///DistMap.
 		    static DistMap *createDistMap(const Digraph &g)
+		    {
 		      return new DistMap(g);
+		    }
@@ -226,12 +226,12 @@
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
-		    ///\ref PredMap type.
 		    ///PredMap type.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
-		    ///\ref PredMap type.
 		    ///PredMap type.
 		    template <class T>
 		    struct SetPredMap : public Dfs<Digraph, SetPredMapTraits<T> > {
 		      typedef Dfs<Digraph, SetPredMapTraits<T> > Create;
 		    };
@@ -245,12 +245,12 @@
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
-		    ///\ref DistMap type.
 		    ///DistMap type.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
-		    ///\ref DistMap type.
 		    ///DistMap type.
 		    template <class T>
 		    struct SetDistMap : public Dfs< Digraph, SetDistMapTraits<T> > {
 		      typedef Dfs<Digraph, SetDistMapTraits<T> > Create;
 		    };
@@ -264,12 +264,12 @@
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
-		    ///\ref ReachedMap type.
 		    ///ReachedMap type.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
-		    ///\ref ReachedMap type.
 		    ///ReachedMap type.
 		    template <class T>
 		    struct SetReachedMap : public Dfs< Digraph, SetReachedMapTraits<T> > {
 		      typedef Dfs< Digraph, SetReachedMapTraits<T> > Create;
 		    };
@@ -283,12 +283,12 @@
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
-		    ///\ref ProcessedMap type.
 		    ///ProcessedMap type.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
-		    ///\ref ProcessedMap type.
 		    ///ProcessedMap type.
 		    template <class T>
 		    struct SetProcessedMap : public Dfs< Digraph, SetProcessedMapTraits<T> > {
 		      typedef Dfs< Digraph, SetProcessedMapTraits<T> > Create;
 		    };
@@ -300,12 +300,12 @@
 		        return new ProcessedMap(g);
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
-		    ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
 		    ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
-		    ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
 		    ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
 		    ///If you don't set it explicitly, it will be automatically allocated.
 		    struct SetStandardProcessedMap :
 		      public Dfs< Digraph, SetStandardProcessedMapTraits > {
 		      typedef Dfs< Digraph, SetStandardProcessedMapTraits > Create;
@@ -767,13 +767,13 @@
 		    ///The type of the map that stores the predecessor
 		    ///arcs of the %DFS paths.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
-		    ///Instantiates a \ref PredMap.
 		    ///Instantiates a PredMap.
-		    ///This function instantiates a \ref PredMap.
 		    ///This function instantiates a PredMap.
 		    ///\param g is the digraph, to which we would like to define the
-		    ///\ref PredMap.
 		    ///PredMap.
 		    static PredMap *createPredMap(const Digraph &g)
+		    {
 		      return new PredMap(g);
+		    }
@@ -783,13 +783,13 @@
 		    ///The type of the map that indicates which nodes are processed.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    ///By default it is a NullMap.
 		    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
-		    ///Instantiates a \ref ProcessedMap.
 		    ///Instantiates a ProcessedMap.
-		    ///This function instantiates a \ref ProcessedMap.
 		    ///This function instantiates a ProcessedMap.
 		    ///\param g is the digraph, to which
-		    ///we would like to define the \ref ProcessedMap.
 		    ///we would like to define the ProcessedMap.
 		#ifdef DOXYGEN
 		    static ProcessedMap *createProcessedMap(const Digraph &g)
 		#else
 		    static ProcessedMap *createProcessedMap(const Digraph &)
@@ -802,13 +802,13 @@
 		    ///The type of the map that indicates which nodes are reached.
 		    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
 		    typedef typename Digraph::template NodeMap<bool> ReachedMap;
-		    ///Instantiates a \ref ReachedMap.
 		    ///Instantiates a ReachedMap.
-		    ///This function instantiates a \ref ReachedMap.
 		    ///This function instantiates a ReachedMap.
 		    ///\param g is the digraph, to which
-		    ///we would like to define the \ref ReachedMap.
 		    ///we would like to define the ReachedMap.
 		    static ReachedMap *createReachedMap(const Digraph &g)
+		    {
 		      return new ReachedMap(g);
+		    }
@@ -817,13 +817,13 @@
 		    ///The type of the map that stores the distances of the nodes.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    typedef typename Digraph::template NodeMap<int> DistMap;
-		    ///Instantiates a \ref DistMap.
 		    ///Instantiates a DistMap.
-		    ///This function instantiates a \ref DistMap.
 		    ///This function instantiates a DistMap.
 		    ///\param g is the digraph, to which we would like to define
-		    ///the \ref DistMap
 		    ///the DistMap
 		    static DistMap *createDistMap(const Digraph &g)
+		    {
 		      return new DistMap(g);
+		    }
@@ -834,9 +834,9 @@
 		    ///It must meet the \ref concepts::Path "Path" concept.
 		    typedef lemon::Path<Digraph> Path;
 		  };
-		  /// Default traits class used by \ref DfsWizard
 		  /// Default traits class used by DfsWizard
 		  /// To make it easier to use Dfs algorithm
 		  /// we have created a wizard class.
 		  /// This \ref DfsWizard class needs default traits,
@@ -1000,12 +1000,12 @@
 		      static PredMap *createPredMap(const Digraph &) { return 0; };
 		      SetPredMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-func-param "Named parameter"
-		    ///for setting \ref PredMap object.
 		    ///for setting PredMap object.
 		    ///
 		    ///\ref named-func-param "Named parameter"
-		    ///for setting \ref PredMap object.
 		    ///for setting PredMap object.
 		    template<class T>
 		    DfsWizard<SetPredMapBase<T> > predMap(const T &t)
+		    {
 		      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
@@ -1018,12 +1018,12 @@
 		      static ReachedMap *createReachedMap(const Digraph &) { return 0; };
 		      SetReachedMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-func-param "Named parameter"
-		    ///for setting \ref ReachedMap object.
 		    ///for setting ReachedMap object.
 		    ///
 		    /// \ref named-func-param "Named parameter"
-		    ///for setting \ref ReachedMap object.
 		    ///for setting ReachedMap object.
 		    template<class T>
 		    DfsWizard<SetReachedMapBase<T> > reachedMap(const T &t)
+		    {
 		      Base::_reached=reinterpret_cast<void*>(const_cast<T*>(&t));
@@ -1036,12 +1036,12 @@
 		      static DistMap *createDistMap(const Digraph &) { return 0; };
 		      SetDistMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-func-param "Named parameter"
-		    ///for setting \ref DistMap object.
 		    ///for setting DistMap object.
 		    ///
 		    /// \ref named-func-param "Named parameter"
-		    ///for setting \ref DistMap object.
 		    ///for setting DistMap object.
 		    template<class T>
 		    DfsWizard<SetDistMapBase<T> > distMap(const T &t)
+		    {
 		      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
@@ -1054,12 +1054,12 @@
 		      static ProcessedMap *createProcessedMap(const Digraph &) { return 0; };
 		      SetProcessedMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-func-param "Named parameter"
-		    ///for setting \ref ProcessedMap object.
 		    ///for setting ProcessedMap object.
 		    ///
 		    /// \ref named-func-param "Named parameter"
-		    ///for setting \ref ProcessedMap object.
 		    ///for setting ProcessedMap object.
 		    template<class T>
 		    DfsWizard<SetProcessedMapBase<T> > processedMap(const T &t)
+		    {
 		      Base::_processed=reinterpret_cast<void*>(const_cast<T*>(&t));
@@ -1212,13 +1212,13 @@
 		    /// The type of the map that indicates which nodes are reached.
 		    /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
 		    typedef typename Digraph::template NodeMap<bool> ReachedMap;
-		    /// \brief Instantiates a \ref ReachedMap.
 		    /// \brief Instantiates a ReachedMap.
 		    ///
-		    /// This function instantiates a \ref ReachedMap.
 		    /// This function instantiates a ReachedMap.
 		    /// \param digraph is the digraph, to which
-		    /// we would like to define the \ref ReachedMap.
 		    /// we would like to define the ReachedMap.
 		    static ReachedMap *createReachedMap(const Digraph &digraph) {
 		      return new ReachedMap(digraph);
+		    }

lemon/dijkstra.h

Show inline comments

@@ -138,13 +138,13 @@
 		    ///The type of the map that stores the predecessor
 		    ///arcs of the shortest paths.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
-		    ///Instantiates a \ref PredMap.
 		    ///Instantiates a PredMap.
-		    ///This function instantiates a \ref PredMap.
 		    ///This function instantiates a PredMap.
 		    ///\param g is the digraph, to which we would like to define the
-		    ///\ref PredMap.
 		    ///PredMap.
 		    static PredMap *createPredMap(const Digraph &g)
+		    {
 		      return new PredMap(g);
+		    }
@@ -154,13 +154,13 @@
 		    ///The type of the map that indicates which nodes are processed.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    ///By default it is a NullMap.
 		    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
-		    ///Instantiates a \ref ProcessedMap.
 		    ///Instantiates a ProcessedMap.
-		    ///This function instantiates a \ref ProcessedMap.
 		    ///This function instantiates a ProcessedMap.
 		    ///\param g is the digraph, to which
-		    ///we would like to define the \ref ProcessedMap
 		    ///we would like to define the ProcessedMap
 		#ifdef DOXYGEN
 		    static ProcessedMap *createProcessedMap(const Digraph &g)
 		#else
 		    static ProcessedMap *createProcessedMap(const Digraph &)
@@ -173,13 +173,13 @@
 		    ///The type of the map that stores the distances of the nodes.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    typedef typename Digraph::template NodeMap<typename LM::Value> DistMap;
-		    ///Instantiates a \ref DistMap.
 		    ///Instantiates a DistMap.
-		    ///This function instantiates a \ref DistMap.
 		    ///This function instantiates a DistMap.
 		    ///\param g is the digraph, to which we would like to define
-		    ///the \ref DistMap
 		    ///the DistMap
 		    static DistMap *createDistMap(const Digraph &g)
+		    {
 		      return new DistMap(g);
+		    }
@@ -326,12 +326,12 @@
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
-		    ///\ref PredMap type.
 		    ///PredMap type.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
-		    ///\ref PredMap type.
 		    ///PredMap type.
 		    template <class T>
 		    struct SetPredMap
 		      : public Dijkstra< Digraph, LengthMap, SetPredMapTraits<T> > {
 		      typedef Dijkstra< Digraph, LengthMap, SetPredMapTraits<T> > Create;
@@ -346,12 +346,12 @@
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
-		    ///\ref DistMap type.
 		    ///DistMap type.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
-		    ///\ref DistMap type.
 		    ///DistMap type.
 		    template <class T>
 		    struct SetDistMap
 		      : public Dijkstra< Digraph, LengthMap, SetDistMapTraits<T> > {
 		      typedef Dijkstra< Digraph, LengthMap, SetDistMapTraits<T> > Create;
@@ -366,12 +366,12 @@
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
-		    ///\ref ProcessedMap type.
 		    ///ProcessedMap type.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
-		    ///\ref ProcessedMap type.
 		    ///ProcessedMap type.
 		    template <class T>
 		    struct SetProcessedMap
 		      : public Dijkstra< Digraph, LengthMap, SetProcessedMapTraits<T> > {
 		      typedef Dijkstra< Digraph, LengthMap, SetProcessedMapTraits<T> > Create;
@@ -384,12 +384,12 @@
 		        return new ProcessedMap(g);
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
-		    ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
 		    ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
-		    ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
 		    ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
 		    ///If you don't set it explicitly, it will be automatically allocated.
 		    struct SetStandardProcessedMap
 		      : public Dijkstra< Digraph, LengthMap, SetStandardProcessedMapTraits > {
 		      typedef Dijkstra< Digraph, LengthMap, SetStandardProcessedMapTraits >
@@ -452,9 +452,9 @@
 		      typedef T OperationTraits;
 		    };
 		    /// \brief \ref named-templ-param "Named parameter" for setting
-		    ///\ref OperationTraits type
+		    ///\c OperationTraits type
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
 		    ///\ref OperationTraits type.
 		    template <class T>
@@ -985,13 +985,13 @@
 		    ///The type of the map that stores the predecessor
 		    ///arcs of the shortest paths.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
-		    ///Instantiates a \ref PredMap.
 		    ///Instantiates a PredMap.
-		    ///This function instantiates a \ref PredMap.
 		    ///This function instantiates a PredMap.
 		    ///\param g is the digraph, to which we would like to define the
-		    ///\ref PredMap.
 		    ///PredMap.
 		    static PredMap *createPredMap(const Digraph &g)
+		    {
 		      return new PredMap(g);
+		    }
@@ -1001,13 +1001,13 @@
 		    ///The type of the map that indicates which nodes are processed.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    ///By default it is a NullMap.
 		    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
-		    ///Instantiates a \ref ProcessedMap.
 		    ///Instantiates a ProcessedMap.
-		    ///This function instantiates a \ref ProcessedMap.
 		    ///This function instantiates a ProcessedMap.
 		    ///\param g is the digraph, to which
-		    ///we would like to define the \ref ProcessedMap.
 		    ///we would like to define the ProcessedMap.
 		#ifdef DOXYGEN
 		    static ProcessedMap *createProcessedMap(const Digraph &g)
 		#else
 		    static ProcessedMap *createProcessedMap(const Digraph &)
@@ -1020,13 +1020,13 @@
 		    ///The type of the map that stores the distances of the nodes.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    typedef typename Digraph::template NodeMap<typename LM::Value> DistMap;
-		    ///Instantiates a \ref DistMap.
 		    ///Instantiates a DistMap.
-		    ///This function instantiates a \ref DistMap.
 		    ///This function instantiates a DistMap.
 		    ///\param g is the digraph, to which we would like to define
-		    ///the \ref DistMap
 		    ///the DistMap
 		    static DistMap *createDistMap(const Digraph &g)
+		    {
 		      return new DistMap(g);
+		    }
@@ -1037,9 +1037,9 @@
 		    ///It must meet the \ref concepts::Path "Path" concept.
 		    typedef lemon::Path<Digraph> Path;
 		  };
-		  /// Default traits class used by \ref DijkstraWizard
 		  /// Default traits class used by DijkstraWizard
 		  /// To make it easier to use Dijkstra algorithm
 		  /// we have created a wizard class.
 		  /// This \ref DijkstraWizard class needs default traits,
@@ -1197,12 +1197,12 @@
 		      static PredMap *createPredMap(const Digraph &) { return 0; };
 		      SetPredMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-func-param "Named parameter"
-		    ///for setting \ref PredMap object.
 		    ///for setting PredMap object.
 		    ///
 		    ///\ref named-func-param "Named parameter"
-		    ///for setting \ref PredMap object.
 		    ///for setting PredMap object.
 		    template<class T>
 		    DijkstraWizard<SetPredMapBase<T> > predMap(const T &t)
+		    {
 		      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
@@ -1215,12 +1215,12 @@
 		      static DistMap *createDistMap(const Digraph &) { return 0; };
 		      SetDistMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-func-param "Named parameter"
-		    ///for setting \ref DistMap object.
 		    ///for setting DistMap object.
 		    ///
 		    ///\ref named-func-param "Named parameter"
-		    ///for setting \ref DistMap object.
 		    ///for setting DistMap object.
 		    template<class T>
 		    DijkstraWizard<SetDistMapBase<T> > distMap(const T &t)
+		    {
 		      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
@@ -1233,12 +1233,12 @@
 		      static ProcessedMap *createProcessedMap(const Digraph &) { return 0; };
 		      SetProcessedMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-func-param "Named parameter"
-		    ///for setting \ref ProcessedMap object.
 		    ///for setting ProcessedMap object.
 		    ///
 		    /// \ref named-func-param "Named parameter"
-		    ///for setting \ref ProcessedMap object.
 		    ///for setting ProcessedMap object.
 		    template<class T>
 		    DijkstraWizard<SetProcessedMapBase<T> > processedMap(const T &t)
+		    {
 		      Base::_processed=reinterpret_cast<void*>(const_cast<T*>(&t));

lemon/dim2.h

Show inline comments

@@ -258,12 +258,12 @@
+		  }
-		  /// Bounding box of plain vectors (\ref Point points).
 		  /// Bounding box of plain vectors (points).
 		  /// A class to calculate or store the bounding box of plain vectors
 		  /// (\ref Point points).
+		  /// (\ref Point "points").
 		  template<typename T>
 		  class Box {
 		      Point<T> _bottom_left, _top_right;
 		      bool _empty;
@@ -572,11 +572,10 @@
 		    os << "(" << b.bottomLeft() << "," << b.topRight() << ")";
 		    return os;
+		  }
-		  ///Map of x-coordinates of a \ref Point "Point"-map
+		  ///Map of x-coordinates of a <tt>Point</tt>-map
 		  ///\ingroup maps
 		  ///Map of x-coordinates of a \ref Point "Point"-map.
 		  ///
 		  template<class M>
 		  class XMap
@@ -591,13 +590,11 @@
 		    Value operator[](Key k) const {return _map[k].x;}
 		    void set(Key k,Value v) {_map.set(k,typename M::Value(v,_map[k].y));}
 		  };
-		  ///Returns an \ref XMap class
 		  ///Returns an XMap class
 		  ///This function just returns an \ref XMap class.
 		  ///
-		  ///\ingroup maps
+		  ///This function just returns an XMap class.
 		  ///\relates XMap
 		  template<class M>
 		  inline XMap<M> xMap(M &m)
+		  {
@@ -609,12 +606,11 @@
+		  {
 		    return XMap<M>(m);
+		  }
-		  ///Constant (read only) version of \ref XMap
 		  ///Constant (read only) version of XMap
 		  ///\ingroup maps
 		  ///Constant (read only) version of \ref XMap
 		  ///Constant (read only) version of XMap.
 		  ///
 		  template<class M>
 		  class ConstXMap
+		  {
@@ -627,23 +623,20 @@
 		    ConstXMap(const M &map) : _map(map) {}
 		    Value operator[](Key k) const {return _map[k].x;}
 		  };
-		  ///Returns a \ref ConstXMap class
 		  ///Returns a ConstXMap class
 		  ///This function just returns a \ref ConstXMap class.
 		  ///
-		  ///\ingroup maps
+		  ///This function just returns a ConstXMap class.
 		  ///\relates ConstXMap
 		  template<class M>
 		  inline ConstXMap<M> xMap(const M &m)
+		  {
 		    return ConstXMap<M>(m);
+		  }
-		  ///Map of y-coordinates of a \ref Point "Point"-map
+		  ///Map of y-coordinates of a <tt>Point</tt>-map
 		  ///\ingroup maps
 		  ///Map of y-coordinates of a \ref Point "Point"-map.
 		  ///
 		  template<class M>
 		  class YMap
@@ -658,13 +651,11 @@
 		    Value operator[](Key k) const {return _map[k].y;}
 		    void set(Key k,Value v) {_map.set(k,typename M::Value(_map[k].x,v));}
 		  };
-		  ///Returns a \ref YMap class
 		  ///Returns a YMap class
 		  ///This function just returns a \ref YMap class.
 		  ///
-		  ///\ingroup maps
+		  ///This function just returns a YMap class.
 		  ///\relates YMap
 		  template<class M>
 		  inline YMap<M> yMap(M &m)
+		  {
@@ -676,12 +667,11 @@
+		  {
 		    return YMap<M>(m);
+		  }
-		  ///Constant (read only) version of \ref YMap
 		  ///Constant (read only) version of YMap
 		  ///\ingroup maps
 		  ///Constant (read only) version of \ref YMap
 		  ///Constant (read only) version of YMap.
 		  ///
 		  template<class M>
 		  class ConstYMap
+		  {
@@ -694,27 +684,23 @@
 		    ConstYMap(const M &map) : _map(map) {}
 		    Value operator[](Key k) const {return _map[k].y;}
 		  };
-		  ///Returns a \ref ConstYMap class
 		  ///Returns a ConstYMap class
 		  ///This function just returns a \ref ConstYMap class.
 		  ///
-		  ///\ingroup maps
+		  ///This function just returns a ConstYMap class.
 		  ///\relates ConstYMap
 		  template<class M>
 		  inline ConstYMap<M> yMap(const M &m)
+		  {
 		    return ConstYMap<M>(m);
+		  }
 		  ///\brief Map of the \ref Point::normSquare() "normSquare()"
 		  ///of a \ref Point "Point"-map
 		  ///\brief Map of the normSquare() of a <tt>Point</tt>-map
 		  ///
 		  ///Map of the \ref Point::normSquare() "normSquare()"
 		  ///of a \ref Point "Point"-map.
 		  ///\ingroup maps
 		  template<class M>
 		  class NormSquareMap
+		  {
 		    const M& _map;
@@ -726,13 +712,11 @@
 		    NormSquareMap(const M &map) : _map(map) {}
 		    Value operator[](Key k) const {return _map[k].normSquare();}
 		  };
-		  ///Returns a \ref NormSquareMap class
 		  ///Returns a NormSquareMap class
 		  ///This function just returns a \ref NormSquareMap class.
 		  ///
-		  ///\ingroup maps
+		  ///This function just returns a NormSquareMap class.
 		  ///\relates NormSquareMap
 		  template<class M>
 		  inline NormSquareMap<M> normSquareMap(const M &m)
+		  {

lemon/graph_to_eps.h

Show inline comments

@@ -61,9 +61,9 @@
 		      Value operator[](Key n) { return Value(map[n].x,map[n].y*yscale);}
 		    };
+		  }
-		///Default traits class of \ref GraphToEps
 		///Default traits class of GraphToEps
 		///Default traits class of \ref GraphToEps.
 		///
 		///\c G is the type of the underlying graph.

lemon/lgf_reader.h

Show inline comments

@@ -390,17 +390,39 @@
 		  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);
 		                                       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
 		  template <typename Digraph>
 		  DigraphReader<Digraph> digraphReader(Digraph& digraph, const std::string& fn);
 		  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> digraphReader(Digraph& digraph, const char* fn) {
 		    DigraphReader<Digraph> tmp(digraph, fn);
 		    return tmp;
+		  }
 		  /// \ingroup lemon_io
 		  ///
 		  /// \brief \ref lgf-format "LGF" reader for directed graphs
@@ -1188,53 +1210,41 @@
 		    /// @}
 		  };
-		  /// \brief Return a \ref DigraphReader class
+		  template <typename Graph>
 		  class GraphReader;
 		  /// \brief Return a \ref GraphReader 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);
 		  /// 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 DigraphReader class
+		  /// \brief Return a \ref GraphReader 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);
 		  /// 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 DigraphReader class
+		  /// \brief Return a \ref GraphReader 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);
+		  /// 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;
+		  }
 		  template <typename Graph>
 		  class GraphReader;
 		  template <typename Graph>
 		  GraphReader<Graph> graphReader(Graph& graph,
 		                                 std::istream& is = std::cin);
 		  template <typename Graph>
 		  GraphReader<Graph> graphReader(Graph& graph, const std::string& fn);
 		  template <typename Graph>
 		  GraphReader<Graph> graphReader(Graph& graph, const char *fn);
 		  /// \ingroup lemon_io
 		  ///
 		  /// \brief \ref lgf-format "LGF" reader for undirected graphs
 		  ///
@@ -2030,38 +2040,8 @@
 		    /// @}
 		  };
 		  /// \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
 		  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);

lemon/lgf_writer.h

Show inline comments

@@ -350,19 +350,40 @@
 		  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);
+		                                       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
 		  template <typename Digraph>
 		  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
-		                                       const std::string& fn);
+		                                       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);
+		                                       const char* fn) {
 		    DigraphWriter<Digraph> tmp(digraph, fn);
 		    return tmp;
+		  }
 		  /// \ingroup lemon_io
 		  ///
 		  /// \brief \ref lgf-format "LGF" writer for directed graphs
@@ -912,54 +933,42 @@
 		    /// @}
 		  };
-		  /// \brief Return a \ref DigraphWriter class
+		  template <typename Graph>
 		  class GraphWriter;
 		  /// \brief Return a \ref GraphWriter 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);
 		  /// 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 DigraphWriter class
+		  /// \brief Return a \ref GraphWriter 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);
 		  /// 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 DigraphWriter class
+		  /// \brief Return a \ref GraphWriter 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);
 		  /// 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;
+		  }
 		  template <typename Graph>
 		  class GraphWriter;
 		  template <typename Graph>
 		  GraphWriter<Graph> graphWriter(const Graph& graph,
 		                                 std::ostream& os = std::cout);
 		  template <typename Graph>
 		  GraphWriter<Graph> graphWriter(const Graph& graph, const std::string& fn);
 		  template <typename Graph>
 		  GraphWriter<Graph> graphWriter(const Graph& graph, const char *fn);
 		  /// \ingroup lemon_io
 		  ///
 		  /// \brief \ref lgf-format "LGF" writer for directed graphs
 		  ///
@@ -1525,39 +1534,8 @@
 		    /// @}
 		  };
 		  /// \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
 		  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);

lemon/list_graph.h

Show inline comments

@@ -412,9 +412,9 @@
 		    /// Change the source of \c a to \c n
 		    ///
 		    ///\note The <tt>InArcIt</tt>s referencing the changed arc remain
 		    ///valid. However the <tt>ArcIt<tt>s and <tt>OutArcIt</tt>s are
+		    ///valid. However the <tt>ArcIt</tt>s and <tt>OutArcIt</tt>s are
 		    ///invalidated.
 		    ///
 		    ///\warning This functionality cannot be used together with the Snapshot
 		    ///feature.

lemon/maps.h

Show inline comments

@@ -42,9 +42,9 @@
 		  /// required by the map %concepts.
 		  template<typename K, typename V>
 		  class MapBase {
 		  public:
-		    /// \biref The key type of the map.
+		    /// \brief The key type of the map.
 		    typedef K Key;
 		    /// \brief The value type of the map.
 		    /// (The type of objects associated with the keys).
 		    typedef V Value;
@@ -72,11 +72,11 @@
 		    /// Absorbs the value.
 		    void set(const Key&, const Value&) {}
 		  };
-		  /// Returns a \ref NullMap class
+		  /// Returns a \c NullMap class
-		  /// This function just returns a \ref NullMap class.
+		  /// This function just returns a \c NullMap class.
 		  /// \relates NullMap
 		  template <typename K, typename V>
 		  NullMap<K, V> nullMap() {
 		    return NullMap<K, V>();
@@ -87,9 +87,9 @@
 		  /// This \ref concepts::ReadMap "readable map" assigns a specified
 		  /// value to each key.
 		  ///
-		  /// In other aspects it is equivalent to \ref NullMap.
+		  /// In other aspects it is equivalent to \c NullMap.
 		  /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap"
 		  /// concept, but it absorbs the data written to it.
 		  ///
 		  /// The simplest way of using this map is through the constMap()
@@ -132,11 +132,11 @@
 		    template<typename V1>
 		    ConstMap(const ConstMap<K, V1> &, const Value &v) : _value(v) {}
 		  };
-		  /// Returns a \ref ConstMap class
+		  /// Returns a \c ConstMap class
-		  /// This function just returns a \ref ConstMap class.
+		  /// This function just returns a \c ConstMap class.
 		  /// \relates ConstMap
 		  template<typename K, typename V>
 		  inline ConstMap<K, V> constMap(const V &v) {
 		    return ConstMap<K, V>(v);
@@ -155,9 +155,9 @@
 		  /// This \ref concepts::ReadMap "readable map" assigns a specified
 		  /// value to each key.
 		  ///
-		  /// In other aspects it is equivalent to \ref NullMap.
+		  /// In other aspects it is equivalent to \c NullMap.
 		  /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap"
 		  /// concept, but it absorbs the data written to it.
 		  ///
 		  /// The simplest way of using this map is through the constMap()
@@ -181,11 +181,11 @@
 		    /// Absorbs the value.
 		    void set(const Key&, const Value&) {}
 		  };
-		  /// Returns a \ref ConstMap class with inlined constant value
+		  /// Returns a \c ConstMap class with inlined constant value
-		  /// This function just returns a \ref ConstMap class with inlined
+		  /// This function just returns a \c ConstMap class with inlined
 		  /// constant value.
 		  /// \relates ConstMap
 		  template<typename K, typename V, V v>
 		  inline ConstMap<K, Const<V, v> > constMap() {
@@ -211,11 +211,11 @@
 		      return k;
+		    }
 		  };
-		  /// Returns an \ref IdentityMap class
+		  /// Returns an \c IdentityMap class
-		  /// This function just returns an \ref IdentityMap class.
+		  /// This function just returns an \c IdentityMap class.
 		  /// \relates IdentityMap
 		  template<typename T>
 		  inline IdentityMap<T> identityMap() {
 		    return IdentityMap<T>();
@@ -227,9 +227,9 @@
 		  ///
 		  /// This map is essentially a wrapper for \c std::vector. It assigns
 		  /// values to integer keys from the range <tt>[0..size-1]</tt>.
 		  /// It can be used with some data structures, for example
-		  /// \ref UnionFind, \ref BinHeap, when the used items are small
+		  /// \c UnionFind, \c BinHeap, when the used items are small
 		  /// integers. This map conforms the \ref concepts::ReferenceMap
 		  /// "ReferenceMap" concept.
 		  ///
 		  /// The simplest way of using this map is through the rangeMap()
@@ -267,9 +267,9 @@
 		    template <typename V1>
 		    RangeMap(const std::vector<V1>& vector)
 		      : _vector(vector.begin(), vector.end()) {}
-		    /// Constructs the map from another \ref RangeMap.
+		    /// Constructs the map from another \c RangeMap.
 		    template <typename V1>
 		    RangeMap(const RangeMap<V1> &c)
 		      : _vector(c._vector.begin(), c._vector.end()) {}
@@ -310,21 +310,21 @@
 		      _vector[k] = v;
+		    }
 		  };
-		  /// Returns a \ref RangeMap class
+		  /// Returns a \c RangeMap class
-		  /// This function just returns a \ref RangeMap class.
+		  /// This function just returns a \c RangeMap class.
 		  /// \relates RangeMap
 		  template<typename V>
 		  inline RangeMap<V> rangeMap(int size = 0, const V &value = V()) {
 		    return RangeMap<V>(size, value);
+		  }
-		  /// \brief Returns a \ref RangeMap class created from an appropriate
+		  /// \brief Returns a \c RangeMap class created from an appropriate
 		  /// \c std::vector
-		  /// This function just returns a \ref RangeMap class created from an
+		  /// This function just returns a \c RangeMap class created from an
 		  /// appropriate \c std::vector.
 		  /// \relates RangeMap
 		  template<typename V>
 		  inline RangeMap<V> rangeMap(const std::vector<V> &vector) {
@@ -387,9 +387,9 @@
 		    SparseMap(const std::map<Key, V1, Comp1> &map,
 		              const Value &value = Value())
 		      : _map(map.begin(), map.end()), _value(value) {}
-		    /// \brief Constructs the map from another \ref SparseMap.
+		    /// \brief Constructs the map from another \c SparseMap.
 		    template<typename V1, typename Comp1>
 		    SparseMap(const SparseMap<Key, V1, Comp1> &c)
 		      : _map(c._map.begin(), c._map.end()), _value(c._value) {}
@@ -432,11 +432,11 @@
 		      _map.clear();
+		    }
 		  };
-		  /// Returns a \ref SparseMap class
+		  /// Returns a \c SparseMap class
-		  /// This function just returns a \ref SparseMap class with specified
+		  /// This function just returns a \c SparseMap class with specified
 		  /// default value.
 		  /// \relates SparseMap
 		  template<typename K, typename V, typename Compare>
 		  inline SparseMap<K, V, Compare> sparseMap(const V& value = V()) {
@@ -447,12 +447,12 @@
 		  inline SparseMap<K, V, std::less<K> > sparseMap(const V& value = V()) {
 		    return SparseMap<K, V, std::less<K> >(value);
+		  }
-		  /// \brief Returns a \ref SparseMap class created from an appropriate
+		  /// \brief Returns a \c SparseMap class created from an appropriate
 		  /// \c std::map
-		  /// This function just returns a \ref SparseMap class created from an
+		  /// This function just returns a \c SparseMap class created from an
 		  /// appropriate \c std::map.
 		  /// \relates SparseMap
 		  template<typename K, typename V, typename Compare>
 		  inline SparseMap<K, V, Compare>
@@ -500,11 +500,11 @@
 		    typename MapTraits<M1>::ConstReturnValue
 		    operator[](const Key &k) const { return _m1[_m2[k]]; }
 		  };
-		  /// Returns a \ref ComposeMap class
+		  /// Returns a \c ComposeMap class
-		  /// This function just returns a \ref ComposeMap class.
+		  /// This function just returns a \c ComposeMap class.
 		  ///
 		  /// If \c m1 and \c m2 are maps and the \c Value type of \c m2 is
 		  /// convertible to the \c Key of \c m1, then <tt>composeMap(m1,m2)[x]</tt>
 		  /// will be equal to <tt>m1[m2[x]]</tt>.
@@ -555,11 +555,11 @@
 		    /// \e
 		    Value operator[](const Key &k) const { return _f(_m1[k],_m2[k]); }
 		  };
-		  /// Returns a \ref CombineMap class
+		  /// Returns a \c CombineMap class
-		  /// This function just returns a \ref CombineMap class.
+		  /// This function just returns a \c CombineMap class.
 		  ///
 		  /// For example, if \c m1 and \c m2 are both maps with \c double
 		  /// values, then
 		  /// \code
@@ -624,11 +624,11 @@
 		    /// \e
 		    Value operator[](const Key &k) const { return _f(k); }
 		  };
-		  /// Returns a \ref FunctorToMap class
+		  /// Returns a \c FunctorToMap class
-		  /// This function just returns a \ref FunctorToMap class.
+		  /// This function just returns a \c FunctorToMap class.
 		  ///
 		  /// This function is specialized for adaptable binary function
 		  /// classes and C++ functions.
 		  ///
@@ -683,11 +683,11 @@
 		    /// \e
 		    Value operator[](const Key &k) const { return _m[k]; }
 		  };
-		  /// Returns a \ref MapToFunctor class
+		  /// Returns a \c MapToFunctor class
-		  /// This function just returns a \ref MapToFunctor class.
+		  /// This function just returns a \c MapToFunctor class.
 		  /// \relates MapToFunctor
 		  template<typename M>
 		  inline MapToFunctor<M> mapToFunctor(const M &m) {
 		    return MapToFunctor<M>(m);
@@ -722,11 +722,11 @@
 		    /// \e
 		    Value operator[](const Key &k) const { return _m[k]; }
 		  };
-		  /// Returns a \ref ConvertMap class
+		  /// Returns a \c ConvertMap class
-		  /// This function just returns a \ref ConvertMap class.
+		  /// This function just returns a \c ConvertMap class.
 		  /// \relates ConvertMap
 		  template<typename V, typename M>
 		  inline ConvertMap<M, V> convertMap(const M &map) {
 		    return ConvertMap<M, V>(map);
@@ -762,11 +762,11 @@
 		    /// Sets the value associated with the given key in both maps.
 		    void set(const Key &k, const Value &v) { _m1.set(k,v); _m2.set(k,v); }
 		  };
-		  /// Returns a \ref ForkMap class
+		  /// Returns a \c ForkMap class
-		  /// This function just returns a \ref ForkMap class.
+		  /// This function just returns a \c ForkMap class.
 		  /// \relates ForkMap
 		  template <typename M1, typename M2>
 		  inline ForkMap<M1,M2> forkMap(M1 &m1, M2 &m2) {
 		    return ForkMap<M1,M2>(m1,m2);
@@ -806,11 +806,11 @@
 		    /// \e
 		    Value operator[](const Key &k) const { return _m1[k]+_m2[k]; }
 		  };
-		  /// Returns an \ref AddMap class
+		  /// Returns an \c AddMap class
-		  /// This function just returns an \ref AddMap class.
+		  /// This function just returns an \c AddMap class.
 		  ///
 		  /// For example, if \c m1 and \c m2 are both maps with \c double
 		  /// values, then <tt>addMap(m1,m2)[x]</tt> will be equal to
 		  /// <tt>m1[x]+m2[x]</tt>.
@@ -854,11 +854,11 @@
 		    /// \e
 		    Value operator[](const Key &k) const { return _m1[k]-_m2[k]; }
 		  };
-		  /// Returns a \ref SubMap class
+		  /// Returns a \c SubMap class
-		  /// This function just returns a \ref SubMap class.
+		  /// This function just returns a \c SubMap class.
 		  ///
 		  /// For example, if \c m1 and \c m2 are both maps with \c double
 		  /// values, then <tt>subMap(m1,m2)[x]</tt> will be equal to
 		  /// <tt>m1[x]-m2[x]</tt>.
@@ -903,11 +903,11 @@
 		    /// \e
 		    Value operator[](const Key &k) const { return _m1[k]*_m2[k]; }
 		  };
-		  /// Returns a \ref MulMap class
+		  /// Returns a \c MulMap class
-		  /// This function just returns a \ref MulMap class.
+		  /// This function just returns a \c MulMap class.
 		  ///
 		  /// For example, if \c m1 and \c m2 are both maps with \c double
 		  /// values, then <tt>mulMap(m1,m2)[x]</tt> will be equal to
 		  /// <tt>m1[x]*m2[x]</tt>.
@@ -951,11 +951,11 @@
 		    /// \e
 		    Value operator[](const Key &k) const { return _m1[k]/_m2[k]; }
 		  };
-		  /// Returns a \ref DivMap class
+		  /// Returns a \c DivMap class
-		  /// This function just returns a \ref DivMap class.
+		  /// This function just returns a \c DivMap class.
 		  ///
 		  /// For example, if \c m1 and \c m2 are both maps with \c double
 		  /// values, then <tt>divMap(m1,m2)[x]</tt> will be equal to
 		  /// <tt>m1[x]/m2[x]</tt>.
@@ -1037,11 +1037,11 @@
 		    /// \e
 		    void set(const Key &k, const Value &v) { _m.set(k, v-_v); }
 		  };
-		  /// Returns a \ref ShiftMap class
+		  /// Returns a \c ShiftMap class
-		  /// This function just returns a \ref ShiftMap class.
+		  /// This function just returns a \c ShiftMap class.
 		  ///
 		  /// For example, if \c m is a map with \c double values and \c v is
 		  /// \c double, then <tt>shiftMap(m,v)[x]</tt> will be equal to
 		  /// <tt>m[x]+v</tt>.
@@ -1051,11 +1051,11 @@
 		  inline ShiftMap<M, C> shiftMap(const M &m, const C &v) {
 		    return ShiftMap<M, C>(m,v);
+		  }
-		  /// Returns a \ref ShiftWriteMap class
+		  /// Returns a \c ShiftWriteMap class
-		  /// This function just returns a \ref ShiftWriteMap class.
+		  /// This function just returns a \c ShiftWriteMap class.
 		  ///
 		  /// For example, if \c m is a map with \c double values and \c v is
 		  /// \c double, then <tt>shiftWriteMap(m,v)[x]</tt> will be equal to
 		  /// <tt>m[x]+v</tt>.
@@ -1139,11 +1139,11 @@
 		    /// \e
 		    void set(const Key &k, const Value &v) { _m.set(k, v/_v); }
 		  };
-		  /// Returns a \ref ScaleMap class
+		  /// Returns a \c ScaleMap class
-		  /// This function just returns a \ref ScaleMap class.
+		  /// This function just returns a \c ScaleMap class.
 		  ///
 		  /// For example, if \c m is a map with \c double values and \c v is
 		  /// \c double, then <tt>scaleMap(m,v)[x]</tt> will be equal to
 		  /// <tt>v*m[x]</tt>.
@@ -1153,11 +1153,11 @@
 		  inline ScaleMap<M, C> scaleMap(const M &m, const C &v) {
 		    return ScaleMap<M, C>(m,v);
+		  }
-		  /// Returns a \ref ScaleWriteMap class
+		  /// Returns a \c ScaleWriteMap class
-		  /// This function just returns a \ref ScaleWriteMap class.
+		  /// This function just returns a \c ScaleWriteMap class.
 		  ///
 		  /// For example, if \c m is a map with \c double values and \c v is
 		  /// \c double, then <tt>scaleWriteMap(m,v)[x]</tt> will be equal to
 		  /// <tt>v*m[x]</tt>.
@@ -1239,11 +1239,11 @@
 		    /// \e
 		    void set(const Key &k, const Value &v) { _m.set(k, -v); }
 		  };
-		  /// Returns a \ref NegMap class
+		  /// Returns a \c NegMap class
-		  /// This function just returns a \ref NegMap class.
+		  /// This function just returns a \c NegMap class.
 		  ///
 		  /// For example, if \c m is a map with \c double values, then
 		  /// <tt>negMap(m)[x]</tt> will be equal to <tt>-m[x]</tt>.
 		  ///
@@ -1252,11 +1252,11 @@
 		  inline NegMap<M> negMap(const M &m) {
 		    return NegMap<M>(m);
+		  }
-		  /// Returns a \ref NegWriteMap class
+		  /// Returns a \c NegWriteMap class
-		  /// This function just returns a \ref NegWriteMap class.
+		  /// This function just returns a \c NegWriteMap class.
 		  ///
 		  /// For example, if \c m is a map with \c double values, then
 		  /// <tt>negWriteMap(m)[x]</tt> will be equal to <tt>-m[x]</tt>.
 		  /// Moreover it makes also possible to write the map.
@@ -1295,11 +1295,11 @@
+		    }
 		  };
-		  /// Returns an \ref AbsMap class
+		  /// Returns an \c AbsMap class
-		  /// This function just returns an \ref AbsMap class.
+		  /// This function just returns an \c AbsMap class.
 		  ///
 		  /// For example, if \c m is a map with \c double values, then
 		  /// <tt>absMap(m)[x]</tt> will be equal to <tt>m[x]</tt> if
 		  /// it is positive or zero and <tt>-m[x]</tt> if <tt>m[x]</tt> is
@@ -1344,11 +1344,11 @@
 		    /// Gives back \c true.
 		    Value operator[](const Key&) const { return true; }
 		  };
-		  /// Returns a \ref TrueMap class
+		  /// Returns a \c TrueMap class
-		  /// This function just returns a \ref TrueMap class.
+		  /// This function just returns a \c TrueMap class.
 		  /// \relates TrueMap
 		  template<typename K>
 		  inline TrueMap<K> trueMap() {
 		    return TrueMap<K>();
@@ -1381,11 +1381,11 @@
 		    /// Gives back \c false.
 		    Value operator[](const Key&) const { return false; }
 		  };
-		  /// Returns a \ref FalseMap class
+		  /// Returns a \c FalseMap class
-		  /// This function just returns a \ref FalseMap class.
+		  /// This function just returns a \c FalseMap class.
 		  /// \relates FalseMap
 		  template<typename K>
 		  inline FalseMap<K> falseMap() {
 		    return FalseMap<K>();
@@ -1428,11 +1428,11 @@
 		    /// \e
 		    Value operator[](const Key &k) const { return _m1[k]&&_m2[k]; }
 		  };
-		  /// Returns an \ref AndMap class
+		  /// Returns an \c AndMap class
-		  /// This function just returns an \ref AndMap class.
+		  /// This function just returns an \c AndMap class.
 		  ///
 		  /// For example, if \c m1 and \c m2 are both maps with \c bool values,
 		  /// then <tt>andMap(m1,m2)[x]</tt> will be equal to
 		  /// <tt>m1[x]&&m2[x]</tt>.
@@ -1476,11 +1476,11 @@
 		    /// \e
 		    Value operator[](const Key &k) const { return _m1[k]||_m2[k]; }
 		  };
-		  /// Returns an \ref OrMap class
+		  /// Returns an \c OrMap class
-		  /// This function just returns an \ref OrMap class.
+		  /// This function just returns an \c OrMap class.
 		  ///
 		  /// For example, if \c m1 and \c m2 are both maps with \c bool values,
 		  /// then <tt>orMap(m1,m2)[x]</tt> will be equal to
 		  /// <tt>m1[x]||m2[x]</tt>.
@@ -1543,11 +1543,11 @@
 		    /// \e
 		    void set(const Key &k, bool v) { _m.set(k, !v); }
 		  };
-		  /// Returns a \ref NotMap class
+		  /// Returns a \c NotMap class
-		  /// This function just returns a \ref NotMap class.
+		  /// This function just returns a \c NotMap class.
 		  ///
 		  /// For example, if \c m is a map with \c bool values, then
 		  /// <tt>notMap(m)[x]</tt> will be equal to <tt>!m[x]</tt>.
 		  ///
@@ -1556,11 +1556,11 @@
 		  inline NotMap<M> notMap(const M &m) {
 		    return NotMap<M>(m);
+		  }
-		  /// Returns a \ref NotWriteMap class
+		  /// Returns a \c NotWriteMap class
-		  /// This function just returns a \ref NotWriteMap class.
+		  /// This function just returns a \c NotWriteMap class.
 		  ///
 		  /// For example, if \c m is a map with \c bool values, then
 		  /// <tt>notWriteMap(m)[x]</tt> will be equal to <tt>!m[x]</tt>.
 		  /// Moreover it makes also possible to write the map.
@@ -1604,11 +1604,11 @@
 		    /// \e
 		    Value operator[](const Key &k) const { return _m1[k]==_m2[k]; }
 		  };
-		  /// Returns an \ref EqualMap class
+		  /// Returns an \c EqualMap class
-		  /// This function just returns an \ref EqualMap class.
+		  /// This function just returns an \c EqualMap class.
 		  ///
 		  /// For example, if \c m1 and \c m2 are maps with keys and values of
 		  /// the same type, then <tt>equalMap(m1,m2)[x]</tt> will be equal to
 		  /// <tt>m1[x]==m2[x]</tt>.
@@ -1652,11 +1652,11 @@
 		    /// \e
 		    Value operator[](const Key &k) const { return _m1[k]<_m2[k]; }
 		  };
-		  /// Returns an \ref LessMap class
+		  /// Returns an \c LessMap class
-		  /// This function just returns an \ref LessMap class.
+		  /// This function just returns an \c LessMap class.
 		  ///
 		  /// For example, if \c m1 and \c m2 are maps with keys and values of
 		  /// the same type, then <tt>lessMap(m1,m2)[x]</tt> will be equal to
 		  /// <tt>m1[x]<m2[x]</tt>.
@@ -1682,8 +1682,13 @@
 		    };
+		  }
 		  /// @}
 		  /// \addtogroup maps
 		  /// @{
 		  /// \brief Writable bool map for logging each \c true assigned element
 		  ///
 		  /// A \ref concepts::WriteMap "writable" bool map for logging
 		  /// each \c true assigned element, i.e it copies subsequently each
@@ -1744,11 +1749,11 @@
 		    Iterator _begin;
 		    Iterator _end;
 		  };
-		  /// Returns a \ref LoggerBoolMap class
+		  /// Returns a \c LoggerBoolMap class
-		  /// This function just returns a \ref LoggerBoolMap class.
+		  /// This function just returns a \c LoggerBoolMap class.
 		  ///
 		  /// The most important usage of it is storing certain nodes or arcs
 		  /// that were marked \c true by an algorithm.
 		  /// For example it makes easier to store the nodes in the processing
@@ -1766,16 +1771,21 @@
 		  /// for the elements or the iterator should be an inserter iterator.
 		  ///
 		  /// \note LoggerBoolMap is just \ref concepts::WriteMap "writable", so
 		  /// it cannot be used when a readable map is needed, for example as
-		  /// \c ReachedMap for \ref Bfs, \ref Dfs and \ref Dijkstra algorithms.
+		  /// \c ReachedMap for \c Bfs, \c Dfs and \c Dijkstra algorithms.
 		  ///
 		  /// \relates LoggerBoolMap
 		  template<typename Iterator>
 		  inline LoggerBoolMap<Iterator> loggerBoolMap(Iterator it) {
 		    return LoggerBoolMap<Iterator>(it);
+		  }
 		  /// @}
 		  /// \addtogroup graph_maps
 		  /// @{
 		  /// Provides an immutable and unique id for each item in the graph.
 		  /// The IdMap class provides a unique and immutable id for each item of the
 		  /// same type (e.g. node) in the graph. This id is <ul><li>\b unique:
@@ -1860,9 +1870,9 @@
 		    /// \brief Constructor
 		    ///
 		    /// Constructor
-		    /// \param _digraph The digraph that the map belongs to.
+		    /// \param digraph The digraph that the map belongs to.
 		    explicit SourceMap(const Digraph& digraph) : _digraph(digraph) {}
 		    /// \brief The subscript operator.
 		    ///
@@ -1876,11 +1886,11 @@
 		  private:
 		    const Digraph& _digraph;
 		  };
-		  /// \brief Returns a \ref SourceMap class.
+		  /// \brief Returns a \c SourceMap class.
 		  ///
-		  /// This function just returns an \ref SourceMap class.
+		  /// This function just returns an \c SourceMap class.
 		  /// \relates SourceMap
 		  template <typename Digraph>
 		  inline SourceMap<Digraph> sourceMap(const Digraph& digraph) {
 		    return SourceMap<Digraph>(digraph);
@@ -1899,9 +1909,9 @@
 		    /// \brief Constructor
 		    ///
 		    /// Constructor
-		    /// \param _digraph The digraph that the map belongs to.
+		    /// \param digraph The digraph that the map belongs to.
 		    explicit TargetMap(const Digraph& digraph) : _digraph(digraph) {}
 		    /// \brief The subscript operator.
 		    ///
@@ -1915,11 +1925,11 @@
 		  private:
 		    const Digraph& _digraph;
 		  };
-		  /// \brief Returns a \ref TargetMap class.
+		  /// \brief Returns a \c TargetMap class.
 		  ///
-		  /// This function just returns a \ref TargetMap class.
+		  /// This function just returns a \c TargetMap class.
 		  /// \relates TargetMap
 		  template <typename Digraph>
 		  inline TargetMap<Digraph> targetMap(const Digraph& digraph) {
 		    return TargetMap<Digraph>(digraph);
@@ -1938,9 +1948,9 @@
 		    /// \brief Constructor
 		    ///
 		    /// Constructor
-		    /// \param _graph The graph that the map belongs to.
+		    /// \param graph The graph that the map belongs to.
 		    explicit ForwardMap(const Graph& graph) : _graph(graph) {}
 		    /// \brief The subscript operator.
 		    ///
@@ -1954,11 +1964,11 @@
 		  private:
 		    const Graph& _graph;
 		  };
-		  /// \brief Returns a \ref ForwardMap class.
+		  /// \brief Returns a \c ForwardMap class.
 		  ///
-		  /// This function just returns an \ref ForwardMap class.
+		  /// This function just returns an \c ForwardMap class.
 		  /// \relates ForwardMap
 		  template <typename Graph>
 		  inline ForwardMap<Graph> forwardMap(const Graph& graph) {
 		    return ForwardMap<Graph>(graph);
@@ -1977,9 +1987,9 @@
 		    /// \brief Constructor
 		    ///
 		    /// Constructor
-		    /// \param _graph The graph that the map belongs to.
+		    /// \param graph The graph that the map belongs to.
 		    explicit BackwardMap(const Graph& graph) : _graph(graph) {}
 		    /// \brief The subscript operator.
 		    ///
@@ -1993,11 +2003,11 @@
 		  private:
 		    const Graph& _graph;
 		  };
-		  /// \brief Returns a \ref BackwardMap class
+		  /// \brief Returns a \c BackwardMap class
-		  /// This function just returns a \ref BackwardMap class.
+		  /// This function just returns a \c BackwardMap class.
 		  /// \relates BackwardMap
 		  template <typename Graph>
 		  inline BackwardMap<Graph> backwardMap(const Graph& graph) {
 		    return BackwardMap<Graph>(graph);

lemon/path.h

Show inline comments

@@ -848,9 +848,9 @@
 		    /// \brief Return true when the path is empty.
 		    int empty() const { return len == 0; }
-		    /// \break Erase all arcs in the digraph.
+		    /// \brief Erase all arcs in the digraph.
 		    void clear() {
 		      len = 0;
 		      if (arcs) delete[] arcs;
 		      arcs = 0;

lemon/smart_graph.h

Show inline comments

@@ -364,9 +364,9 @@
 		      Snapshot() : _graph(0) {}
 		      ///Constructor that immediately makes a snapshot
 		      ///This constructor immediately makes a snapshot of the digraph.
-		      ///\param _g The digraph we make a snapshot of.
+		      ///\param graph The digraph we make a snapshot of.
 		      Snapshot(SmartDigraph &graph) : _graph(&graph) {
 		        node_num=_graph->nodes.size();
 		        arc_num=_graph->arcs.size();
+		      }
@@ -376,9 +376,9 @@
 		      ///Make a snapshot of the digraph.
 		      ///
 		      ///This function can be called more than once. In case of a repeated
 		      ///call, the previous snapshot gets lost.
-		      ///\param _g The digraph we make the snapshot of.
+		      ///\param graph The digraph we make the snapshot of.
 		      void save(SmartDigraph &graph)
+		      {
 		        _graph=&graph;
 		        node_num=_graph->nodes.size();
@@ -774,9 +774,9 @@
 		      Snapshot() : _graph(0) {}
 		      ///Constructor that immediately makes a snapshot
 		      ///This constructor immediately makes a snapshot of the digraph.
-		      ///\param g The digraph we make a snapshot of.
+		      ///\param graph The digraph we make a snapshot of.
 		      Snapshot(SmartGraph &graph) {
 		        graph.saveSnapshot(*this);
+		      }
@@ -785,9 +785,9 @@
 		      ///Make a snapshot of the graph.
 		      ///
 		      ///This function can be called more than once. In case of a repeated
 		      ///call, the previous snapshot gets lost.
-		      ///\param g The digraph we make the snapshot of.
+		      ///\param graph The digraph we make the snapshot of.
 		      void save(SmartGraph &graph)
+		      {
 		        graph.saveSnapshot(*this);
+		      }

lemon/time_measure.h

Show inline comments

@@ -310,14 +310,13 @@
 		    ///\name Control the state of the timer
 		    ///Basically a Timer can be either running or stopped,
 		    ///but it provides a bit finer control on the execution.
 		    ///The \ref Timer also counts the number of \ref start()
 		    ///executions, and is stops only after the same amount (or more)
 		    ///\ref stop() "stop()"s. This can be useful e.g. to compute
 		    ///the running time
 		    ///The \ref lemon::Timer "Timer" also counts the number of
 		    ///\ref lemon::Timer::start() "start()" executions, and it stops
 		    ///only after the same amount (or more) \ref lemon::Timer::stop()
 		    ///"stop()"s. This can be useful e.g. to compute the running time
 		    ///of recursive functions.
 		    ///
 		    ///@{
 		    ///Reset and stop the time counters
@@ -471,9 +470,9 @@
 		    ///@}
 		  };
-		  ///Same as \ref Timer but prints a report on destruction.
 		  ///Same as Timer but prints a report on destruction.
 		  ///Same as \ref Timer but prints a report on destruction.
 		  ///This example shows its usage.
 		  ///\code
@@ -490,24 +489,24 @@
+		  {
 		    std::string _title;
 		    std::ostream &_os;
 		  public:
-		    ///\e
+		    ///Constructor
 		    ///Constructor.
 		    ///\param title This text will be printed before the ellapsed time.
 		    ///\param os The stream to print the report to.
 		    ///\param run Sets whether the timer should start immediately.
 		    TimeReport(std::string title,std::ostream &os=std::cerr,bool run=true)
 		      : Timer(run), _title(title), _os(os){}
-		    ///\e Prints the ellapsed time on destruction.
+		    ///Destructor that prints the ellapsed time
 		    ~TimeReport()
+		    {
 		      _os << _title << *this << std::endl;
+		    }
 		  };
-		  ///'Do nothing' version of \ref TimeReport
 		  ///'Do nothing' version of TimeReport
 		  ///\sa TimeReport
 		  ///
 		  class NoTimeReport

tools/Makefile.am

Show inline comments

 		if WANT_TOOLS
 		bin_PROGRAMS +=
 		dist_bin_SCRIPTS += tools/lemon-0.x-to-1.x.sh
 		endif WANT_TOOLS

benchmark/Makefile.am

Show inline comments

 		if WANT_BENCHMARK
 		noinst_HEADERS +=
 		noinst_PROGRAMS +=
 		endif WANT_BENCHMARK

0 comments (0 inline)

RhodeCode

Login to your account

...	...	@@ -25,14 +25,13 @@
25	25	(static_cast<ArgParser*>(p))->showHelp();
26	26	exit(1);
27	27	}
28	28
29		ArgParser::ArgParser(int argc, const char **argv) :_argc(argc), _argv(argv),
30		_command_name(argv[0]) {
	29	ArgParser::ArgParser(int argc, const char * const *argv)
	30	:_argc(argc), _argv(argv), _command_name(argv[0]) {
31	31	funcOption("-help","Print a short help message",_showHelp,this);
32	32	synonym("help","-help");
33	33	synonym("h","-help");
34
35	34	}
36	35
37	36	ArgParser::~ArgParser()
38	37	{