LEMON/LEMON-official Changeset - r314:2cc60866a0c9

Repositories » LEMON » LEMON-official

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

Changeset - r314:2cc60866a0c9

« 313:64f8f7

315:c175e3 »

r314:2cc60866a0c9

Thu, 09 Oct 2008 13:27:35

[Not Reviewed]

0 comments (0 inline)

kpeter (Peter Kovacs)
kpeter@inf.elte.hu

Doc reorganization + improvements - Reorganize several tools (move them to other modules). - Add new module for map concepts. - Remove the doc of all tools in lemon/bits. - Improvements in groups.dox. - Fix some doxygen warnings.

0 17 0

default

17 files changed with 527 insertions and 558 deletions:

doc/groups.dox

doc/mainpage.dox

doc/migration.dox

lemon/bits/alteration_notifier.h

209

222

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/concepts/maps.h

lemon/dim2.h

lemon/maps.h

lemon/time_measure.h

↑ Collapse diff ↑

doc/groups.dox

Show inline comments

@@ -49,17 +49,19 @@
 		the residual graph can be accessed by another algorithm, or a node-set
 		is to be shrunk for another algorithm.
 		LEMON also provides a variety of graphs for these requirements called
 		\ref graph_adaptors "graph adaptors". Adaptors cannot be used alone but only
 		in conjunction with other graph representations.
 		You are free to use the graph structure that fit your requirements
 		the best, most graph algorithms and auxiliary data structures can be used
-		with any graph structures.
+		with any graph structure.
 		<b>See also:</b> \ref graph_concepts "Graph Structure Concepts".
 		*/
 		/**
 		@defgroup semi_adaptors Semi-Adaptor Classes for Graphs
 		@ingroup graphs
 		\brief Graph types between real graphs and graph adaptors.
 		This group describes some graph types between real graphs and graph adaptors.
@@ -69,67 +71,68 @@
 		/**
 		@defgroup maps Maps
 		@ingroup datas
 		\brief Map structures implemented in LEMON.
 		This group describes the map structures implemented in LEMON.
 		LEMON provides several special purpose maps that e.g. combine
+		LEMON provides several special purpose maps and map adaptors that e.g. combine
 		new maps from existing ones.
 		<b>See also:</b> \ref map_concepts "Map Concepts".
 		*/
 		/**
 		@defgroup graph_maps Graph Maps
 		@ingroup maps
 		\brief Special graph-related maps.
 		This group describes maps that are specifically designed to assign
 		values to the nodes and arcs of graphs.
 		*/
 		/**
 		\defgroup map_adaptors Map Adaptors
 		\ingroup maps
 		\brief Tools to create new maps from existing ones
 		This group describes map adaptors that are used to create "implicit"
 		maps from other maps.
 		Most of them are \ref lemon::concepts::ReadMap "read-only maps".
 		They can make arithmetic and logical operations between one or two maps
 		(negation, shifting, addition, multiplication, logical 'and', 'or',
 		'not' etc.) or e.g. convert a map to another one of different Value type.
 		The typical usage of this classes is passing implicit maps to
 		algorithms.  If a function type algorithm is called then the function
 		type map adaptors can be used comfortable. For example let's see the
-		usage of map adaptors with the \c 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);
 		    } else if (deg == 1) {
 		      return Color(1.0, 0.5, 1.0);
 		    } else {
 		      return Color(0.0, 0.0, 0.0);
+		    }
+		  }
 		  Digraph::NodeMap<int> degree_map(graph);
-		  digraphToEps(graph, "graph.eps")
+		  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
 		case the function type map adaptors can not be used, because the
 		function map adaptors give back temporary objects.
 		\code
 		  Digraph graph;
@@ -168,57 +171,55 @@
 		LEMON provides flexible data structures to work with paths.
 		All of them have similar interfaces and they can be copied easily with
 		assignment operators and copy constructors. This makes it easy and
 		efficient to have e.g. the Dijkstra algorithm to store its result in
 		any kind of path structure.
 		\sa lemon::concepts::Path
 		*/
 		/**
 		@defgroup auxdat Auxiliary Data Structures
 		@ingroup datas
 		\brief Auxiliary data structures implemented in LEMON.
 		This group describes some data structures implemented in LEMON in
 		order to make it easier to implement combinatorial algorithms.
 		*/
 		/**
 		@defgroup algs Algorithms
 		\brief This group describes the several algorithms
 		implemented in LEMON.
 		This group describes the several algorithms
 		implemented in LEMON.
 		*/
 		/**
 		@defgroup search Graph Search
 		@ingroup algs
 		\brief Common graph search algorithms.
 		This group describes the common graph search algorithms like
-		Breadth-first search (Bfs) and Depth-first search (Dfs).
+		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 max_flow Maximum Flow algorithms
+		@defgroup max_flow Maximum Flow Algorithms
 		@ingroup algs
 		\brief Algorithms for finding maximum flows.
 		This group describes the algorithms for finding maximum flows and
 		feasible circulations.
 		The maximum flow problem is to find a flow between a single source and
 		a single target that is maximum. Formally, there is a \f$G=(V,A)\f$
@@ -236,31 +237,30 @@
 		- \ref lemon::Preflow "Goldberg's Preflow algorithm"
 		- \ref lemon::DinitzSleatorTarjan "Dinitz's blocking flow algorithm with dynamic trees"
 		- \ref lemon::GoldbergTarjan "Preflow algorithm with dynamic trees"
 		In most cases the \ref lemon::Preflow "Preflow" algorithm provides the
 		fastest method to compute the maximum flow. All impelementations
 		provides functions to query the minimum cut, which is the dual linear
 		programming problem of the maximum flow.
 		*/
 		/**
-		@defgroup min_cost_flow Minimum Cost Flow algorithms
+		@defgroup min_cost_flow Minimum Cost Flow Algorithms
 		@ingroup algs
 		\brief Algorithms for finding minimum cost flows and circulations.
 		This group describes the algorithms for finding minimum cost flows and
 		circulations.
 		*/
 		/**
-		@defgroup min_cut Minimum Cut algorithms
+		@defgroup min_cut Minimum Cut Algorithms
 		@ingroup algs
 		\brief Algorithms for finding minimum cut in graphs.
 		This group describes the algorithms for finding minimum cut in graphs.
 		The minimum cut problem is to find a non-empty and non-complete
 		\f$X\f$ subset of the vertices with minimum overall capacity on
@@ -277,45 +277,44 @@
 		  in directed graphs
 		- \ref lemon::NagamochiIbaraki "Nagamochi-Ibaraki algorithm" to
 		  calculate minimum cut in undirected graphs
 		- \ref lemon::GomoryHuTree "Gomory-Hu tree computation" to calculate all
 		  pairs minimum cut in undirected graphs
 		If you want to find minimum cut just between two distinict nodes,
 		please see the \ref max_flow "Maximum Flow page".
 		*/
 		/**
-		@defgroup graph_prop Connectivity and other graph properties
+		@defgroup graph_prop Connectivity and Other Graph Properties
 		@ingroup algs
 		\brief Algorithms for discovering the graph properties
 		This group describes the algorithms for discovering the graph properties
 		like connectivity, bipartiteness, euler property, simplicity etc.
 		\image html edge_biconnected_components.png
 		\image latex edge_biconnected_components.eps "bi-edge-connected components" width=\textwidth
 		*/
 		/**
-		@defgroup planar Planarity embedding and drawing
+		@defgroup planar Planarity Embedding and Drawing
 		@ingroup algs
 		\brief Algorithms for planarity checking, embedding and drawing
 		This group describes the algorithms for planarity checking,
 		embedding and drawing.
 		\image html planar.png
 		\image latex planar.eps "Plane graph" width=\textwidth
 		*/
 		/**
-		@defgroup matching Matching algorithms
+		@defgroup matching Matching Algorithms
 		@ingroup algs
 		\brief Algorithms for finding matchings in graphs and bipartite graphs.
 		This group contains algorithm objects and functions to calculate
 		matchings in graphs and bipartite graphs. The general matching problem is
 		finding a subset of the arcs which does not shares common endpoints.
 		There are several different algorithms for calculate matchings in
@@ -343,69 +342,66 @@
 		  shrinking algorithm for calculate maximum weighted matching in general
 		  graph
 		- \ref lemon::MaxWeightedPerfectMatching "MaxWeightedPerfectMatching"
 		  Edmond's blossom shrinking algorithm for calculate maximum weighted
 		  perfect matching in general graph
 		\image html bipartite_matching.png
 		\image latex bipartite_matching.eps "Bipartite Matching" width=\textwidth
 		*/
 		/**
-		@defgroup spantree Minimum Spanning Tree algorithms
+		@defgroup spantree Minimum Spanning Tree Algorithms
 		@ingroup algs
 		\brief Algorithms for finding a minimum cost spanning tree in a graph.
 		This group describes the algorithms for finding a minimum cost spanning
 		tree in a graph
 		*/
 		/**
-		@defgroup auxalg Auxiliary algorithms
+		@defgroup auxalg Auxiliary Algorithms
 		@ingroup algs
 		\brief Auxiliary algorithms implemented in LEMON.
 		This group describes some algorithms implemented in LEMON
 		in order to make it easier to implement complex algorithms.
 		*/
 		/**
-		@defgroup approx Approximation algorithms
+		@defgroup approx Approximation Algorithms
 		@ingroup algs
 		\brief Approximation algorithms.
 		This group describes the approximation and heuristic algorithms
 		implemented in LEMON.
 		*/
 		/**
 		@defgroup gen_opt_group General Optimization Tools
 		\brief This group describes some general optimization frameworks
 		implemented in LEMON.
 		This group describes some general optimization frameworks
 		implemented in LEMON.
 		*/
 		/**
-		@defgroup lp_group Lp and Mip solvers
+		@defgroup lp_group Lp and Mip Solvers
 		@ingroup gen_opt_group
 		\brief Lp and Mip solver interfaces for LEMON.
 		This group describes Lp and Mip solver interfaces for LEMON. The
 		various LP solvers could be used in the same manner with this
 		interface.
 		*/
 		/**
-		@defgroup lp_utils Tools for Lp and Mip solvers
+		@defgroup lp_utils Tools for Lp and Mip Solvers
 		@ingroup lp_group
 		\brief Helper tools to the Lp and Mip solvers.
 		This group adds some helper tools to general optimization framework
 		implemented in LEMON.
 		*/
 		/**
@@ -436,69 +432,60 @@
 		@ingroup utils
 		\brief Tools for development, debugging and testing.
 		This group describes several useful tools for development,
 		debugging and testing.
 		*/
 		/**
-		@defgroup timecount Time measuring and Counting
+		@defgroup timecount Time Measuring and Counting
 		@ingroup misc
 		\brief Simple tools for measuring the performance of algorithms.
 		This group describes simple tools for measuring the performance
 		of algorithms.
 		*/
 		/**
 		@defgroup graphbits Tools for Graph Implementation
 		@ingroup utils
 		\brief Tools to make it easier to create graphs.
 		This group describes the tools that makes it easier to create graphs and
 		the maps that dynamically update with the graph changes.
 		*/
 		/**
 		@defgroup exceptions Exceptions
 		@ingroup utils
 		\brief Exceptions defined in LEMON.
 		This group describes the exceptions defined in LEMON.
 		*/
 		/**
 		@defgroup io_group Input-Output
 		\brief Graph Input-Output methods
 		This group describes the tools for importing and exporting graphs
 		and graph related data. Now it supports the LEMON format, the
 		\c DIMACS format and the encapsulated postscript (EPS) format.
 		and graph related data. Now it supports the \ref lgf-format
 		"LEMON Graph Format", the \c DIMACS format and the encapsulated
 		postscript (EPS) format.
 		*/
 		/**
 		@defgroup lemon_io LEMON Input-Output
 		@ingroup io_group
-		\brief Reading and writing \ref lgf-format "LEMON Graph Format".
 		\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
 		This group describes the data/algorithm skeletons and concept checking
 		classes implemented in LEMON.
 		The purpose of the classes in this group is fourfold.
@@ -516,33 +503,33 @@
 		  of course.) In this way it is easily to check if an algorithm
 		  doesn't use any extra feature of a certain implementation.
 		- The concept descriptor classes also provide a <em>checker class</em>
 		  that makes it possible to check whether a certain implementation of a
 		  concept indeed provides all the required features.
 		- Finally, They can serve as a skeleton of a new implementation of a concept.
 		*/
 		/**
 		@defgroup graph_concepts Graph Structure Concepts
 		@ingroup concept
 		\brief Skeleton and concept checking classes for graph structures
 		This group describes the skeletons and concept checking classes of LEMON's
 		graph structures and helper classes used to implement these.
 		*/
 		/* --- Unused group
 		@defgroup experimental Experimental Structures and Algorithms
 		This group describes some Experimental structures and algorithms.
 		The stuff here is subject to change.
 		/**
 		@defgroup map_concepts Map Concepts
 		@ingroup concept
 		\brief Skeleton and concept checking classes for maps
 		This group describes the skeletons and concept checking classes of maps.
 		*/
 		/**
 		\anchor demoprograms
 		@defgroup demos Demo programs
 		Some demo programs are listed here. Their full source codes can be found in

doc/mainpage.dox

Show inline comments

@@ -45,16 +45,17 @@
 		take a look at our \ref quicktour
 		"Quick Tour to LEMON" which will guide you along.
 		If you already feel like using our library, see the page that tells you
 		\ref getstart "How to start using LEMON".
 		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.
 		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.
 		*/

doc/migration.dox

Show inline comments

@@ -52,17 +52,17 @@
 		  \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
 		\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

lemon/bits/alteration_notifier.h

Show inline comments

@@ -19,326 +19,317 @@
 		#ifndef LEMON_BITS_ALTERATION_NOTIFIER_H
 		#define LEMON_BITS_ALTERATION_NOTIFIER_H
 		#include <vector>
 		#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 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:
 		    typedef True Notifier;
 		    typedef _Container Container;
 		    typedef _Item Item;
 		    /// \brief Exception which can be called from \e clear() and
 		    /// \e erase().
 		    ///
 		    /// From the \e clear() and \e erase() function only this
 		    /// exception is allowed to throw. The exception immediatly
 		    /// detaches the current observer from the notifier. Because the
 		    /// \e clear() and \e erase() should not throw other exceptions
 		    /// it can be used to invalidate the observer.
 		    // \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:
 		      ObserverBase& operator=(const ObserverBase& copy);
 		    protected:
 		      Notifier* _notifier;
 		      typename std::list<ObserverBase*>::iterator _index;
 		      /// \brief The member function to notificate the observer about an
 		      /// item is added to the container.
 		      ///
 		      /// The add() member function notificates the observer about an item
 		      /// is added to the container. It have to be overrided in the
 		      /// subclasses.
 		      // \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;
 		    };
 		  protected:
 		    const Container* container;
 		    typedef std::list<ObserverBase*> Observers;
 		    Observers _observers;
 		  public:
 		    /// \brief Default constructor.
 		    ///
 		    /// The default constructor of the AlterationNotifier.
 		    /// It creates an empty notifier.
 		    // \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;
+		    }
 		  protected:
 		    AlterationNotifier& operator=(const AlterationNotifier&);
 		  public:
 		    /// \brief First item in the container.
 		    ///
 		    /// Returns the first item in the container. It is
 		    /// for start the iteration on the container.
 		    // \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());
+		    }
 		  protected:
 		    void attach(ObserverBase& observer) {
 		      observer._index = _observers.insert(_observers.begin(), &observer);
@@ -348,123 +339,119 @@
 		    void detach(ObserverBase& observer) {
 		      _observers.erase(observer._index);
 		      observer._index = _observers.end();
 		      observer._notifier = 0;
+		    }
 		  public:
 		    /// \brief Notifies all the registed observers about an item added to
 		    /// the container.
 		    ///
 		    /// It notifies all the registed observers about an item added to
 		    /// the container.
 		    ///
 		    // \brief Notifies all the registed observers about an item added to
 		    // the container.
 		    //
 		    // It notifies all the registed observers about an item added to
 		    // the container.
 		    void add(const Item& item) {
 		      typename Observers::reverse_iterator it;
 		      try {
 		        for (it = _observers.rbegin(); it != _observers.rend(); ++it) {
 		          (*it)->add(item);
+		        }
 		      } catch (...) {
 		        typename Observers::iterator jt;
 		        for (jt = it.base(); jt != _observers.end(); ++jt) {
 		          (*jt)->erase(item);
+		        }
 		        throw;
+		      }
+		    }
 		    /// \brief Notifies all the registed observers about more item added to
 		    /// the container.
 		    ///
 		    /// It notifies all the registed observers about more item added to
 		    /// the container.
 		    ///
 		    // \brief Notifies all the registed observers about more item added to
 		    // the container.
 		    //
 		    // It notifies all the registed observers about more item added to
 		    // the container.
 		    void add(const std::vector<Item>& items) {
 		      typename Observers::reverse_iterator it;
 		      try {
 		        for (it = _observers.rbegin(); it != _observers.rend(); ++it) {
 		          (*it)->add(items);
+		        }
 		      } catch (...) {
 		        typename Observers::iterator jt;
 		        for (jt = it.base(); jt != _observers.end(); ++jt) {
 		          (*jt)->erase(items);
+		        }
 		        throw;
+		      }
+		    }
 		    /// \brief Notifies all the registed observers about an item erased from
 		    /// the container.
 		    ///
 		    /// It notifies all the registed observers about an item erased from
 		    /// the container.
 		    ///
 		    // \brief Notifies all the registed observers about an item erased from
 		    // the container.
 		    //
 		    // It notifies all the registed observers about an item erased from
 		    // the container.
 		    void erase(const Item& item) throw() {
 		      typename Observers::iterator it = _observers.begin();
 		      while (it != _observers.end()) {
 		        try {
 		          (*it)->erase(item);
 		          ++it;
 		        } catch (const ImmediateDetach&) {
 		          (*it)->_index = _observers.end();
 		          (*it)->_notifier = 0;
 		          it = _observers.erase(it);
+		        }
+		      }
+		    }
 		    /// \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 {
 		          (*it)->erase(items);
 		          ++it;
 		        } catch (const ImmediateDetach&) {
 		          (*it)->_index = _observers.end();
 		          (*it)->_notifier = 0;
 		          it = _observers.erase(it);
+		        }
+		      }
+		    }
 		    /// \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) {
 		          (*it)->build();
+		        }
 		      } catch (...) {
 		        typename Observers::iterator jt;
 		        for (jt = it.base(); jt != _observers.end(); ++jt) {
 		          (*jt)->clear();
+		        }
 		        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 {
 		          (*it)->clear();
 		          ++it;
 		        } catch (const ImmediateDetach&) {
 		          (*it)->_index = _observers.end();

lemon/bits/array_map.h

Show inline comments

@@ -21,192 +21,192 @@
 		#include <memory>
 		#include <lemon/bits/traits.h>
 		#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();
 		      Item it;
 		      for (nf->first(it); it != INVALID; nf->next(it)) {
 		        int id = nf->id(it);;
 		        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();
 		      Item it;
 		      for (nf->first(it); it != INVALID; nf->next(it)) {
 		        int id = nf->id(it);;
 		        allocator.construct(&(values[id]), value);
+		      }
+		    }
 		  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());
+		      }
 		      capacity = copy.capacity;
 		      if (capacity == 0) return;
 		      values = allocator.allocate(capacity);
 		      Notifier* nf = Parent::notifier();
 		      Item it;
 		      for (nf->first(it); it != INVALID; nf->next(it)) {
 		        int id = nf->id(it);;
 		        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();
 		      Item it;
 		      for (nf->first(it); it != INVALID; nf->next(it)) {
 		        set(it, cmap[it]);
+		      }
 		      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();
+		      }
+		    }
 		  protected:
 		    using Parent::attach;
 		    using Parent::detach;
 		    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) {
 		        int new_capacity = (capacity == 0 ? 1 : capacity);
 		        while (new_capacity <= id) {
 		          new_capacity <<= 1;
+		        }
@@ -221,20 +221,20 @@
+		        }
 		        if (capacity != 0) allocator.deallocate(values, capacity);
 		        values = new_values;
 		        capacity = new_capacity;
+		      }
 		      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) {
 		        int id = nf->id(keys[i]);
 		        if (id > max_id) {
 		          max_id = id;
+		        }
@@ -265,54 +265,54 @@
 		        capacity = new_capacity;
+		      }
 		      for (int i = 0; i < int(keys.size()); ++i) {
 		        int id = nf->id(keys[i]);
 		        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;
 		      for (nf->first(it); it != INVALID; nf->next(it)) {
 		        int id = nf->id(it);;
 		        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;
 		        for (nf->first(it); it != INVALID; nf->next(it)) {
 		          int id = nf->id(it);
 		          allocator.destroy(&(values[id]));
+		        }

lemon/bits/base_extender.h

Show inline comments

@@ -23,24 +23,24 @@
 		#include <lemon/error.h>
 		#include <lemon/bits/map_extender.h>
 		#include <lemon/bits/default_map.h>
 		#include <lemon/concept_check.h>
 		#include <lemon/concepts/maps.h>
 		///\ingroup digraphbits
 		///\file
-		///\brief Extenders for the digraph types
+		//\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:
 		    typedef Base Parent;
 		    typedef typename Parent::Arc Edge;
 		    typedef typename Parent::Node Node;
@@ -69,47 +69,47 @@
 		        return forward!=that.forward || Edge(*this)!=Edge(that);
+		      }
 		      bool operator<(const Arc &that) const {
 		        return forward<that.forward ||
 		          (!(that.forward<forward) && Edge(*this)<Edge(that));
+		      }
 		    };
-		    /// 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;
 		    void first(Arc &e) const {
 		      Parent::first(e);
 		      e.forward=true;

lemon/bits/bezier.h

Show inline comments

@@ -14,21 +14,21 @@
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#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 {
 		  namespace dim2 {
 		class BezierBase {
 		public:

lemon/bits/default_map.h

Show inline comments

@@ -14,24 +14,23 @@
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_BITS_DEFAULT_MAP_H
 		#define LEMON_BITS_DEFAULT_MAP_H
 		#include <lemon/bits/array_map.h>
 		#include <lemon/bits/vector_map.h>
 		//#include <lemon/bits/debug_map.h>
 		///\ingroup graphbits
 		///\file
-		///\brief Graph maps that construct and destruct their elements dynamically.
+		//\ingroup graphbits
 		//\file
 		//\brief Graph maps that construct and destruct their elements dynamically.
 		namespace lemon {
 		  //#ifndef LEMON_USE_DEBUG_MAP
 		  template <typename _Graph, typename _Item, typename _Value>
 		  struct DefaultMapSelector {
@@ -144,17 +143,17 @@
 		//   template <typename _Graph, typename _Item, typename _Value>
 		//   struct DefaultMapSelector {
 		//     typedef DebugMap<_Graph, _Item, _Value> Map;
 		//   };
 		// #endif
-		  /// DefaultMap class
 		  // DefaultMap class
 		  template <typename _Graph, typename _Item, typename _Value>
 		  class DefaultMap
 		    : public DefaultMapSelector<_Graph, _Item, _Value>::Map {
 		  public:
 		    typedef typename DefaultMapSelector<_Graph, _Item, _Value>::Map Parent;
 		    typedef DefaultMap<_Graph, _Item, _Value> Map;
 		    typedef typename Parent::Graph Graph;

lemon/bits/enable_if.h

Show inline comments

@@ -30,39 +30,39 @@
 		//    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
 		//             Jeremiah Willcock (jewillco at osl.iu.edu)
 		//             Andrew Lumsdaine (lums at osl.iu.edu)
 		#ifndef LEMON_BITS_ENABLE_IF_H
 		#define LEMON_BITS_ENABLE_IF_H
 		///\file
 		///\brief Miscellaneous basic utilities
 		//\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;
 		  };
 		  template <typename T>
 		  struct Wrap {
 		    const T &value;

lemon/bits/graph_extender.h

Show inline comments

@@ -22,24 +22,24 @@
 		#include <lemon/core.h>
 		#include <lemon/bits/map_extender.h>
 		#include <lemon/bits/default_map.h>
 		#include <lemon/concept_check.h>
 		#include <lemon/concepts/maps.h>
 		///\ingroup graphbits
 		///\file
-		///\brief Extenders for the digraph types
+		//\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:
 		    typedef Base Parent;
 		    typedef DigraphExtender Digraph;
 		    // Base extensions
@@ -181,40 +181,40 @@
 		      InArcIt& operator++() {
 		        _digraph->nextIn(*this);
 		        return *this;
+		      }
 		    };
 		    /// \brief Base node of the iterator
 		    ///
-		    /// Returns the base node (i.e. the source in this case) of the iterator
+		    // \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);
+		    }
 		    template <typename _Value>
 		    class NodeMap
 		      : public MapExtender<DefaultMap<Digraph, Node, _Value> > {
@@ -320,19 +320,19 @@
 		    ~DigraphExtender() {
 		      arc_notifier.clear();
 		      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:
 		    typedef Base Parent;
 		    typedef GraphExtender Graph;
 		    typedef True UndirectedTag;
@@ -550,53 +550,53 @@
+		      }
 		      IncEdgeIt& operator++() {
 		        _graph->nextInc(*this, _direction);
 		        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);
+		    }
 		    // Mappable extension
 		    template <typename _Value>
 		    class NodeMap

lemon/bits/map_extender.h

Show inline comments

@@ -21,24 +21,24 @@
 		#include <iterator>
 		#include <lemon/bits/traits.h>
 		#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:
 		    typedef _Map Parent;
 		    typedef MapExtender Map;
@@ -166,19 +166,19 @@
+		      }
 		    protected:
 		      const Map& map;
 		    };
 		  };
 		  /// \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:
 		    typedef _Map Parent;
 		    typedef SubMapExtender Map;
 		    typedef _Graph Graph;

lemon/bits/traits.h

Show inline comments

@@ -14,19 +14,19 @@
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#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 {
 		  struct InvalidType {};
 		  template <typename _Graph, typename _Item>

lemon/bits/vector_map.h

Show inline comments

@@ -23,213 +23,213 @@
 		#include <algorithm>
 		#include <lemon/core.h>
 		#include <lemon/bits/alteration_notifier.h>
 		#include <lemon/concept_check.h>
 		#include <lemon/concepts/maps.h>
 		///\ingroup graphbits
 		///
 		///\file
 		///\brief Vector based graph maps.
 		//\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();
 		      Item it;
 		      for (nf->first(it); it != INVALID; nf->next(it)) {
 		        set(it, cmap[it]);
+		      }
 		      return *this;
+		    }
 		  public:
 		    /// \brief The subcript operator.
 		    ///
 		    /// The subscript operator. The map can be subscripted by the
 		    /// actual items of the graph.
 		    // \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]);
 		        if (id >= max) {
 		          max = id;
+		        }
+		      }
 		      container.resize(max + 1);
+		    }
 		    /// \brief Erase a key from the map.
 		    ///
 		    /// Erase a key from the map. It called by the observer notifier
 		    /// and it overrides the erase() member function of the observer base.
 		    // \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();
+		    }
 		  private:
 		    Container container;

lemon/concepts/maps.h

Show inline comments

@@ -17,25 +17,25 @@
 		 */
 		#ifndef LEMON_CONCEPT_MAPS_H
 		#define LEMON_CONCEPT_MAPS_H
 		#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
 		    /// Readable map concept.
 		    ///
 		    template<typename K, typename T>
 		    class ReadMap

lemon/dim2.h

Show inline comments

@@ -571,17 +571,17 @@
+		  {
 		    os << "(" << b.bottomLeft() << "," << b.topRight() << ")";
 		    return os;
+		  }
 		  ///Map of x-coordinates of a <tt>Point</tt>-map
 		  ///Map of x-coordinates of a \ref Point "Point"-map.
-		  ///\ingroup maps
 		  ///
 		  template<class M>
 		  class XMap
+		  {
 		    M& _map;
 		  public:
 		    typedef typename M::Value::Value Value;
 		    typedef typename M::Key Key;
@@ -589,64 +589,60 @@
 		    XMap(M& map) : _map(map) {}
 		    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 XMap class
 		  ///This function just returns an XMap class.
 		  ///
 		  ///\ingroup maps
 		  ///\relates XMap
 		  template<class M>
 		  inline XMap<M> xMap(M &m)
+		  {
 		    return XMap<M>(m);
+		  }
 		  template<class M>
 		  inline XMap<M> xMap(const M &m)
+		  {
 		    return XMap<M>(m);
+		  }
 		  ///Constant (read only) version of XMap
 		  ///Constant (read only) version of XMap.
-		  ///\ingroup maps
 		  ///
 		  template<class M>
 		  class ConstXMap
+		  {
 		    const M& _map;
 		  public:
 		    typedef typename M::Value::Value Value;
 		    typedef typename M::Key Key;
 		    ///\e
 		    ConstXMap(const M &map) : _map(map) {}
 		    Value operator[](Key k) const {return _map[k].x;}
 		  };
 		  ///Returns a ConstXMap class
 		  ///This function just returns a ConstXMap class.
 		  ///
 		  ///\ingroup maps
 		  ///\relates ConstXMap
 		  template<class M>
 		  inline ConstXMap<M> xMap(const M &m)
+		  {
 		    return ConstXMap<M>(m);
+		  }
 		  ///Map of y-coordinates of a <tt>Point</tt>-map
 		  ///Map of y-coordinates of a \ref Point "Point"-map.
-		  ///\ingroup maps
 		  ///
 		  template<class M>
 		  class YMap
+		  {
 		    M& _map;
 		  public:
 		    typedef typename M::Value::Value Value;
 		    typedef typename M::Key Key;
@@ -654,84 +650,77 @@
 		    YMap(M& map) : _map(map) {}
 		    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 YMap class
 		  ///This function just returns a YMap class.
 		  ///
 		  ///\ingroup maps
 		  ///\relates YMap
 		  template<class M>
 		  inline YMap<M> yMap(M &m)
+		  {
 		    return YMap<M>(m);
+		  }
 		  template<class M>
 		  inline YMap<M> yMap(const M &m)
+		  {
 		    return YMap<M>(m);
+		  }
 		  ///Constant (read only) version of YMap
 		  ///Constant (read only) version of YMap.
-		  ///\ingroup maps
 		  ///
 		  template<class M>
 		  class ConstYMap
+		  {
 		    const M& _map;
 		  public:
 		    typedef typename M::Value::Value Value;
 		    typedef typename M::Key Key;
 		    ///\e
 		    ConstYMap(const M &map) : _map(map) {}
 		    Value operator[](Key k) const {return _map[k].y;}
 		  };
 		  ///Returns a ConstYMap class
 		  ///This function just returns a ConstYMap class.
 		  ///
 		  ///\ingroup maps
 		  ///\relates ConstYMap
 		  template<class M>
 		  inline ConstYMap<M> yMap(const M &m)
+		  {
 		    return ConstYMap<M>(m);
+		  }
 		  ///\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;
 		  public:
 		    typedef typename M::Value::Value Value;
 		    typedef typename M::Key Key;
 		    ///\e
 		    NormSquareMap(const M &map) : _map(map) {}
 		    Value operator[](Key k) const {return _map[k].normSquare();}
 		  };
 		  ///Returns a NormSquareMap class
 		  ///This function just returns a NormSquareMap class.
 		  ///
 		  ///\ingroup maps
 		  ///\relates NormSquareMap
 		  template<class M>
 		  inline NormSquareMap<M> normSquareMap(const M &m)
+		  {
 		    return NormSquareMap<M>(m);
+		  }
 		  /// @}

lemon/maps.h

Show inline comments

@@ -1678,16 +1678,21 @@
 		    struct IteratorTraits<_Iterator,
 		      typename exists<typename _Iterator::container_type>::type>
+		    {
 		      typedef typename _Iterator::container_type::value_type Value;
 		    };
+		  }
 		  /// @}
 		  /// \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
 		  /// keys set to \c true to the given iterator.
 		  /// The most important usage of it is storing certain nodes or arcs
 		  /// that were marked \c true by an algorithm.
 		  ///
@@ -1770,16 +1775,21 @@
 		  /// \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:
 		  /// different items (nodes) get different ids <li>\b immutable: the id of an
 		  /// item (node) does not change (even if you delete other nodes).  </ul>
 		  /// Through this map you get access (i.e. can read) the inner id values of
 		  /// the items stored in the graph. This map can be inverted with its member
@@ -1877,18 +1887,16 @@
 		  public:
 		    /// The key type of InvertableMap (Node, Arc, Edge).
 		    typedef typename Map::Key Key;
 		    /// The value type of the InvertableMap.
 		    typedef typename Map::Value Value;
 		    /// \brief Constructor.
 		    ///
 		    /// Construct a new InvertableMap for the graph.
 		    ///
 		    explicit InvertableMap(const Graph& graph) : Map(graph) {}
 		    /// \brief Forward iterator for values.
 		    ///
@@ -2044,18 +2052,16 @@
 		    /// \brief It gives back the just readable inverse map.
 		    ///
 		    /// It gives back the just readable inverse map.
 		    InverseMap inverse() const {
 		      return InverseMap(*this);
+		    }
 		  };
 		  /// \brief Provides a mutable, continuous and unique descriptor for each
 		  /// item in the graph.
 		  ///
 		  /// The DescriptorMap class provides a unique and continuous (but mutable)
 		  /// descriptor (id) for each item of the same type (e.g. node) in the
 		  /// graph. This id is <ul><li>\b unique: different items (nodes) get

lemon/time_measure.h

Show inline comments

@@ -306,18 +306,18 @@
 		    ///\param run indicates whether or not the timer starts immediately.
 		    ///
 		    Timer(bool run=true) :_running(run) {_reset();}
 		    ///\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 lemon::Timer "Timer" also counts the number of
 		    ///\ref lemon::Timer::start() "start()" executions, and it stops
 		    ///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

0 comments (0 inline)

RhodeCode

Login to your account