Diff [de38fca7678041dd19b4439b845071d50feec778:12626fc94ccf51d14518c91d17560621646414e9] for / – LEMON

Makefile.am

-                      r227
+                      r310
 bin_PROGRAMS =
 check_PROGRAMS =
+dist_bin_SCRIPTS =
 TESTS =
 XFAIL_TESTS =
 …
 include doc/Makefile.am
 include demo/Makefile.am
-include benchmark/Makefile.am
 include tools/Makefile.am

README

-                      r246
+                      r310
    Contains programs to check the integrity and correctness of LEMON.
-benchmark/
-   Contains programs for measuring the performance of algorithms.
 tools/

configure.ac

-                      r296
+                      r310
 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)
 …
 #echo SOPLEX support................ : $lx_soplex_found
 #echo
-echo Build benchmarks.............. : $enable_benchmark
 echo Build demo programs........... : $enable_demo
 echo Build additional tools........ : $enable_tools

demo/arg_parser_demo.cc

r209	r311
28	28
29	29	using namespace lemon;
30		int main(int argc, c~~onst c~~har **argv)
	30	int main(int argc, char **argv)
31	31	{
32	32	// Initialize the argument parser

demo/graph_to_eps_demo.cc

r220	r313
27	27	/// how to handle parallel egdes, how to change the properties (like
28	28	/// color, shape, size, title etc.) of nodes and arcs individually
29		/// using appropriate ~~\ref maps-page "graph maps"~~.
	29	/// using appropriate graph maps.
30	30	///
31	31	/// \include graph_to_eps_demo.cc

doc/Makefile.am

r270	r306
7	7	doc/license.dox \
8	8	doc/mainpage.dox \
	9	doc/migration.dox \
9	10	doc/named-param.dox \
10	11	doc/namespaces.dox \

doc/groups.dox

-                      r325
+                      r327
 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".
 */
 …
 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".
 */
 …
 values to the nodes and arcs of graphs.
 */
 /**
 …
 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) {
 …
   Digraph::NodeMap<int> degree_map(graph);
   digraphToEps(graph, "graph.eps")
+  graphToEps(graph, "graph.eps")
     .coords(coords).scaleToA4().undirected()
     .nodeColors(composeMap(functorToMap(nodeColor), degree_map))
 …
 \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.
 …
 \sa lemon::concepts::Path
 */
 …
 */
 /**
 @defgroup algs Algorithms
 …
 This group describes the common graph search algorithms like
 Breadth-first search (Bfs) and Depth-first search (Dfs).
 */
 /**
 @defgroup shortest_path Shortest Path algorithms
+Breadth-First Search (BFS) and Depth-First Search (DFS).
+*/
+/**
+@defgroup shortest_path Shortest Path Algorithms
 @ingroup algs
 \brief Algorithms for finding shortest paths.
 …
 /**
 @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.
 …
 */
+@ingroup algs
 /**
 @defgroup utils Tools and Utilities
 …
 /**
 @defgroup timecount Time measuring and Counting
+@defgroup timecount Time Measuring and Counting
 @ingroup misc
 \brief Simple tools for measuring the performance of algorithms.
 …
 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
 …
 /**
 @defgroup eps_io Postscript exporting
+@defgroup eps_io Postscript Exporting
 @ingroup io_group
 \brief General \c EPS drawer and graph exporter
 …
 graph exporting tools.
 */
 /**
 …
 - Finally, They can serve as a skeleton of a new implementation of a concept.
+*/
+*/
 /**
 …
 */
+This group describes the skeletons and concept checking classes of maps.
 /**
 \anchor demoprograms

doc/lgf.dox

r236	r313
79	79	\endcode
80	80
81		The \c \@edges is just a synonym of \c \@arcs. The @arcs section can
	81	The \c \@edges is just a synonym of \c \@arcs. The \@arcs section can
82	82	also store the edge set of an undirected graph. In such case there is
83	83	a conventional method for store arc maps in the file, if two columns

doc/mainpage.dox

-                      r325
+                      r327
 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
 …
 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

-                      r214
+                      r311
+  }
   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");
+  }

lemon/arg_parser.h

-                      r290
+                      r311
     int _argc;
     const char **_argv;
+    const char * const *_argv;
     enum OptType { UNKNOWN=0, BOOL=1, STRING=2, DOUBLE=3, INTEGER=4, FUNC=5 };
 …
     ///Constructor
     ArgParser(int argc, const char **argv);
+    ArgParser(int argc, const char * const *argv);
     ~ArgParser();

lemon/bfs.h

-                      r292
+                      r301
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a \ref PredMap.
     ///This function instantiates a \ref PredMap.
+    ///Instantiates a 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)
+    {
 …
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a \ref ProcessedMap.
     ///This function instantiates a \ref ProcessedMap.
+    ///Instantiates a 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)
 …
     ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a \ref ReachedMap.
     ///This function instantiates a \ref ReachedMap.
+    ///Instantiates a 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)
+    {
 …
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<int> DistMap;
     ///Instantiates a \ref DistMap.
     ///This function instantiates a \ref DistMap.
+    ///Instantiates a 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)
+    {
 …
     };
     ///\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> > {
 …
     };
     ///\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> > {
 …
     };
     ///\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> > {
 …
     };
     ///\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> > {
 …
     };
     ///\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 :
 …
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a \ref PredMap.
     ///This function instantiates a \ref PredMap.
+    ///Instantiates a 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)
+    {
 …
     ///By default it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a \ref ProcessedMap.
     ///This function instantiates a \ref ProcessedMap.
+    ///Instantiates a 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)
 …
     ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a \ref ReachedMap.
     ///This function instantiates a \ref ReachedMap.
+    ///Instantiates a 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)
+    {
 …
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<int> DistMap;
     ///Instantiates a \ref DistMap.
     ///This function instantiates a \ref DistMap.
+    ///Instantiates a 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)
+    {
 …
   };
   /// Default traits class used by \ref BfsWizard
+  /// Default traits class used by BfsWizard
   /// To make it easier to use Bfs algorithm
 …
     };
     ///\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)
 …
     };
     ///\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)
 …
     };
     ///\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)
 …
     };
     ///\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)
 …
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     /// \brief Instantiates a \ref ReachedMap.
     ///
     /// This function instantiates a \ref ReachedMap.
+    /// \brief Instantiates a 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

-                      r236
+                      r314
 #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>
 …
     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:
 …
       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()) {
 …
+      }
       /// \brief Destructor
+      // \brief Destructor
       virtual ~ObserverBase() {
         if (attached()) {
 …
+      }
+      /// \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; }
 …
       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;
 …
   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;
 …
+    }
     /// \brief Sets the container.
     ///
     /// Sets the container.
+    // \brief Sets the container.
+    //
+    // Sets the container.
     void setContainer(const Container& _container) {
       container = &_container;
 …
   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());
 …
   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;
 …
+    }
+    /// \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;
 …
+    }
+    /// \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();
 …
+    }
+    /// \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();
 …
+    }
     /// \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;
 …
+    }
     /// \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();

lemon/bits/array_map.h

-                      r263
+                      r314
 #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;
 …
   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()));
 …
+    }
     /// \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()));
 …
   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()) {
 …
+    }
     /// \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) {
 …
   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()) {
 …
   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);
 …
+    }
     /// \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);
 …
+    }
     /// \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();
 …
+    }
     /// \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();
 …
+    }
     /// \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);
 …
+    }
     /// \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) {
 …
+    }
     /// \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();
 …
+    }
     /// \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();

lemon/bits/base_extender.h

-                      r289
+                      r314
 #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 {
 …
     };
     /// 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; }

lemon/bits/bezier.h

-                      r209
+                      r314
 #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>

lemon/bits/default_map.h

-                      r209
+                      r314
 #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 {
 …
 // #endif
   /// \e
+  // DefaultMap class
   template <typename _Graph, typename _Item, typename _Value>
   class DefaultMap

lemon/bits/enable_if.h

-                      r220
+                      r314
 #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

-                      r263
+                      r314
 #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 {
 …
     };
     /// \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);
 …
   };
   /// \ingroup _graphbits
   ///
   /// \brief Extender for the Graphs
+  // \ingroup _graphbits
+  //
+  // \brief Extender for the Graphs
   template <typename Base>
   class GraphExtender : public Base {
 …
     };
     /// \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

-                      r263
+                      r314
 #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 {
 …
   };
   /// \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 {

lemon/bits/traits.h

-                      r220
+                      r314
 #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>

lemon/bits/vector_map.h

-                      r280
+                      r314
 #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
 …
   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()));
 …
+    }
     /// \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()));
 …
   private:
     /// \brief Copy constructor
     ///
     /// Copy constructor.
+    // \brief Copy constructor
+    //
+    // Copy constructor.
     VectorMap(const VectorMap& _copy) : Parent() {
       if (_copy.attached()) {
 …
+    }
     /// \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) {
 …
   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);
 …
+    }
     /// \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;
 …
+    }
     /// \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) {
 …
+    }
     /// \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;
 …
+    }
     /// \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

r209	r313
93	93	extern const Color DARK_CYAN;
94	94
95		///Map <tt>int</tt>s to different ~~\ref Color "Color"~~s
	95	///Map <tt>int</tt>s to different <tt>Color</tt>s
96	96
97	97	///This map assigns one of the predefined \ref Color "Color"s to

lemon/concepts/graph_components.h

r263	r313
983	983	///
984	984	/// This class describes the common interface of the graph maps
985		/// (NodeMap, ArcMap), that is ~~\ref maps-page "maps" which~~ can be used to
	985	/// (NodeMap, ArcMap), that is maps that can be used to
986	986	/// associate data to graph descriptors (nodes or arcs).
987	987	template <typename _Graph, typename _Item, typename _Value>

lemon/concepts/maps.h

-                      r220
+                      r314
 #include <lemon/concept_check.h>
 ///\ingroup concept
+///\ingroup map_concepts
 ///\file
 ///\brief The concept of maps.
 …
   namespace concepts {
     /// \addtogroup concept
+    /// \addtogroup map_concepts
     /// @{

lemon/core.h

-                      r282
+                      r313
   /// @{
   ///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
 …
   typedef Digraph::ArcMap<bool> BoolArcMap;                             \
   typedef Digraph::ArcMap<int> IntArcMap;                               \
   typedef Digraph::ArcMap<double> DoubleArcMap;
   ///Create convenient typedefs for the digraph types and iterators
+  typedef Digraph::ArcMap<double> DoubleArcMap
+  ///Create convenience typedefs for the digraph types and iterators
   ///\see DIGRAPH_TYPEDEFS
 …
   typedef typename Digraph::template ArcMap<bool> BoolArcMap;           \
   typedef typename Digraph::template ArcMap<int> IntArcMap;             \
   typedef typename Digraph::template ArcMap<double> DoubleArcMap;
   ///Create convenient typedefs for the graph types and iterators
+  typedef typename Digraph::template ArcMap<double> DoubleArcMap
+  ///Create convenience typedefs for the graph types and iterators
   ///This \c \#define creates the same convenient type definitions as defined
 …
   typedef Graph::EdgeMap<bool> BoolEdgeMap;                             \
   typedef Graph::EdgeMap<int> IntEdgeMap;                               \
   typedef Graph::EdgeMap<double> DoubleEdgeMap;
   ///Create convenient typedefs for the graph types and iterators
+  typedef Graph::EdgeMap<double> DoubleEdgeMap
+  ///Create convenience typedefs for the graph types and iterators
   ///\see GRAPH_TYPEDEFS
 …
   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.
 …
     ///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  {
 …
     ///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.
 …
     ///\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.
     ///

lemon/dfs.h

-                      r292
+                      r313
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a \ref PredMap.
     ///This function instantiates a \ref PredMap.
+    ///Instantiates a 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)
+    {
 …
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a \ref ProcessedMap.
     ///This function instantiates a \ref ProcessedMap.
+    ///Instantiates a 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)
 …
     ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a \ref ReachedMap.
     ///This function instantiates a \ref ReachedMap.
+    ///Instantiates a 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)
+    {
 …
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<int> DistMap;
     ///Instantiates a \ref DistMap.
     ///This function instantiates a \ref DistMap.
+    ///Instantiates a 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)
+    {
 …
     };
     ///\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> > {
 …
     };
     ///\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> > {
 …
     };
     ///\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> > {
 …
     };
     ///\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> > {
 …
     };
     ///\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 :
 …
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a \ref PredMap.
     ///This function instantiates a \ref PredMap.
+    ///Instantiates a 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)
+    {
 …
     ///By default it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a \ref ProcessedMap.
     ///This function instantiates a \ref ProcessedMap.
+    ///Instantiates a 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)
 …
     ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a \ref ReachedMap.
     ///This function instantiates a \ref ReachedMap.
+    ///Instantiates a 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)
+    {
 …
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<int> DistMap;
     ///Instantiates a \ref DistMap.
     ///This function instantiates a \ref DistMap.
+    ///Instantiates a 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)
+    {
 …
   };
   /// Default traits class used by \ref DfsWizard
+  /// Default traits class used by DfsWizard
   /// To make it easier to use Dfs algorithm
 …
     };
     ///\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)
 …
     };
     ///\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)
 …
     };
     ///\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)
 …
     };
     ///\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)
 …
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     /// \brief Instantiates a \ref ReachedMap.
     ///
     /// This function instantiates a \ref ReachedMap.
+    /// \brief Instantiates a 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

-                      r290
+                      r313
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a \ref PredMap.
     ///This function instantiates a \ref PredMap.
+    ///Instantiates a 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)
+    {
 …
     ///By default it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a \ref ProcessedMap.
     ///This function instantiates a \ref ProcessedMap.
+    ///Instantiates a 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)
 …
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename LM::Value> DistMap;
     ///Instantiates a \ref DistMap.
     ///This function instantiates a \ref DistMap.
+    ///Instantiates a 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)
+    {
 …
     };
     ///\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
 …
     };
     ///\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
 …
     };
     ///\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
 …
     };
     ///\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
 …
     /// \brief \ref named-templ-param "Named parameter" for setting
     ///\ref OperationTraits type
+    ///\c OperationTraits type
     ///
     ///\ref named-templ-param "Named parameter" for setting
 …
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a \ref PredMap.
     ///This function instantiates a \ref PredMap.
+    ///Instantiates a 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)
+    {
 …
     ///By default it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a \ref ProcessedMap.
     ///This function instantiates a \ref ProcessedMap.
+    ///Instantiates a 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)
 …
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename LM::Value> DistMap;
     ///Instantiates a \ref DistMap.
     ///This function instantiates a \ref DistMap.
+    ///Instantiates a 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)
+    {
 …
   };
   /// Default traits class used by \ref DijkstraWizard
+  /// Default traits class used by DijkstraWizard
   /// To make it easier to use Dijkstra algorithm
 …
     };
     ///\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)
 …
     };
     ///\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)
 …
     };
     ///\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)

lemon/dim2.h

-                      r253
+                      r314
   /// 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 {
 …
+  }
+  ///Map of x-coordinates of a \ref Point "Point"-map
+  ///\ingroup maps
+  ///Map of x-coordinates of a <tt>Point</tt>-map
   ///Map of x-coordinates of a \ref Point "Point"-map.
   ///
 …
   };
+  ///Returns an \ref XMap class
+  ///This function just returns an \ref XMap class.
+  ///
+  ///\ingroup maps
+  ///Returns an XMap class
+  ///This function just returns an XMap class.
   ///\relates XMap
   template<class M>
 …
+  }
+  ///Constant (read only) version of \ref XMap
+  ///\ingroup maps
+  ///Constant (read only) version of \ref XMap
+  ///Constant (read only) version of XMap
+  ///Constant (read only) version of XMap.
   ///
   template<class M>
 …
   };
+  ///Returns a \ref ConstXMap class
+  ///This function just returns a \ref ConstXMap class.
+  ///
+  ///\ingroup maps
+  ///Returns a ConstXMap class
+  ///This function just returns a ConstXMap class.
   ///\relates ConstXMap
   template<class M>
 …
+  }
+  ///Map of y-coordinates of a \ref Point "Point"-map
+  ///\ingroup maps
+  ///Map of y-coordinates of a <tt>Point</tt>-map
   ///Map of y-coordinates of a \ref Point "Point"-map.
   ///
 …
   };
+  ///Returns a \ref YMap class
+  ///This function just returns a \ref YMap class.
+  ///
+  ///\ingroup maps
+  ///Returns a YMap class
+  ///This function just returns a YMap class.
   ///\relates YMap
   template<class M>
 …
+  }
+  ///Constant (read only) version of \ref YMap
+  ///\ingroup maps
+  ///Constant (read only) version of \ref YMap
+  ///Constant (read only) version of YMap
+  ///Constant (read only) version of YMap.
   ///
   template<class M>
 …
   };
+  ///Returns a \ref ConstYMap class
+  ///This function just returns a \ref ConstYMap class.
+  ///
+  ///\ingroup maps
+  ///Returns a ConstYMap class
+  ///This function just returns a ConstYMap class.
   ///\relates ConstYMap
   template<class 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
 …
   };
+  ///Returns a \ref NormSquareMap class
+  ///This function just returns a \ref NormSquareMap class.
+  ///
+  ///\ingroup maps
+  ///Returns a NormSquareMap class
+  ///This function just returns a NormSquareMap class.
   ///\relates NormSquareMap
   template<class M>

lemon/graph_to_eps.h

r291	r313
63	63	}
64	64
65		///Default traits class of ~~\ref~~ GraphToEps
	65	///Default traits class of GraphToEps
66	66
67	67	///Default traits class of \ref GraphToEps.

lemon/lgf_reader.h

-                      r295
+                      r303
   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 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 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;

lemon/lgf_writer.h

-                      r295
+                      r303
   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 Return a \ref DigraphWriter class
+  ///
+  /// This function just returns a \ref DigraphWriter class.
+  /// \relates DigraphWriter
+  template <typename Digraph>
+  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
+                                       std::ostream& os = std::cout) {
+    DigraphWriter<Digraph> tmp(digraph, os);
+  template <typename Graph>
+  class GraphWriter;
+  /// \brief Return a \ref GraphWriter class
+  ///
+  /// This function just returns a \ref GraphWriter class.
+  /// \relates GraphWriter
+  template <typename Graph>
+  GraphWriter<Graph> graphWriter(const Graph& graph,
+                                 std::ostream& os = std::cout) {
+    GraphWriter<Graph> tmp(graph, os);
     return tmp;
+  }
+  /// \brief Return a \ref DigraphWriter class
+  ///
+  /// This function just returns a \ref DigraphWriter class.
+  /// \relates DigraphWriter
+  template <typename Digraph>
+  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
+                                       const std::string& fn) {
+    DigraphWriter<Digraph> tmp(digraph, fn);
+  /// \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 DigraphWriter class
+  ///
+  /// This function just returns a \ref DigraphWriter class.
+  /// \relates DigraphWriter
+  template <typename Digraph>
+  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
+                                       const char* fn) {
+    DigraphWriter<Digraph> tmp(digraph, fn);
+  /// \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;
+  }
-  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 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;

lemon/list_graph.h

r280	r313
414	414	///
415	415	///\note The <tt>InArcIt</tt>s referencing the changed arc remain
416		///valid. However the <tt>ArcIt<tt>s and <tt>OutArcIt</tt>s are
	416	///valid. However the <tt>ArcIt</tt>s and <tt>OutArcIt</tt>s are
417	417	///invalidated.
418	418	///

lemon/maps.h

-                      r324
+                      r327
   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.
 …
   };
   /// Returns a \ref NullMap class
   /// This function just returns a \ref NullMap class.
+  /// Returns a \c NullMap class
+  /// This function just returns a \c NullMap class.
   /// \relates NullMap
   template <typename K, typename V>
 …
   /// 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.
 …
   };
   /// Returns a \ref ConstMap class
   /// This function just returns a \ref ConstMap class.
+  /// Returns a \c ConstMap class
+  /// This function just returns a \c ConstMap class.
   /// \relates ConstMap
   template<typename K, typename V>
 …
   /// 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.
 …
   };
   /// Returns a \ref ConstMap class with inlined constant value
   /// This function just returns a \ref ConstMap class with inlined
+  /// Returns a \c ConstMap class with inlined constant value
+  /// This function just returns a \c ConstMap class with inlined
   /// constant value.
   /// \relates ConstMap
 …
   };
   /// Returns an \ref IdentityMap class
   /// This function just returns an \ref IdentityMap class.
+  /// Returns an \c IdentityMap class
+  /// This function just returns an \c IdentityMap class.
   /// \relates IdentityMap
   template<typename T>
 …
   /// 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.
 …
       : _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)
 …
   };
   /// Returns a \ref RangeMap class
   /// This function just returns a \ref RangeMap class.
+  /// Returns a \c RangeMap class
+  /// This function just returns a \c RangeMap class.
   /// \relates RangeMap
   template<typename V>
 …
+  }
   /// \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
 …
       : _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)
 …
   };
   /// Returns a \ref SparseMap class
   /// This function just returns a \ref SparseMap class with specified
+  /// Returns a \c SparseMap class
+  /// This function just returns a \c SparseMap class with specified
   /// default value.
   /// \relates SparseMap
 …
+  }
   /// \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
 …
   };
   /// Returns a \ref ComposeMap class
   /// This function just returns a \ref ComposeMap class.
+  /// Returns a \c 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
 …
   };
   /// Returns a \ref CombineMap class
   /// This function just returns a \ref CombineMap class.
+  /// Returns a \c CombineMap class
+  /// This function just returns a \c CombineMap class.
   ///
   /// For example, if \c m1 and \c m2 are both maps with \c double
 …
   };
   /// Returns a \ref FunctorToMap class
   /// This function just returns a \ref FunctorToMap class.
+  /// Returns a \c FunctorToMap class
+  /// This function just returns a \c FunctorToMap class.
   ///
   /// This function is specialized for adaptable binary function
 …
   };
   /// Returns a \ref MapToFunctor class
   /// This function just returns a \ref MapToFunctor class.
+  /// Returns a \c MapToFunctor class
+  /// This function just returns a \c MapToFunctor class.
   /// \relates MapToFunctor
   template<typename M>
 …
   };
   /// Returns a \ref ConvertMap class
   /// This function just returns a \ref ConvertMap class.
+  /// Returns a \c ConvertMap class
+  /// This function just returns a \c ConvertMap class.
   /// \relates ConvertMap
   template<typename V, typename M>
 …
   };
   /// Returns a \ref ForkMap class
   /// This function just returns a \ref ForkMap class.
+  /// Returns a \c ForkMap class
+  /// This function just returns a \c ForkMap class.
   /// \relates ForkMap
   template <typename M1, typename M2>
 …
   };
   /// Returns an \ref AddMap class
   /// This function just returns an \ref AddMap class.
+  /// Returns an \c AddMap class
+  /// This function just returns an \c AddMap class.
   ///
   /// For example, if \c m1 and \c m2 are both maps with \c double
 …
   };
   /// Returns a \ref SubMap class
   /// This function just returns a \ref SubMap class.
+  /// Returns a \c SubMap class
+  /// This function just returns a \c SubMap class.
   ///
   /// For example, if \c m1 and \c m2 are both maps with \c double
 …
   };
   /// Returns a \ref MulMap class
   /// This function just returns a \ref MulMap class.
+  /// Returns a \c MulMap class
+  /// This function just returns a \c MulMap class.
   ///
   /// For example, if \c m1 and \c m2 are both maps with \c double
 …
   };
   /// Returns a \ref DivMap class
   /// This function just returns a \ref DivMap class.
+  /// Returns a \c DivMap class
+  /// This function just returns a \c DivMap class.
   ///
   /// For example, if \c m1 and \c m2 are both maps with \c double
 …
   };
   /// Returns a \ref ShiftMap class
   /// This function just returns a \ref ShiftMap class.
+  /// Returns a \c 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
 …
+  }
   /// Returns a \ref ShiftWriteMap class
   /// This function just returns a \ref ShiftWriteMap class.
+  /// Returns a \c 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
 …
   };
   /// Returns a \ref ScaleMap class
   /// This function just returns a \ref ScaleMap class.
+  /// Returns a \c 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
 …
+  }
   /// Returns a \ref ScaleWriteMap class
   /// This function just returns a \ref ScaleWriteMap class.
+  /// Returns a \c 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
 …
   };
   /// Returns a \ref NegMap class
   /// This function just returns a \ref NegMap class.
+  /// Returns a \c NegMap class
+  /// This function just returns a \c NegMap class.
   ///
   /// For example, if \c m is a map with \c double values, then
 …
+  }
   /// Returns a \ref NegWriteMap class
   /// This function just returns a \ref NegWriteMap class.
+  /// Returns a \c NegWriteMap class
+  /// This function just returns a \c NegWriteMap class.
   ///
   /// For example, if \c m is a map with \c double values, then
 …
   };
   /// Returns an \ref AbsMap class
   /// This function just returns an \ref AbsMap class.
+  /// Returns an \c AbsMap class
+  /// This function just returns an \c AbsMap class.
   ///
   /// For example, if \c m is a map with \c double values, then
 …
   };
   /// Returns a \ref TrueMap class
   /// This function just returns a \ref TrueMap class.
+  /// Returns a \c TrueMap class
+  /// This function just returns a \c TrueMap class.
   /// \relates TrueMap
   template<typename K>
 …
   };
   /// Returns a \ref FalseMap class
   /// This function just returns a \ref FalseMap class.
+  /// Returns a \c FalseMap class
+  /// This function just returns a \c FalseMap class.
   /// \relates FalseMap
   template<typename K>
 …
   };
   /// Returns an \ref AndMap class
   /// This function just returns an \ref AndMap class.
+  /// Returns an \c 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,
 …
   };
   /// Returns an \ref OrMap class
   /// This function just returns an \ref OrMap class.
+  /// Returns an \c 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,
 …
   };
   /// Returns a \ref NotMap class
   /// This function just returns a \ref NotMap class.
+  /// Returns a \c NotMap class
+  /// This function just returns a \c NotMap class.
   ///
   /// For example, if \c m is a map with \c bool values, then
 …
+  }
   /// Returns a \ref NotWriteMap class
   /// This function just returns a \ref NotWriteMap class.
+  /// Returns a \c NotWriteMap class
+  /// This function just returns a \c NotWriteMap class.
   ///
   /// For example, if \c m is a map with \c bool values, then
 …
   };
   /// Returns an \ref EqualMap class
   /// This function just returns an \ref EqualMap class.
+  /// Returns an \c 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
 …
   };
   /// Returns an \ref LessMap class
   /// This function just returns an \ref LessMap class.
+  /// Returns an \c 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
 …
+  }
+  /// @}
+  /// \addtogroup maps
+  /// @{
   /// \brief Writable bool map for logging each \c true assigned element
 …
   };
   /// Returns a \ref LoggerBoolMap class
   /// This function just returns a \ref LoggerBoolMap class.
+  /// Returns a \c LoggerBoolMap class
+  /// This function just returns a \c LoggerBoolMap class.
   ///
   /// The most important usage of it is storing certain nodes or arcs
 …
   /// \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
 …
     return LoggerBoolMap<Iterator>(it);
+  }
+  /// @}
+  /// \addtogroup graph_maps
+  /// @{
   /// Provides an immutable and unique id for each item in the graph.
 …
     ///
     /// 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 Returns a \ref SourceMap class.
   ///
   /// This function just returns an \ref SourceMap class.
+  /// \brief Returns a \c SourceMap class.
+  ///
+  /// This function just returns an \c SourceMap class.
   /// \relates SourceMap
   template <typename Digraph>
 …
     ///
     /// 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 Returns a \ref TargetMap class.
   ///
   /// This function just returns a \ref TargetMap class.
+  /// \brief Returns a \c TargetMap class.
+  ///
+  /// This function just returns a \c TargetMap class.
   /// \relates TargetMap
   template <typename Digraph>
 …
     ///
     /// 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 Returns a \ref ForwardMap class.
   ///
   /// This function just returns an \ref ForwardMap class.
+  /// \brief Returns a \c ForwardMap class.
+  ///
+  /// This function just returns an \c ForwardMap class.
   /// \relates ForwardMap
   template <typename Graph>
 …
     ///
     /// 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 Returns a \ref BackwardMap class
   /// This function just returns a \ref BackwardMap class.
+  /// \brief Returns a \c BackwardMap class
+  /// This function just returns a \c BackwardMap class.
   /// \relates BackwardMap
   template <typename Graph>

lemon/path.h

r236	r313
850	850	int empty() const { return len == 0; }
851	851
852		/// \br~~eak~~ Erase all arcs in the digraph.
	852	/// \brief Erase all arcs in the digraph.
853	853	void clear() {
854	854	len = 0;

lemon/smart_graph.h

-                      r280
+                      r313
       ///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();
 …
       ///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)
+      {
 …
       ///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);
 …
       ///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)
+      {

lemon/time_measure.h

-                      r280
+                      r314
     ///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.
-    ///
     ///@{
 …
   };
   ///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.
 …
     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()
+    {
 …
   };
   ///'Do nothing' version of \ref TimeReport
+  ///'Do nothing' version of TimeReport
   ///\sa TimeReport

tools/Makefile.am

r146	r310
2	2
3	3	bin_PROGRAMS +=
	4	dist_bin_SCRIPTS += tools/lemon-0.x-to-1.x.sh
4	5
5	6	endif WANT_TOOLS

Context Navigation

Changes in / [326:de38fca76780:327:12626fc94ccf] in lemon

Legend:

Download in other formats: