COIN-OR::LEMON - Graph Library

Changes in / [303:de38fca76780:320:12626fc94ccf] in lemon-1.0


Ignore:
Files:
2 added
1 deleted
38 edited

Legend:

Unmodified
Added
Removed
  • Makefile.am

    r227 r314  
    2525bin_PROGRAMS =
    2626check_PROGRAMS =
     27dist_bin_SCRIPTS =
    2728TESTS =
    2829XFAIL_TESTS =
     
    3233include doc/Makefile.am
    3334include demo/Makefile.am
    34 include benchmark/Makefile.am
    3535include tools/Makefile.am
    3636
  • README

    r246 r314  
    3838   Contains programs to check the integrity and correctness of LEMON.
    3939
    40 benchmark/
    41  
    42    Contains programs for measuring the performance of algorithms.
    43 
    4440tools/
    4541
  • configure.ac

    r296 r314  
    8282AM_CONDITIONAL([WANT_TOOLS], [test x"$enable_tools" != x"no"])
    8383
    84 dnl Disable/enable building the benchmarks.
    85 AC_ARG_ENABLE([benchmark],
    86 AS_HELP_STRING([--enable-benchmark], [build the benchmarks])
    87 AS_HELP_STRING([--disable-benchmark], [do not build the benchmarks @<:@default@:>@]),
    88               [], [enable_benchmark=no])
    89 AC_MSG_CHECKING([whether to build the benchmarks])
    90 if test x"$enable_benchmark" != x"no"; then
    91   AC_MSG_RESULT([yes])
    92 else
    93   AC_MSG_RESULT([no])
    94 fi
    95 AM_CONDITIONAL([WANT_BENCHMARK], [test x"$enable_benchmark" != x"no"])
    96 
    9784dnl Checks for header files.
    9885AC_CHECK_HEADERS(limits.h sys/time.h sys/times.h unistd.h)
     
    133120#echo SOPLEX support................ : $lx_soplex_found
    134121#echo
    135 echo Build benchmarks.............. : $enable_benchmark
    136122echo Build demo programs........... : $enable_demo
    137123echo Build additional tools........ : $enable_tools
  • demo/arg_parser_demo.cc

    r209 r315  
    2828
    2929using namespace lemon;
    30 int main(int argc, const char **argv)
     30int main(int argc, char **argv)
    3131{
    3232  // Initialize the argument parser
  • demo/graph_to_eps_demo.cc

    r220 r317  
    2727/// how to handle parallel egdes, how to change the properties (like
    2828/// color, shape, size, title etc.) of nodes and arcs individually
    29 /// using appropriate \ref maps-page "graph maps".
     29/// using appropriate graph maps.
    3030///
    3131/// \include graph_to_eps_demo.cc
  • doc/Makefile.am

    r270 r310  
    77        doc/license.dox \
    88        doc/mainpage.dox \
     9        doc/migration.dox \
    910        doc/named-param.dox \
    1011        doc/namespaces.dox \
  • doc/groups.dox

    r302 r320  
    4343You are free to use the graph structure that fit your requirements
    4444the best, most graph algorithms and auxiliary data structures can be used
    45 with any graph structures.
     45with any graph structure.
     46
     47<b>See also:</b> \ref graph_concepts "Graph Structure Concepts".
    4648*/
    4749
     
    5355This group describes the map structures implemented in LEMON.
    5456
    55 LEMON provides several special purpose maps that e.g. combine
     57LEMON provides several special purpose maps and map adaptors that e.g. combine
    5658new maps from existing ones.
     59
     60<b>See also:</b> \ref map_concepts "Map Concepts".
    5761*/
    5862
     
    6569values to the nodes and arcs of graphs.
    6670*/
    67 
    6871
    6972/**
     
    8386algorithms.  If a function type algorithm is called then the function
    8487type map adaptors can be used comfortable. For example let's see the
    85 usage of map adaptors with the \c digraphToEps() function.
     88usage of map adaptors with the \c graphToEps() function.
    8689\code
    8790  Color nodeColor(int deg) {
     
    97100  Digraph::NodeMap<int> degree_map(graph);
    98101
    99   digraphToEps(graph, "graph.eps")
     102  graphToEps(graph, "graph.eps")
    100103    .coords(coords).scaleToA4().undirected()
    101104    .nodeColors(composeMap(functorToMap(nodeColor), degree_map))
     
    103106\endcode
    104107The \c functorToMap() function makes an \c int to \c Color map from the
    105 \e nodeColor() function. The \c composeMap() compose the \e degree_map
     108\c nodeColor() function. The \c composeMap() compose the \c degree_map
    106109and the previously created map. The composed map is a proper function to
    107110get the color of each node.
     
    144147
    145148\sa lemon::concepts::Path
    146 
    147149*/
    148150
     
    156158*/
    157159
    158 
    159160/**
    160161@defgroup algs Algorithms
     
    172173
    173174This group describes the common graph search algorithms like
    174 Breadth-first search (Bfs) and Depth-first search (Dfs).
    175 */
    176 
    177 /**
    178 @defgroup shortest_path Shortest Path algorithms
     175Breadth-First Search (BFS) and Depth-First Search (DFS).
     176*/
     177
     178/**
     179@defgroup shortest_path Shortest Path Algorithms
    179180@ingroup algs
    180181\brief Algorithms for finding shortest paths.
     
    184185
    185186/**
    186 @defgroup spantree Minimum Spanning Tree algorithms
     187@defgroup spantree Minimum Spanning Tree Algorithms
    187188@ingroup algs
    188189\brief Algorithms for finding a minimum cost spanning tree in a graph.
     
    192193*/
    193194
     195@ingroup algs
    194196/**
    195197@defgroup utils Tools and Utilities
     
    217219
    218220/**
    219 @defgroup timecount Time measuring and Counting
     221@defgroup timecount Time Measuring and Counting
    220222@ingroup misc
    221223\brief Simple tools for measuring the performance of algorithms.
     
    240242and graph related data. Now it supports the LEMON format
    241243and the encapsulated postscript (EPS) format.
     244postscript (EPS) format.
    242245*/
    243246
     
    245248@defgroup lemon_io LEMON Input-Output
    246249@ingroup io_group
    247 \brief Reading and writing \ref lgf-format "LEMON Graph Format".
     250\brief Reading and writing LEMON Graph Format.
    248251
    249252This group describes methods for reading and writing
     
    252255
    253256/**
    254 @defgroup eps_io Postscript exporting
     257@defgroup eps_io Postscript Exporting
    255258@ingroup io_group
    256259\brief General \c EPS drawer and graph exporter
     
    259262graph exporting tools.
    260263*/
    261 
    262264
    263265/**
     
    288290
    289291- Finally, They can serve as a skeleton of a new implementation of a concept.
    290 
    291 */
    292 
     292*/
    293293
    294294/**
     
    301301*/
    302302
     303
     304This group describes the skeletons and concept checking classes of maps.
    303305/**
    304306\anchor demoprograms
  • doc/lgf.dox

    r236 r317  
    7979\endcode
    8080
    81 The \c \@edges is just a synonym of \c \@arcs. The @arcs section can
     81The \c \@edges is just a synonym of \c \@arcs. The \@arcs section can
    8282also store the edge set of an undirected graph. In such case there is
    8383a conventional method for store arc maps in the file, if two columns
  • doc/mainpage.dox

    r302 r320  
    4444If you
    4545want to see how LEMON works, see
    46 some \ref demoprograms "demo programs"!
     46some \ref demoprograms "demo programs".
    4747
    4848If you know what you are looking for then try to find it under the
     
    5050section.
    5151
    52 
     52If you are a user of the old (0.x) series of LEMON, please check out the
     53\ref migration "Migration Guide" for the backward incompatibilities.
    5354*/
  • lemon/arg_parser.cc

    r214 r315  
    2727  }
    2828
    29   ArgParser::ArgParser(int argc, const char **argv) :_argc(argc), _argv(argv),
    30                                                     _command_name(argv[0]) {
     29  ArgParser::ArgParser(int argc, const char * const *argv)
     30    :_argc(argc), _argv(argv), _command_name(argv[0]) {
    3131    funcOption("-help","Print a short help message",_showHelp,this);
    3232    synonym("help","-help");
    3333    synonym("h","-help");
    34 
    3534  }
    3635
  • lemon/arg_parser.h

    r290 r315  
    4747
    4848    int _argc;
    49     const char **_argv;
     49    const char * const *_argv;
    5050
    5151    enum OptType { UNKNOWN=0, BOOL=1, STRING=2, DOUBLE=3, INTEGER=4, FUNC=5 };
     
    120120
    121121    ///Constructor
    122     ArgParser(int argc, const char **argv);
     122    ArgParser(int argc, const char * const *argv);
    123123
    124124    ~ArgParser();
  • lemon/bfs.h

    r292 r305  
    5050    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    5151    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
    52     ///Instantiates a \ref PredMap.
    53 
    54     ///This function instantiates a \ref PredMap.
     52    ///Instantiates a PredMap.
     53
     54    ///This function instantiates a PredMap.
    5555    ///\param g is the digraph, to which we would like to define the
    56     ///\ref PredMap.
     56    ///PredMap.
    5757    static PredMap *createPredMap(const Digraph &g)
    5858    {
     
    6565    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    6666    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    67     ///Instantiates a \ref ProcessedMap.
    68 
    69     ///This function instantiates a \ref ProcessedMap.
     67    ///Instantiates a ProcessedMap.
     68
     69    ///This function instantiates a ProcessedMap.
    7070    ///\param g is the digraph, to which
    71     ///we would like to define the \ref ProcessedMap
     71    ///we would like to define the ProcessedMap
    7272#ifdef DOXYGEN
    7373    static ProcessedMap *createProcessedMap(const Digraph &g)
     
    8484    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
    8585    typedef typename Digraph::template NodeMap<bool> ReachedMap;
    86     ///Instantiates a \ref ReachedMap.
    87 
    88     ///This function instantiates a \ref ReachedMap.
     86    ///Instantiates a ReachedMap.
     87
     88    ///This function instantiates a ReachedMap.
    8989    ///\param g is the digraph, to which
    90     ///we would like to define the \ref ReachedMap.
     90    ///we would like to define the ReachedMap.
    9191    static ReachedMap *createReachedMap(const Digraph &g)
    9292    {
     
    9999    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    100100    typedef typename Digraph::template NodeMap<int> DistMap;
    101     ///Instantiates a \ref DistMap.
    102 
    103     ///This function instantiates a \ref DistMap.
     101    ///Instantiates a DistMap.
     102
     103    ///This function instantiates a DistMap.
    104104    ///\param g is the digraph, to which we would like to define the
    105     ///\ref DistMap.
     105    ///DistMap.
    106106    static DistMap *createDistMap(const Digraph &g)
    107107    {
     
    228228    };
    229229    ///\brief \ref named-templ-param "Named parameter" for setting
    230     ///\ref PredMap type.
     230    ///PredMap type.
    231231    ///
    232232    ///\ref named-templ-param "Named parameter" for setting
    233     ///\ref PredMap type.
     233    ///PredMap type.
    234234    template <class T>
    235235    struct SetPredMap : public Bfs< Digraph, SetPredMapTraits<T> > {
     
    247247    };
    248248    ///\brief \ref named-templ-param "Named parameter" for setting
    249     ///\ref DistMap type.
     249    ///DistMap type.
    250250    ///
    251251    ///\ref named-templ-param "Named parameter" for setting
    252     ///\ref DistMap type.
     252    ///DistMap type.
    253253    template <class T>
    254254    struct SetDistMap : public Bfs< Digraph, SetDistMapTraits<T> > {
     
    266266    };
    267267    ///\brief \ref named-templ-param "Named parameter" for setting
    268     ///\ref ReachedMap type.
     268    ///ReachedMap type.
    269269    ///
    270270    ///\ref named-templ-param "Named parameter" for setting
    271     ///\ref ReachedMap type.
     271    ///ReachedMap type.
    272272    template <class T>
    273273    struct SetReachedMap : public Bfs< Digraph, SetReachedMapTraits<T> > {
     
    285285    };
    286286    ///\brief \ref named-templ-param "Named parameter" for setting
    287     ///\ref ProcessedMap type.
     287    ///ProcessedMap type.
    288288    ///
    289289    ///\ref named-templ-param "Named parameter" for setting
    290     ///\ref ProcessedMap type.
     290    ///ProcessedMap type.
    291291    template <class T>
    292292    struct SetProcessedMap : public Bfs< Digraph, SetProcessedMapTraits<T> > {
     
    303303    };
    304304    ///\brief \ref named-templ-param "Named parameter" for setting
    305     ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     305    ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
    306306    ///
    307307    ///\ref named-templ-param "Named parameter" for setting
    308     ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     308    ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
    309309    ///If you don't set it explicitly, it will be automatically allocated.
    310310    struct SetStandardProcessedMap :
     
    836836    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    837837    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
    838     ///Instantiates a \ref PredMap.
    839 
    840     ///This function instantiates a \ref PredMap.
     838    ///Instantiates a PredMap.
     839
     840    ///This function instantiates a PredMap.
    841841    ///\param g is the digraph, to which we would like to define the
    842     ///\ref PredMap.
     842    ///PredMap.
    843843    static PredMap *createPredMap(const Digraph &g)
    844844    {
     
    852852    ///By default it is a NullMap.
    853853    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    854     ///Instantiates a \ref ProcessedMap.
    855 
    856     ///This function instantiates a \ref ProcessedMap.
     854    ///Instantiates a ProcessedMap.
     855
     856    ///This function instantiates a ProcessedMap.
    857857    ///\param g is the digraph, to which
    858     ///we would like to define the \ref ProcessedMap.
     858    ///we would like to define the ProcessedMap.
    859859#ifdef DOXYGEN
    860860    static ProcessedMap *createProcessedMap(const Digraph &g)
     
    871871    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
    872872    typedef typename Digraph::template NodeMap<bool> ReachedMap;
    873     ///Instantiates a \ref ReachedMap.
    874 
    875     ///This function instantiates a \ref ReachedMap.
     873    ///Instantiates a ReachedMap.
     874
     875    ///This function instantiates a ReachedMap.
    876876    ///\param g is the digraph, to which
    877     ///we would like to define the \ref ReachedMap.
     877    ///we would like to define the ReachedMap.
    878878    static ReachedMap *createReachedMap(const Digraph &g)
    879879    {
     
    886886    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    887887    typedef typename Digraph::template NodeMap<int> DistMap;
    888     ///Instantiates a \ref DistMap.
    889 
    890     ///This function instantiates a \ref DistMap.
     888    ///Instantiates a DistMap.
     889
     890    ///This function instantiates a DistMap.
    891891    ///\param g is the digraph, to which we would like to define
    892     ///the \ref DistMap
     892    ///the DistMap
    893893    static DistMap *createDistMap(const Digraph &g)
    894894    {
     
    903903  };
    904904
    905   /// Default traits class used by \ref BfsWizard
     905  /// Default traits class used by BfsWizard
    906906
    907907  /// To make it easier to use Bfs algorithm
     
    10691069    };
    10701070    ///\brief \ref named-func-param "Named parameter"
    1071     ///for setting \ref PredMap object.
     1071    ///for setting PredMap object.
    10721072    ///
    10731073    ///\ref named-func-param "Named parameter"
    1074     ///for setting \ref PredMap object.
     1074    ///for setting PredMap object.
    10751075    template<class T>
    10761076    BfsWizard<SetPredMapBase<T> > predMap(const T &t)
     
    10871087    };
    10881088    ///\brief \ref named-func-param "Named parameter"
    1089     ///for setting \ref ReachedMap object.
     1089    ///for setting ReachedMap object.
    10901090    ///
    10911091    /// \ref named-func-param "Named parameter"
    1092     ///for setting \ref ReachedMap object.
     1092    ///for setting ReachedMap object.
    10931093    template<class T>
    10941094    BfsWizard<SetReachedMapBase<T> > reachedMap(const T &t)
     
    11051105    };
    11061106    ///\brief \ref named-func-param "Named parameter"
    1107     ///for setting \ref DistMap object.
     1107    ///for setting DistMap object.
    11081108    ///
    11091109    /// \ref named-func-param "Named parameter"
    1110     ///for setting \ref DistMap object.
     1110    ///for setting DistMap object.
    11111111    template<class T>
    11121112    BfsWizard<SetDistMapBase<T> > distMap(const T &t)
     
    11231123    };
    11241124    ///\brief \ref named-func-param "Named parameter"
    1125     ///for setting \ref ProcessedMap object.
     1125    ///for setting ProcessedMap object.
    11261126    ///
    11271127    /// \ref named-func-param "Named parameter"
    1128     ///for setting \ref ProcessedMap object.
     1128    ///for setting ProcessedMap object.
    11291129    template<class T>
    11301130    BfsWizard<SetProcessedMapBase<T> > processedMap(const T &t)
     
    12681268    typedef typename Digraph::template NodeMap<bool> ReachedMap;
    12691269
    1270     /// \brief Instantiates a \ref ReachedMap.
    1271     ///
    1272     /// This function instantiates a \ref ReachedMap.
     1270    /// \brief Instantiates a ReachedMap.
     1271    ///
     1272    /// This function instantiates a ReachedMap.
    12731273    /// \param digraph is the digraph, to which
    1274     /// we would like to define the \ref ReachedMap.
     1274    /// we would like to define the ReachedMap.
    12751275    static ReachedMap *createReachedMap(const Digraph &digraph) {
    12761276      return new ReachedMap(digraph);
  • lemon/bits/alteration_notifier.h

    r236 r318  
    2525#include <lemon/core.h>
    2626
    27 ///\ingroup graphbits
    28 ///\file
    29 ///\brief Observer notifier for graph alteration observers.
     27//\ingroup graphbits
     28//\file
     29//\brief Observer notifier for graph alteration observers.
    3030
    3131namespace lemon {
    3232
    33   /// \ingroup graphbits
    34   ///
    35   /// \brief Notifier class to notify observes about alterations in
    36   /// a container.
    37   ///
    38   /// The simple graph's can be refered as two containers, one node container
    39   /// and one edge container. But they are not standard containers they
    40   /// does not store values directly they are just key continars for more
    41   /// value containers which are the node and edge maps.
    42   ///
    43   /// The graph's node and edge sets can be changed as we add or erase
    44   /// nodes and edges in the graph. LEMON would like to handle easily
    45   /// that the node and edge maps should contain values for all nodes or
    46   /// edges. If we want to check on every indicing if the map contains
    47   /// the current indicing key that cause a drawback in the performance
    48   /// in the library. We use another solution we notify all maps about
    49   /// an alteration in the graph, which cause only drawback on the
    50   /// alteration of the graph.
    51   ///
    52   /// This class provides an interface to the container. The \e first() and \e
    53   /// next() member functions make possible to iterate on the keys of the
    54   /// container. The \e id() function returns an integer id for each key.
    55   /// The \e maxId() function gives back an upper bound of the ids.
    56   ///
    57   /// For the proper functonality of this class, we should notify it
    58   /// about each alteration in the container. The alterations have four type
    59   /// as \e add(), \e erase(), \e build() and \e clear(). The \e add() and
    60   /// \e erase() signals that only one or few items added or erased to or
    61   /// from the graph. If all items are erased from the graph or from an empty
    62   /// graph a new graph is builded then it can be signaled with the
    63   /// clear() and build() members. Important rule that if we erase items
    64   /// from graph we should first signal the alteration and after that erase
    65   /// them from the container, on the other way on item addition we should
    66   /// first extend the container and just after that signal the alteration.
    67   ///
    68   /// The alteration can be observed with a class inherited from the
    69   /// \e ObserverBase nested class. The signals can be handled with
    70   /// overriding the virtual functions defined in the base class.  The
    71   /// observer base can be attached to the notifier with the
    72   /// \e attach() member and can be detached with detach() function. The
    73   /// alteration handlers should not call any function which signals
    74   /// an other alteration in the same notifier and should not
    75   /// detach any observer from the notifier.
    76   ///
    77   /// Alteration observers try to be exception safe. If an \e add() or
    78   /// a \e clear() function throws an exception then the remaining
    79   /// observeres will not be notified and the fulfilled additions will
    80   /// be rolled back by calling the \e erase() or \e clear()
    81   /// functions. Thence the \e erase() and \e clear() should not throw
    82   /// exception. Actullay, it can be throw only
    83   /// \ref AlterationObserver::ImmediateDetach ImmediateDetach
    84   /// exception which detach the observer from the notifier.
    85   ///
    86   /// There are some place when the alteration observing is not completly
    87   /// reliable. If we want to carry out the node degree in the graph
    88   /// as in the \ref InDegMap and we use the reverseEdge that cause
    89   /// unreliable functionality. Because the alteration observing signals
    90   /// only erasing and adding but not the reversing it will stores bad
    91   /// degrees. The sub graph adaptors cannot signal the alterations because
    92   /// just a setting in the filter map can modify the graph and this cannot
    93   /// be watched in any way.
    94   ///
    95   /// \param _Container The container which is observed.
    96   /// \param _Item The item type which is obserbved.
     33  // \ingroup graphbits
     34  //
     35  // \brief Notifier class to notify observes about alterations in
     36  // a container.
     37  //
     38  // The simple graph's can be refered as two containers, one node container
     39  // and one edge container. But they are not standard containers they
     40  // does not store values directly they are just key continars for more
     41  // value containers which are the node and edge maps.
     42  //
     43  // The graph's node and edge sets can be changed as we add or erase
     44  // nodes and edges in the graph. LEMON would like to handle easily
     45  // that the node and edge maps should contain values for all nodes or
     46  // edges. If we want to check on every indicing if the map contains
     47  // the current indicing key that cause a drawback in the performance
     48  // in the library. We use another solution we notify all maps about
     49  // an alteration in the graph, which cause only drawback on the
     50  // alteration of the graph.
     51  //
     52  // This class provides an interface to the container. The \e first() and \e
     53  // next() member functions make possible to iterate on the keys of the
     54  // container. The \e id() function returns an integer id for each key.
     55  // The \e maxId() function gives back an upper bound of the ids.
     56  //
     57  // For the proper functonality of this class, we should notify it
     58  // about each alteration in the container. The alterations have four type
     59  // as \e add(), \e erase(), \e build() and \e clear(). The \e add() and
     60  // \e erase() signals that only one or few items added or erased to or
     61  // from the graph. If all items are erased from the graph or from an empty
     62  // graph a new graph is builded then it can be signaled with the
     63  // clear() and build() members. Important rule that if we erase items
     64  // from graph we should first signal the alteration and after that erase
     65  // them from the container, on the other way on item addition we should
     66  // first extend the container and just after that signal the alteration.
     67  //
     68  // The alteration can be observed with a class inherited from the
     69  // \e ObserverBase nested class. The signals can be handled with
     70  // overriding the virtual functions defined in the base class.  The
     71  // observer base can be attached to the notifier with the
     72  // \e attach() member and can be detached with detach() function. The
     73  // alteration handlers should not call any function which signals
     74  // an other alteration in the same notifier and should not
     75  // detach any observer from the notifier.
     76  //
     77  // Alteration observers try to be exception safe. If an \e add() or
     78  // a \e clear() function throws an exception then the remaining
     79  // observeres will not be notified and the fulfilled additions will
     80  // be rolled back by calling the \e erase() or \e clear()
     81  // functions. Thence the \e erase() and \e clear() should not throw
     82  // exception. Actullay, it can be throw only \ref ImmediateDetach
     83  // exception which detach the observer from the notifier.
     84  //
     85  // There are some place when the alteration observing is not completly
     86  // reliable. If we want to carry out the node degree in the graph
     87  // as in the \ref InDegMap and we use the reverseEdge that cause
     88  // unreliable functionality. Because the alteration observing signals
     89  // only erasing and adding but not the reversing it will stores bad
     90  // degrees. The sub graph adaptors cannot signal the alterations because
     91  // just a setting in the filter map can modify the graph and this cannot
     92  // be watched in any way.
     93  //
     94  // \param _Container The container which is observed.
     95  // \param _Item The item type which is obserbved.
    9796
    9897  template <typename _Container, typename _Item>
     
    105104    typedef _Item Item;
    106105
    107     /// \brief Exception which can be called from \e clear() and
    108     /// \e erase().
    109     ///
    110     /// From the \e clear() and \e erase() function only this
    111     /// exception is allowed to throw. The exception immediatly
    112     /// detaches the current observer from the notifier. Because the
    113     /// \e clear() and \e erase() should not throw other exceptions
    114     /// it can be used to invalidate the observer.
     106    // \brief Exception which can be called from \e clear() and
     107    // \e erase().
     108    //
     109    // From the \e clear() and \e erase() function only this
     110    // exception is allowed to throw. The exception immediatly
     111    // detaches the current observer from the notifier. Because the
     112    // \e clear() and \e erase() should not throw other exceptions
     113    // it can be used to invalidate the observer.
    115114    struct ImmediateDetach {};
    116115
    117     /// \brief ObserverBase is the base class for the observers.
    118     ///
    119     /// ObserverBase is the abstract base class for the observers.
    120     /// It will be notified about an item was inserted into or
    121     /// erased from the graph.
    122     ///
    123     /// The observer interface contains some pure virtual functions
    124     /// to override. The add() and erase() functions are
    125     /// to notify the oberver when one item is added or
    126     /// erased.
    127     ///
    128     /// The build() and clear() members are to notify the observer
    129     /// about the container is built from an empty container or
    130     /// is cleared to an empty container.
    131 
     116    // \brief ObserverBase is the base class for the observers.
     117    //
     118    // ObserverBase is the abstract base class for the observers.
     119    // It will be notified about an item was inserted into or
     120    // erased from the graph.
     121    //
     122    // The observer interface contains some pure virtual functions
     123    // to override. The add() and erase() functions are
     124    // to notify the oberver when one item is added or
     125    // erased.
     126    //
     127    // The build() and clear() members are to notify the observer
     128    // about the container is built from an empty container or
     129    // is cleared to an empty container.
    132130    class ObserverBase {
    133131    protected:
     
    136134      friend class AlterationNotifier;
    137135
    138       /// \brief Default constructor.
    139       ///
    140       /// Default constructor for ObserverBase.
    141       ///
     136      // \brief Default constructor.
     137      //
     138      // Default constructor for ObserverBase.
    142139      ObserverBase() : _notifier(0) {}
    143140
    144       /// \brief Constructor which attach the observer into notifier.
    145       ///
    146       /// Constructor which attach the observer into notifier.
     141      // \brief Constructor which attach the observer into notifier.
     142      //
     143      // Constructor which attach the observer into notifier.
    147144      ObserverBase(AlterationNotifier& nf) {
    148145        attach(nf);
    149146      }
    150147
    151       /// \brief Constructor which attach the obserever to the same notifier.
    152       ///
    153       /// Constructor which attach the obserever to the same notifier as
    154       /// the other observer is attached to.
     148      // \brief Constructor which attach the obserever to the same notifier.
     149      //
     150      // Constructor which attach the obserever to the same notifier as
     151      // the other observer is attached to.
    155152      ObserverBase(const ObserverBase& copy) {
    156153        if (copy.attached()) {
     
    159156      }
    160157
    161       /// \brief Destructor
     158      // \brief Destructor
    162159      virtual ~ObserverBase() {
    163160        if (attached()) {
     
    166163      }
    167164
    168       /// \brief Attaches the observer into an AlterationNotifier.
    169       ///
    170       /// This member attaches the observer into an AlterationNotifier.
    171       ///
     165      // \brief Attaches the observer into an AlterationNotifier.
     166      //
     167      // This member attaches the observer into an AlterationNotifier.
    172168      void attach(AlterationNotifier& nf) {
    173169        nf.attach(*this);
    174170      }
    175171
    176       /// \brief Detaches the observer into an AlterationNotifier.
    177       ///
    178       /// This member detaches the observer from an AlterationNotifier.
    179       ///
     172      // \brief Detaches the observer into an AlterationNotifier.
     173      //
     174      // This member detaches the observer from an AlterationNotifier.
    180175      void detach() {
    181176        _notifier->detach(*this);
    182177      }
    183178
    184       /// \brief Gives back a pointer to the notifier which the map
    185       /// attached into.
    186       ///
    187       /// This function gives back a pointer to the notifier which the map
    188       /// attached into.
    189       ///
     179      // \brief Gives back a pointer to the notifier which the map
     180      // attached into.
     181      //
     182      // This function gives back a pointer to the notifier which the map
     183      // attached into.
    190184      Notifier* notifier() const { return const_cast<Notifier*>(_notifier); }
    191185
    192       /// Gives back true when the observer is attached into a notifier.
     186      // Gives back true when the observer is attached into a notifier.
    193187      bool attached() const { return _notifier != 0; }
    194188
     
    202196      typename std::list<ObserverBase*>::iterator _index;
    203197
    204       /// \brief The member function to notificate the observer about an
    205       /// item is added to the container.
    206       ///
    207       /// The add() member function notificates the observer about an item
    208       /// is added to the container. It have to be overrided in the
    209       /// subclasses.
     198      // \brief The member function to notificate the observer about an
     199      // item is added to the container.
     200      //
     201      // The add() member function notificates the observer about an item
     202      // is added to the container. It have to be overrided in the
     203      // subclasses.
    210204      virtual void add(const Item&) = 0;
    211205
    212       /// \brief The member function to notificate the observer about
    213       /// more item is added to the container.
    214       ///
    215       /// The add() member function notificates the observer about more item
    216       /// is added to the container. It have to be overrided in the
    217       /// subclasses.
     206      // \brief The member function to notificate the observer about
     207      // more item is added to the container.
     208      //
     209      // The add() member function notificates the observer about more item
     210      // is added to the container. It have to be overrided in the
     211      // subclasses.
    218212      virtual void add(const std::vector<Item>& items) = 0;
    219213
    220       /// \brief The member function to notificate the observer about an
    221       /// item is erased from the container.
    222       ///
    223       /// The erase() member function notificates the observer about an
    224       /// item is erased from the container. It have to be overrided in
    225       /// the subclasses.
     214      // \brief The member function to notificate the observer about an
     215      // item is erased from the container.
     216      //
     217      // The erase() member function notificates the observer about an
     218      // item is erased from the container. It have to be overrided in
     219      // the subclasses.
    226220      virtual void erase(const Item&) = 0;
    227221
    228       /// \brief The member function to notificate the observer about
    229       /// more item is erased from the container.
    230       ///
    231       /// The erase() member function notificates the observer about more item
    232       /// is erased from the container. It have to be overrided in the
    233       /// subclasses.
     222      // \brief The member function to notificate the observer about
     223      // more item is erased from the container.
     224      //
     225      // The erase() member function notificates the observer about more item
     226      // is erased from the container. It have to be overrided in the
     227      // subclasses.
    234228      virtual void erase(const std::vector<Item>& items) = 0;
    235229
    236       /// \brief The member function to notificate the observer about the
    237       /// container is built.
    238       ///
    239       /// The build() member function notificates the observer about the
    240       /// container is built from an empty container. It have to be
    241       /// overrided in the subclasses.
    242 
     230      // \brief The member function to notificate the observer about the
     231      // container is built.
     232      //
     233      // The build() member function notificates the observer about the
     234      // container is built from an empty container. It have to be
     235      // overrided in the subclasses.
    243236      virtual void build() = 0;
    244237
    245       /// \brief The member function to notificate the observer about all
    246       /// items are erased from the container.
    247       ///
    248       /// The clear() member function notificates the observer about all
    249       /// items are erased from the container. It have to be overrided in
    250       /// the subclasses.
     238      // \brief The member function to notificate the observer about all
     239      // items are erased from the container.
     240      //
     241      // The clear() member function notificates the observer about all
     242      // items are erased from the container. It have to be overrided in
     243      // the subclasses.
    251244      virtual void clear() = 0;
    252245
     
    263256  public:
    264257
    265     /// \brief Default constructor.
    266     ///
    267     /// The default constructor of the AlterationNotifier.
    268     /// It creates an empty notifier.
     258    // \brief Default constructor.
     259    //
     260    // The default constructor of the AlterationNotifier.
     261    // It creates an empty notifier.
    269262    AlterationNotifier()
    270263      : container(0) {}
    271264
    272     /// \brief Constructor.
    273     ///
    274     /// Constructor with the observed container parameter.
     265    // \brief Constructor.
     266    //
     267    // Constructor with the observed container parameter.
    275268    AlterationNotifier(const Container& _container)
    276269      : container(&_container) {}
    277270
    278     /// \brief Copy Constructor of the AlterationNotifier.
    279     ///
    280     /// Copy constructor of the AlterationNotifier.
    281     /// It creates only an empty notifier because the copiable
    282     /// notifier's observers have to be registered still into that notifier.
     271    // \brief Copy Constructor of the AlterationNotifier.
     272    //
     273    // Copy constructor of the AlterationNotifier.
     274    // It creates only an empty notifier because the copiable
     275    // notifier's observers have to be registered still into that notifier.
    283276    AlterationNotifier(const AlterationNotifier& _notifier)
    284277      : container(_notifier.container) {}
    285278
    286     /// \brief Destructor.
    287     ///
    288     /// Destructor of the AlterationNotifier.
    289     ///
     279    // \brief Destructor.
     280    //
     281    // Destructor of the AlterationNotifier.
    290282    ~AlterationNotifier() {
    291283      typename Observers::iterator it;
     
    295287    }
    296288
    297     /// \brief Sets the container.
    298     ///
    299     /// Sets the container.
     289    // \brief Sets the container.
     290    //
     291    // Sets the container.
    300292    void setContainer(const Container& _container) {
    301293      container = &_container;
     
    308300  public:
    309301
    310 
    311 
    312     /// \brief First item in the container.
    313     ///
    314     /// Returns the first item in the container. It is
    315     /// for start the iteration on the container.
     302    // \brief First item in the container.
     303    //
     304    // Returns the first item in the container. It is
     305    // for start the iteration on the container.
    316306    void first(Item& item) const {
    317307      container->first(item);
    318308    }
    319309
    320     /// \brief Next item in the container.
    321     ///
    322     /// Returns the next item in the container. It is
    323     /// for iterate on the container.
     310    // \brief Next item in the container.
     311    //
     312    // Returns the next item in the container. It is
     313    // for iterate on the container.
    324314    void next(Item& item) const {
    325315      container->next(item);
    326316    }
    327317
    328     /// \brief Returns the id of the item.
    329     ///
    330     /// Returns the id of the item provided by the container.
     318    // \brief Returns the id of the item.
     319    //
     320    // Returns the id of the item provided by the container.
    331321    int id(const Item& item) const {
    332322      return container->id(item);
    333323    }
    334324
    335     /// \brief Returns the maximum id of the container.
    336     ///
    337     /// Returns the maximum id of the container.
     325    // \brief Returns the maximum id of the container.
     326    //
     327    // Returns the maximum id of the container.
    338328    int maxId() const {
    339329      return container->maxId(Item());
     
    355345  public:
    356346
    357     /// \brief Notifies all the registed observers about an item added to
    358     /// the container.
    359     ///
    360     /// It notifies all the registed observers about an item added to
    361     /// the container.
    362     ///
     347    // \brief Notifies all the registed observers about an item added to
     348    // the container.
     349    //
     350    // It notifies all the registed observers about an item added to
     351    // the container.
    363352    void add(const Item& item) {
    364353      typename Observers::reverse_iterator it;
     
    376365    }
    377366
    378     /// \brief Notifies all the registed observers about more item added to
    379     /// the container.
    380     ///
    381     /// It notifies all the registed observers about more item added to
    382     /// the container.
    383     ///
     367    // \brief Notifies all the registed observers about more item added to
     368    // the container.
     369    //
     370    // It notifies all the registed observers about more item added to
     371    // the container.
    384372    void add(const std::vector<Item>& items) {
    385373      typename Observers::reverse_iterator it;
     
    397385    }
    398386
    399     /// \brief Notifies all the registed observers about an item erased from
    400     /// the container.
    401     ///
    402     /// It notifies all the registed observers about an item erased from
    403     /// the container.
    404     ///
     387    // \brief Notifies all the registed observers about an item erased from
     388    // the container.
     389    //
     390    // It notifies all the registed observers about an item erased from
     391    // the container.
    405392    void erase(const Item& item) throw() {
    406393      typename Observers::iterator it = _observers.begin();
     
    417404    }
    418405
    419     /// \brief Notifies all the registed observers about more item erased
    420     /// from the container.
    421     ///
    422     /// It notifies all the registed observers about more item erased from
    423     /// the container.
    424     ///
     406    // \brief Notifies all the registed observers about more item erased
     407    // from the container.
     408    //
     409    // It notifies all the registed observers about more item erased from
     410    // the container.
    425411    void erase(const std::vector<Item>& items) {
    426412      typename Observers::iterator it = _observers.begin();
     
    437423    }
    438424
    439     /// \brief Notifies all the registed observers about the container is
    440     /// built.
    441     ///
    442     /// Notifies all the registed observers about the container is built
    443     /// from an empty container.
     425    // \brief Notifies all the registed observers about the container is
     426    // built.
     427    //
     428    // Notifies all the registed observers about the container is built
     429    // from an empty container.
    444430    void build() {
    445431      typename Observers::reverse_iterator it;
     
    457443    }
    458444
    459     /// \brief Notifies all the registed observers about all items are
    460     /// erased.
    461     ///
    462     /// Notifies all the registed observers about all items are erased
    463     /// from the container.
     445    // \brief Notifies all the registed observers about all items are
     446    // erased.
     447    //
     448    // Notifies all the registed observers about all items are erased
     449    // from the container.
    464450    void clear() {
    465451      typename Observers::iterator it = _observers.begin();
  • lemon/bits/array_map.h

    r263 r318  
    2727#include <lemon/concepts/maps.h>
    2828
    29 /// \ingroup graphbits
    30 /// \file
    31 /// \brief Graph map based on the array storage.
     29// \ingroup graphbits
     30// \file
     31// \brief Graph map based on the array storage.
    3232
    3333namespace lemon {
    3434
    35   /// \ingroup graphbits
    36   ///
    37   /// \brief Graph map based on the array storage.
    38   ///
    39   /// The ArrayMap template class is graph map structure what
    40   /// automatically updates the map when a key is added to or erased from
    41   /// the map. This map uses the allocators to implement
    42   /// the container functionality.
    43   ///
    44   /// The template parameters are the Graph the current Item type and
    45   /// the Value type of the map.
     35  // \ingroup graphbits
     36  //
     37  // \brief Graph map based on the array storage.
     38  //
     39  // The ArrayMap template class is graph map structure what
     40  // automatically updates the map when a key is added to or erased from
     41  // the map. This map uses the allocators to implement
     42  // the container functionality.
     43  //
     44  // The template parameters are the Graph the current Item type and
     45  // the Value type of the map.
    4646  template <typename _Graph, typename _Item, typename _Value>
    4747  class ArrayMap
    4848    : public ItemSetTraits<_Graph, _Item>::ItemNotifier::ObserverBase {
    4949  public:
    50     /// The graph type of the maps.
     50    // The graph type of the maps.
    5151    typedef _Graph Graph;
    52     /// The item type of the map.
     52    // The item type of the map.
    5353    typedef _Item Item;
    54     /// The reference map tag.
     54    // The reference map tag.
    5555    typedef True ReferenceMapTag;
    5656
    57     /// The key type of the maps.
     57    // The key type of the maps.
    5858    typedef _Item Key;
    59     /// The value type of the map.
     59    // The value type of the map.
    6060    typedef _Value Value;
    6161
    62     /// The const reference type of the map.
     62    // The const reference type of the map.
    6363    typedef const _Value& ConstReference;
    64     /// The reference type of the map.
     64    // The reference type of the map.
    6565    typedef _Value& Reference;
    6666
    67     /// The notifier type.
     67    // The notifier type.
    6868    typedef typename ItemSetTraits<_Graph, _Item>::ItemNotifier Notifier;
    6969
    70     /// The MapBase of the Map which imlements the core regisitry function.
     70    // The MapBase of the Map which imlements the core regisitry function.
    7171    typedef typename Notifier::ObserverBase Parent;
    7272
     
    7676  public:
    7777
    78     /// \brief Graph initialized map constructor.
    79     ///
    80     /// Graph initialized map constructor.
     78    // \brief Graph initialized map constructor.
     79    //
     80    // Graph initialized map constructor.
    8181    explicit ArrayMap(const Graph& graph) {
    8282      Parent::attach(graph.notifier(Item()));
     
    9090    }
    9191
    92     /// \brief Constructor to use default value to initialize the map.
    93     ///
    94     /// It constructs a map and initialize all of the the map.
     92    // \brief Constructor to use default value to initialize the map.
     93    //
     94    // It constructs a map and initialize all of the the map.
    9595    ArrayMap(const Graph& graph, const Value& value) {
    9696      Parent::attach(graph.notifier(Item()));
     
    105105
    106106  private:
    107     /// \brief Constructor to copy a map of the same map type.
    108     ///
    109     /// Constructor to copy a map of the same map type.
     107    // \brief Constructor to copy a map of the same map type.
     108    //
     109    // Constructor to copy a map of the same map type.
    110110    ArrayMap(const ArrayMap& copy) : Parent() {
    111111      if (copy.attached()) {
     
    123123    }
    124124
    125     /// \brief Assign operator.
    126     ///
    127     /// This operator assigns for each item in the map the
    128     /// value mapped to the same item in the copied map.
    129     /// The parameter map should be indiced with the same
    130     /// itemset because this assign operator does not change
    131     /// the container of the map.
     125    // \brief Assign operator.
     126    //
     127    // This operator assigns for each item in the map the
     128    // value mapped to the same item in the copied map.
     129    // The parameter map should be indiced with the same
     130    // itemset because this assign operator does not change
     131    // the container of the map.
    132132    ArrayMap& operator=(const ArrayMap& cmap) {
    133133      return operator=<ArrayMap>(cmap);
     
    135135
    136136
    137     /// \brief Template assign operator.
    138     ///
    139     /// The given parameter should be conform to the ReadMap
    140     /// concecpt and could be indiced by the current item set of
    141     /// the NodeMap. In this case the value for each item
    142     /// is assigned by the value of the given ReadMap.
     137    // \brief Template assign operator.
     138    //
     139    // The given parameter should be conform to the ReadMap
     140    // concecpt and could be indiced by the current item set of
     141    // the NodeMap. In this case the value for each item
     142    // is assigned by the value of the given ReadMap.
    143143    template <typename CMap>
    144144    ArrayMap& operator=(const CMap& cmap) {
     
    153153
    154154  public:
    155     /// \brief The destructor of the map.
    156     ///
    157     /// The destructor of the map.
     155    // \brief The destructor of the map.
     156    //
     157    // The destructor of the map.
    158158    virtual ~ArrayMap() {
    159159      if (attached()) {
     
    171171  public:
    172172
    173     /// \brief The subscript operator.
    174     ///
    175     /// The subscript operator. The map can be subscripted by the
    176     /// actual keys of the graph.
     173    // \brief The subscript operator.
     174    //
     175    // The subscript operator. The map can be subscripted by the
     176    // actual keys of the graph.
    177177    Value& operator[](const Key& key) {
    178178      int id = Parent::notifier()->id(key);
     
    180180    }
    181181
    182     /// \brief The const subscript operator.
    183     ///
    184     /// The const subscript operator. The map can be subscripted by the
    185     /// actual keys of the graph.
     182    // \brief The const subscript operator.
     183    //
     184    // The const subscript operator. The map can be subscripted by the
     185    // actual keys of the graph.
    186186    const Value& operator[](const Key& key) const {
    187187      int id = Parent::notifier()->id(key);
     
    189189    }
    190190
    191     /// \brief Setter function of the map.
    192     ///
    193     /// Setter function of the map. Equivalent with map[key] = val.
    194     /// This is a compatibility feature with the not dereferable maps.
     191    // \brief Setter function of the map.
     192    //
     193    // Setter function of the map. Equivalent with map[key] = val.
     194    // This is a compatibility feature with the not dereferable maps.
    195195    void set(const Key& key, const Value& val) {
    196196      (*this)[key] = val;
     
    199199  protected:
    200200
    201     /// \brief Adds a new key to the map.
    202     ///
    203     /// It adds a new key to the map. It called by the observer notifier
    204     /// and it overrides the add() member function of the observer base.
     201    // \brief Adds a new key to the map.
     202    //
     203    // It adds a new key to the map. It called by the observer notifier
     204    // and it overrides the add() member function of the observer base.
    205205    virtual void add(const Key& key) {
    206206      Notifier* nf = Parent::notifier();
     
    227227    }
    228228
    229     /// \brief Adds more new keys to the map.
    230     ///
    231     /// It adds more new keys to the map. It called by the observer notifier
    232     /// and it overrides the add() member function of the observer base.
     229    // \brief Adds more new keys to the map.
     230    //
     231    // It adds more new keys to the map. It called by the observer notifier
     232    // and it overrides the add() member function of the observer base.
    233233    virtual void add(const std::vector<Key>& keys) {
    234234      Notifier* nf = Parent::notifier();
     
    271271    }
    272272
    273     /// \brief Erase a key from the map.
    274     ///
    275     /// Erase a key from the map. It called by the observer notifier
    276     /// and it overrides the erase() member function of the observer base.
     273    // \brief Erase a key from the map.
     274    //
     275    // Erase a key from the map. It called by the observer notifier
     276    // and it overrides the erase() member function of the observer base.
    277277    virtual void erase(const Key& key) {
    278278      int id = Parent::notifier()->id(key);
     
    280280    }
    281281
    282     /// \brief Erase more keys from the map.
    283     ///
    284     /// Erase more keys from the map. It called by the observer notifier
    285     /// and it overrides the erase() member function of the observer base.
     282    // \brief Erase more keys from the map.
     283    //
     284    // Erase more keys from the map. It called by the observer notifier
     285    // and it overrides the erase() member function of the observer base.
    286286    virtual void erase(const std::vector<Key>& keys) {
    287287      for (int i = 0; i < int(keys.size()); ++i) {
     
    291291    }
    292292
    293     /// \brief Buildes the map.
    294     ///
    295     /// It buildes the map. It called by the observer notifier
    296     /// and it overrides the build() member function of the observer base.
     293    // \brief Buildes the map.
     294    //
     295    // It buildes the map. It called by the observer notifier
     296    // and it overrides the build() member function of the observer base.
    297297    virtual void build() {
    298298      Notifier* nf = Parent::notifier();
     
    305305    }
    306306
    307     /// \brief Clear the map.
    308     ///
    309     /// It erase all items from the map. It called by the observer notifier
    310     /// and it overrides the clear() member function of the observer base.
     307    // \brief Clear the map.
     308    //
     309    // It erase all items from the map. It called by the observer notifier
     310    // and it overrides the clear() member function of the observer base.
    311311    virtual void clear() {
    312312      Notifier* nf = Parent::notifier();
  • lemon/bits/base_extender.h

    r289 r318  
    2929#include <lemon/concepts/maps.h>
    3030
    31 ///\ingroup digraphbits
    32 ///\file
    33 ///\brief Extenders for the digraph types
     31//\ingroup digraphbits
     32//\file
     33//\brief Extenders for the digraph types
    3434namespace lemon {
    3535
    36   /// \ingroup digraphbits
    37   ///
    38   /// \brief BaseDigraph to BaseGraph extender
     36  // \ingroup digraphbits
     37  //
     38  // \brief BaseDigraph to BaseGraph extender
    3939  template <typename Base>
    4040  class UndirDigraphExtender : public Base {
     
    7575    };
    7676
    77     /// First node of the edge
     77    // First node of the edge
    7878    Node u(const Edge &e) const {
    7979      return Parent::source(e);
    8080    }
    8181
    82     /// Source of the given arc
     82    // Source of the given arc
    8383    Node source(const Arc &e) const {
    8484      return e.forward ? Parent::source(e) : Parent::target(e);
    8585    }
    8686
    87     /// Second node of the edge
     87    // Second node of the edge
    8888    Node v(const Edge &e) const {
    8989      return Parent::target(e);
    9090    }
    9191
    92     /// Target of the given arc
     92    // Target of the given arc
    9393    Node target(const Arc &e) const {
    9494      return e.forward ? Parent::target(e) : Parent::source(e);
    9595    }
    9696
    97     /// \brief Directed arc from an edge.
    98     ///
    99     /// Returns a directed arc corresponding to the specified edge.
    100     /// If the given bool is true, the first node of the given edge and
    101     /// the source node of the returned arc are the same.
     97    // \brief Directed arc from an edge.
     98    //
     99    // Returns a directed arc corresponding to the specified edge.
     100    // If the given bool is true, the first node of the given edge and
     101    // the source node of the returned arc are the same.
    102102    static Arc direct(const Edge &e, bool d) {
    103103      return Arc(e, d);
    104104    }
    105105
    106     /// Returns whether the given directed arc has the same orientation
    107     /// as the corresponding edge.
     106    // Returns whether the given directed arc has the same orientation
     107    // as the corresponding edge.
    108108    static bool direction(const Arc &a) { return a.forward; }
    109109
  • lemon/bits/bezier.h

    r209 r318  
    2020#define LEMON_BEZIER_H
    2121
    22 ///\ingroup misc
    23 ///\file
    24 ///\brief Classes to compute with Bezier curves.
    25 ///
    26 ///Up to now this file is used internally by \ref graph_to_eps.h
     22//\ingroup misc
     23//\file
     24//\brief Classes to compute with Bezier curves.
     25//
     26//Up to now this file is used internally by \ref graph_to_eps.h
    2727
    2828#include<lemon/dim2.h>
  • lemon/bits/default_map.h

    r209 r318  
    2020#define LEMON_BITS_DEFAULT_MAP_H
    2121
    22 
    2322#include <lemon/bits/array_map.h>
    2423#include <lemon/bits/vector_map.h>
    2524//#include <lemon/bits/debug_map.h>
    2625
    27 ///\ingroup graphbits
    28 ///\file
    29 ///\brief Graph maps that construct and destruct their elements dynamically.
     26//\ingroup graphbits
     27//\file
     28//\brief Graph maps that construct and destruct their elements dynamically.
    3029
    3130namespace lemon {
     
    150149// #endif
    151150
    152   /// \e
     151  // DefaultMap class
    153152  template <typename _Graph, typename _Item, typename _Value>
    154153  class DefaultMap
  • lemon/bits/enable_if.h

    r220 r318  
    3636#define LEMON_BITS_ENABLE_IF_H
    3737
    38 ///\file
    39 ///\brief Miscellaneous basic utilities
     38//\file
     39//\brief Miscellaneous basic utilities
    4040
    4141namespace lemon
    4242{
    4343
    44   /// Basic type for defining "tags". A "YES" condition for \c enable_if.
     44  // Basic type for defining "tags". A "YES" condition for \c enable_if.
    4545
    46   /// Basic type for defining "tags". A "YES" condition for \c enable_if.
    47   ///
    48   ///\sa False
     46  // Basic type for defining "tags". A "YES" condition for \c enable_if.
     47  //
     48  //\sa False
    4949  struct True {
    50     ///\e
     50    //\e
    5151    static const bool value = true;
    5252  };
    5353
    54   /// Basic type for defining "tags". A "NO" condition for \c enable_if.
     54  // Basic type for defining "tags". A "NO" condition for \c enable_if.
    5555
    56   /// Basic type for defining "tags". A "NO" condition for \c enable_if.
    57   ///
    58   ///\sa True
     56  // Basic type for defining "tags". A "NO" condition for \c enable_if.
     57  //
     58  //\sa True
    5959  struct False {
    60     ///\e
     60    //\e
    6161    static const bool value = false;
    6262  };
  • lemon/bits/graph_extender.h

    r263 r318  
    2828#include <lemon/concepts/maps.h>
    2929
    30 ///\ingroup graphbits
    31 ///\file
    32 ///\brief Extenders for the digraph types
     30//\ingroup graphbits
     31//\file
     32//\brief Extenders for the digraph types
    3333namespace lemon {
    3434
    35   /// \ingroup graphbits
    36   ///
    37   /// \brief Extender for the Digraphs
     35  // \ingroup graphbits
     36  //
     37  // \brief Extender for the Digraphs
    3838  template <typename Base>
    3939  class DigraphExtender : public Base {
     
    187187    };
    188188
    189     /// \brief Base node of the iterator
    190     ///
    191     /// Returns the base node (i.e. the source in this case) of the iterator
     189    // \brief Base node of the iterator
     190    //
     191    // Returns the base node (i.e. the source in this case) of the iterator
    192192    Node baseNode(const OutArcIt &arc) const {
    193193      return Parent::source(arc);
    194194    }
    195     /// \brief Running node of the iterator
    196     ///
    197     /// Returns the running node (i.e. the target in this case) of the
    198     /// iterator
     195    // \brief Running node of the iterator
     196    //
     197    // Returns the running node (i.e. the target in this case) of the
     198    // iterator
    199199    Node runningNode(const OutArcIt &arc) const {
    200200      return Parent::target(arc);
    201201    }
    202202
    203     /// \brief Base node of the iterator
    204     ///
    205     /// Returns the base node (i.e. the target in this case) of the iterator
     203    // \brief Base node of the iterator
     204    //
     205    // Returns the base node (i.e. the target in this case) of the iterator
    206206    Node baseNode(const InArcIt &arc) const {
    207207      return Parent::target(arc);
    208208    }
    209     /// \brief Running node of the iterator
    210     ///
    211     /// Returns the running node (i.e. the source in this case) of the
    212     /// iterator
     209    // \brief Running node of the iterator
     210    //
     211    // Returns the running node (i.e. the source in this case) of the
     212    // iterator
    213213    Node runningNode(const InArcIt &arc) const {
    214214      return Parent::source(arc);
     
    326326  };
    327327
    328   /// \ingroup _graphbits
    329   ///
    330   /// \brief Extender for the Graphs
     328  // \ingroup _graphbits
     329  //
     330  // \brief Extender for the Graphs
    331331  template <typename Base>
    332332  class GraphExtender : public Base {
     
    556556    };
    557557
    558     /// \brief Base node of the iterator
    559     ///
    560     /// Returns the base node (ie. the source in this case) of the iterator
     558    // \brief Base node of the iterator
     559    //
     560    // Returns the base node (ie. the source in this case) of the iterator
    561561    Node baseNode(const OutArcIt &arc) const {
    562562      return Parent::source(static_cast<const Arc&>(arc));
    563563    }
    564     /// \brief Running node of the iterator
    565     ///
    566     /// Returns the running node (ie. the target in this case) of the
    567     /// iterator
     564    // \brief Running node of the iterator
     565    //
     566    // Returns the running node (ie. the target in this case) of the
     567    // iterator
    568568    Node runningNode(const OutArcIt &arc) const {
    569569      return Parent::target(static_cast<const Arc&>(arc));
    570570    }
    571571
    572     /// \brief Base node of the iterator
    573     ///
    574     /// Returns the base node (ie. the target in this case) of the iterator
     572    // \brief Base node of the iterator
     573    //
     574    // Returns the base node (ie. the target in this case) of the iterator
    575575    Node baseNode(const InArcIt &arc) const {
    576576      return Parent::target(static_cast<const Arc&>(arc));
    577577    }
    578     /// \brief Running node of the iterator
    579     ///
    580     /// Returns the running node (ie. the source in this case) of the
    581     /// iterator
     578    // \brief Running node of the iterator
     579    //
     580    // Returns the running node (ie. the source in this case) of the
     581    // iterator
    582582    Node runningNode(const InArcIt &arc) const {
    583583      return Parent::source(static_cast<const Arc&>(arc));
    584584    }
    585585
    586     /// Base node of the iterator
    587     ///
    588     /// Returns the base node of the iterator
     586    // Base node of the iterator
     587    //
     588    // Returns the base node of the iterator
    589589    Node baseNode(const IncEdgeIt &edge) const {
    590590      return edge._direction ? u(edge) : v(edge);
    591591    }
    592     /// Running node of the iterator
    593     ///
    594     /// Returns the running node of the iterator
     592    // Running node of the iterator
     593    //
     594    // Returns the running node of the iterator
    595595    Node runningNode(const IncEdgeIt &edge) const {
    596596      return edge._direction ? v(edge) : u(edge);
  • lemon/bits/map_extender.h

    r263 r318  
    2727#include <lemon/concepts/maps.h>
    2828
    29 ///\file
    30 ///\brief Extenders for iterable maps.
     29//\file
     30//\brief Extenders for iterable maps.
    3131
    3232namespace lemon {
    3333
    34   /// \ingroup graphbits
    35   ///
    36   /// \brief Extender for maps
     34  // \ingroup graphbits
     35  //
     36  // \brief Extender for maps
    3737  template <typename _Map>
    3838  class MapExtender : public _Map {
     
    172172  };
    173173
    174   /// \ingroup graphbits
    175   ///
    176   /// \brief Extender for maps which use a subset of the items.
     174  // \ingroup graphbits
     175  //
     176  // \brief Extender for maps which use a subset of the items.
    177177  template <typename _Graph, typename _Map>
    178178  class SubMapExtender : public _Map {
  • lemon/bits/traits.h

    r220 r318  
    2020#define LEMON_BITS_TRAITS_H
    2121
    22 ///\file
    23 ///\brief Traits for graphs and maps
    24 ///
     22//\file
     23//\brief Traits for graphs and maps
     24//
    2525
    2626#include <lemon/bits/enable_if.h>
  • lemon/bits/vector_map.h

    r280 r318  
    2929#include <lemon/concepts/maps.h>
    3030
    31 ///\ingroup graphbits
    32 ///
    33 ///\file
    34 ///\brief Vector based graph maps.
     31//\ingroup graphbits
     32//
     33//\file
     34//\brief Vector based graph maps.
    3535namespace lemon {
    3636
    37   /// \ingroup graphbits
    38   ///
    39   /// \brief Graph map based on the std::vector storage.
    40   ///
    41   /// The VectorMap template class is graph map structure what
    42   /// automatically updates the map when a key is added to or erased from
    43   /// the map. This map type uses the std::vector to store the values.
    44   ///
    45   /// \tparam _Graph The graph this map is attached to.
    46   /// \tparam _Item The item type of the graph items.
    47   /// \tparam _Value The value type of the map.
     37  // \ingroup graphbits
     38  //
     39  // \brief Graph map based on the std::vector storage.
     40  //
     41  // The VectorMap template class is graph map structure what
     42  // automatically updates the map when a key is added to or erased from
     43  // the map. This map type uses the std::vector to store the values.
     44  //
     45  // \tparam _Graph The graph this map is attached to.
     46  // \tparam _Item The item type of the graph items.
     47  // \tparam _Value The value type of the map.
    4848  template <typename _Graph, typename _Item, typename _Value>
    4949  class VectorMap
     
    5151  private:
    5252
    53     /// The container type of the map.
     53    // The container type of the map.
    5454    typedef std::vector<_Value> Container;
    5555
    5656  public:
    5757
    58     /// The graph type of the map.
     58    // The graph type of the map.
    5959    typedef _Graph Graph;
    60     /// The item type of the map.
     60    // The item type of the map.
    6161    typedef _Item Item;
    62     /// The reference map tag.
     62    // The reference map tag.
    6363    typedef True ReferenceMapTag;
    6464
    65     /// The key type of the map.
     65    // The key type of the map.
    6666    typedef _Item Key;
    67     /// The value type of the map.
     67    // The value type of the map.
    6868    typedef _Value Value;
    6969
    70     /// The notifier type.
     70    // The notifier type.
    7171    typedef typename ItemSetTraits<_Graph, _Item>::ItemNotifier Notifier;
    7272
    73     /// The map type.
     73    // The map type.
    7474    typedef VectorMap Map;
    75     /// The base class of the map.
     75    // The base class of the map.
    7676    typedef typename Notifier::ObserverBase Parent;
    7777
    78     /// The reference type of the map;
     78    // The reference type of the map;
    7979    typedef typename Container::reference Reference;
    80     /// The const reference type of the map;
     80    // The const reference type of the map;
    8181    typedef typename Container::const_reference ConstReference;
    8282
    8383
    84     /// \brief Constructor to attach the new map into the notifier.
    85     ///
    86     /// It constructs a map and attachs it into the notifier.
    87     /// It adds all the items of the graph to the map.
     84    // \brief Constructor to attach the new map into the notifier.
     85    //
     86    // It constructs a map and attachs it into the notifier.
     87    // It adds all the items of the graph to the map.
    8888    VectorMap(const Graph& graph) {
    8989      Parent::attach(graph.notifier(Item()));
     
    9191    }
    9292
    93     /// \brief Constructor uses given value to initialize the map.
    94     ///
    95     /// It constructs a map uses a given value to initialize the map.
    96     /// It adds all the items of the graph to the map.
     93    // \brief Constructor uses given value to initialize the map.
     94    //
     95    // It constructs a map uses a given value to initialize the map.
     96    // It adds all the items of the graph to the map.
    9797    VectorMap(const Graph& graph, const Value& value) {
    9898      Parent::attach(graph.notifier(Item()));
     
    101101
    102102  private:
    103     /// \brief Copy constructor
    104     ///
    105     /// Copy constructor.
     103    // \brief Copy constructor
     104    //
     105    // Copy constructor.
    106106    VectorMap(const VectorMap& _copy) : Parent() {
    107107      if (_copy.attached()) {
     
    111111    }
    112112
    113     /// \brief Assign operator.
    114     ///
    115     /// This operator assigns for each item in the map the
    116     /// value mapped to the same item in the copied map.
    117     /// The parameter map should be indiced with the same
    118     /// itemset because this assign operator does not change
    119     /// the container of the map.
     113    // \brief Assign operator.
     114    //
     115    // This operator assigns for each item in the map the
     116    // value mapped to the same item in the copied map.
     117    // The parameter map should be indiced with the same
     118    // itemset because this assign operator does not change
     119    // the container of the map.
    120120    VectorMap& operator=(const VectorMap& cmap) {
    121121      return operator=<VectorMap>(cmap);
     
    123123
    124124
    125     /// \brief Template assign operator.
    126     ///
    127     /// The given parameter should be conform to the ReadMap
    128     /// concecpt and could be indiced by the current item set of
    129     /// the NodeMap. In this case the value for each item
    130     /// is assigned by the value of the given ReadMap.
     125    // \brief Template assign operator.
     126    //
     127    // The given parameter should be conform to the ReadMap
     128    // concecpt and could be indiced by the current item set of
     129    // the NodeMap. In this case the value for each item
     130    // is assigned by the value of the given ReadMap.
    131131    template <typename CMap>
    132132    VectorMap& operator=(const CMap& cmap) {
     
    142142  public:
    143143
    144     /// \brief The subcript operator.
    145     ///
    146     /// The subscript operator. The map can be subscripted by the
    147     /// actual items of the graph.
     144    // \brief The subcript operator.
     145    //
     146    // The subscript operator. The map can be subscripted by the
     147    // actual items of the graph.
    148148    Reference operator[](const Key& key) {
    149149      return container[Parent::notifier()->id(key)];
    150150    }
    151151
    152     /// \brief The const subcript operator.
    153     ///
    154     /// The const subscript operator. The map can be subscripted by the
    155     /// actual items of the graph.
     152    // \brief The const subcript operator.
     153    //
     154    // The const subscript operator. The map can be subscripted by the
     155    // actual items of the graph.
    156156    ConstReference operator[](const Key& key) const {
    157157      return container[Parent::notifier()->id(key)];
     
    159159
    160160
    161     /// \brief The setter function of the map.
    162     ///
    163     /// It the same as operator[](key) = value expression.
     161    // \brief The setter function of the map.
     162    //
     163    // It the same as operator[](key) = value expression.
    164164    void set(const Key& key, const Value& value) {
    165165      (*this)[key] = value;
     
    168168  protected:
    169169
    170     /// \brief Adds a new key to the map.
    171     ///
    172     /// It adds a new key to the map. It called by the observer notifier
    173     /// and it overrides the add() member function of the observer base.
     170    // \brief Adds a new key to the map.
     171    //
     172    // It adds a new key to the map. It called by the observer notifier
     173    // and it overrides the add() member function of the observer base.
    174174    virtual void add(const Key& key) {
    175175      int id = Parent::notifier()->id(key);
     
    179179    }
    180180
    181     /// \brief Adds more new keys to the map.
    182     ///
    183     /// It adds more new keys to the map. It called by the observer notifier
    184     /// and it overrides the add() member function of the observer base.
     181    // \brief Adds more new keys to the map.
     182    //
     183    // It adds more new keys to the map. It called by the observer notifier
     184    // and it overrides the add() member function of the observer base.
    185185    virtual void add(const std::vector<Key>& keys) {
    186186      int max = container.size() - 1;
     
    194194    }
    195195
    196     /// \brief Erase a key from the map.
    197     ///
    198     /// Erase a key from the map. It called by the observer notifier
    199     /// and it overrides the erase() member function of the observer base.
     196    // \brief Erase a key from the map.
     197    //
     198    // Erase a key from the map. It called by the observer notifier
     199    // and it overrides the erase() member function of the observer base.
    200200    virtual void erase(const Key& key) {
    201201      container[Parent::notifier()->id(key)] = Value();
    202202    }
    203203
    204     /// \brief Erase more keys from the map.
    205     ///
    206     /// Erase more keys from the map. It called by the observer notifier
    207     /// and it overrides the erase() member function of the observer base.
     204    // \brief Erase more keys from the map.
     205    //
     206    // Erase more keys from the map. It called by the observer notifier
     207    // and it overrides the erase() member function of the observer base.
    208208    virtual void erase(const std::vector<Key>& keys) {
    209209      for (int i = 0; i < int(keys.size()); ++i) {
     
    212212    }
    213213
    214     /// \brief Buildes the map.
    215     ///
    216     /// It buildes the map. It called by the observer notifier
    217     /// and it overrides the build() member function of the observer base.
     214    // \brief Buildes the map.
     215    //
     216    // It buildes the map. It called by the observer notifier
     217    // and it overrides the build() member function of the observer base.
    218218    virtual void build() {
    219219      int size = Parent::notifier()->maxId() + 1;
     
    222222    }
    223223
    224     /// \brief Clear the map.
    225     ///
    226     /// It erase all items from the map. It called by the observer notifier
    227     /// and it overrides the clear() member function of the observer base.
     224    // \brief Clear the map.
     225    //
     226    // It erase all items from the map. It called by the observer notifier
     227    // and it overrides the clear() member function of the observer base.
    228228    virtual void clear() {
    229229      container.clear();
  • lemon/color.h

    r209 r317  
    9393  extern const Color DARK_CYAN;
    9494
    95   ///Map <tt>int</tt>s to different \ref Color "Color"s
     95  ///Map <tt>int</tt>s to different <tt>Color</tt>s
    9696
    9797  ///This map assigns one of the predefined \ref Color "Color"s to
  • lemon/concepts/graph_components.h

    r263 r317  
    983983    ///
    984984    /// 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
    986986    /// associate data to graph descriptors (nodes or arcs).
    987987    template <typename _Graph, typename _Item, typename _Value>
  • lemon/concepts/maps.h

    r220 r318  
    2323#include <lemon/concept_check.h>
    2424
    25 ///\ingroup concept
     25///\ingroup map_concepts
    2626///\file
    2727///\brief The concept of maps.
     
    3131  namespace concepts {
    3232
    33     /// \addtogroup concept
     33    /// \addtogroup map_concepts
    3434    /// @{
    3535
  • lemon/core.h

    r282 r317  
    5959  /// @{
    6060
    61   ///Create convenient typedefs for the digraph types and iterators
     61  ///Create convenience typedefs for the digraph types and iterators
    6262
    6363  ///This \c \#define creates convenient type definitions for the following
     
    8181  typedef Digraph::ArcMap<bool> BoolArcMap;                             \
    8282  typedef Digraph::ArcMap<int> IntArcMap;                               \
    83   typedef Digraph::ArcMap<double> DoubleArcMap;
    84 
    85   ///Create convenient typedefs for the digraph types and iterators
     83  typedef Digraph::ArcMap<double> DoubleArcMap
     84
     85  ///Create convenience typedefs for the digraph types and iterators
    8686
    8787  ///\see DIGRAPH_TYPEDEFS
     
    101101  typedef typename Digraph::template ArcMap<bool> BoolArcMap;           \
    102102  typedef typename Digraph::template ArcMap<int> IntArcMap;             \
    103   typedef typename Digraph::template ArcMap<double> DoubleArcMap;
    104 
    105   ///Create convenient typedefs for the graph types and iterators
     103  typedef typename Digraph::template ArcMap<double> DoubleArcMap
     104
     105  ///Create convenience typedefs for the graph types and iterators
    106106
    107107  ///This \c \#define creates the same convenient type definitions as defined
     
    120120  typedef Graph::EdgeMap<bool> BoolEdgeMap;                             \
    121121  typedef Graph::EdgeMap<int> IntEdgeMap;                               \
    122   typedef Graph::EdgeMap<double> DoubleEdgeMap;
    123 
    124   ///Create convenient typedefs for the graph types and iterators
     122  typedef Graph::EdgeMap<double> DoubleEdgeMap
     123
     124  ///Create convenience typedefs for the graph types and iterators
    125125
    126126  ///\see GRAPH_TYPEDEFS
     
    135135  typedef typename Graph::template EdgeMap<bool> BoolEdgeMap;           \
    136136  typedef typename Graph::template EdgeMap<int> IntEdgeMap;             \
    137   typedef typename Graph::template EdgeMap<double> DoubleEdgeMap;
     137  typedef typename Graph::template EdgeMap<double> DoubleEdgeMap
    138138
    139139  /// \brief Function to count the items in a graph.
     
    15551555    ///structure is updated after each graph alteration. Thus although
    15561556    ///this data structure is theoretically faster than \ref ArcLookUp
    1557     ///and \ref AllArcLookup, it often provides worse performance than
     1557    ///and \ref AllArcLookUp, it often provides worse performance than
    15581558    ///them.
    15591559    Arc operator()(Node s, Node t, Arc p = INVALID) const  {
     
    17001700    ///Find an arc between two nodes.
    17011701
    1702     ///Find an arc between two nodes in time <em>O</em>(log<em>d</em>), where
    1703     ///<em>d</em> is the number of outgoing arcs of \c s.
     1702    ///Find an arc between two nodes in time <em>O</em>(log<em>d</em>),
     1703    ///where <em>d</em> is the number of outgoing arcs of \c s.
    17041704    ///\param s The source node.
    17051705    ///\param t The target node.
     
    18181818    ///\endcode
    18191819    ///
    1820     ///Finding the first arc take <em>O</em>(log<em>d</em>) time, where
    1821     ///<em>d</em> is the number of outgoing arcs of \c s. Then, the
     1820    ///Finding the first arc take <em>O</em>(log<em>d</em>) time,
     1821    ///where <em>d</em> is the number of outgoing arcs of \c s. Then the
    18221822    ///consecutive arcs are found in constant time.
    18231823    ///
  • lemon/dfs.h

    r292 r317  
    5151    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    5252    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
    53     ///Instantiates a \ref PredMap.
    54 
    55     ///This function instantiates a \ref PredMap.
     53    ///Instantiates a PredMap.
     54
     55    ///This function instantiates a PredMap.
    5656    ///\param g is the digraph, to which we would like to define the
    57     ///\ref PredMap.
     57    ///PredMap.
    5858    static PredMap *createPredMap(const Digraph &g)
    5959    {
     
    6666    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    6767    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    68     ///Instantiates a \ref ProcessedMap.
    69 
    70     ///This function instantiates a \ref ProcessedMap.
     68    ///Instantiates a ProcessedMap.
     69
     70    ///This function instantiates a ProcessedMap.
    7171    ///\param g is the digraph, to which
    72     ///we would like to define the \ref ProcessedMap
     72    ///we would like to define the ProcessedMap
    7373#ifdef DOXYGEN
    7474    static ProcessedMap *createProcessedMap(const Digraph &g)
     
    8585    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
    8686    typedef typename Digraph::template NodeMap<bool> ReachedMap;
    87     ///Instantiates a \ref ReachedMap.
    88 
    89     ///This function instantiates a \ref ReachedMap.
     87    ///Instantiates a ReachedMap.
     88
     89    ///This function instantiates a ReachedMap.
    9090    ///\param g is the digraph, to which
    91     ///we would like to define the \ref ReachedMap.
     91    ///we would like to define the ReachedMap.
    9292    static ReachedMap *createReachedMap(const Digraph &g)
    9393    {
     
    100100    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    101101    typedef typename Digraph::template NodeMap<int> DistMap;
    102     ///Instantiates a \ref DistMap.
    103 
    104     ///This function instantiates a \ref DistMap.
     102    ///Instantiates a DistMap.
     103
     104    ///This function instantiates a DistMap.
    105105    ///\param g is the digraph, to which we would like to define the
    106     ///\ref DistMap.
     106    ///DistMap.
    107107    static DistMap *createDistMap(const Digraph &g)
    108108    {
     
    228228    };
    229229    ///\brief \ref named-templ-param "Named parameter" for setting
    230     ///\ref PredMap type.
     230    ///PredMap type.
    231231    ///
    232232    ///\ref named-templ-param "Named parameter" for setting
    233     ///\ref PredMap type.
     233    ///PredMap type.
    234234    template <class T>
    235235    struct SetPredMap : public Dfs<Digraph, SetPredMapTraits<T> > {
     
    247247    };
    248248    ///\brief \ref named-templ-param "Named parameter" for setting
    249     ///\ref DistMap type.
     249    ///DistMap type.
    250250    ///
    251251    ///\ref named-templ-param "Named parameter" for setting
    252     ///\ref DistMap type.
     252    ///DistMap type.
    253253    template <class T>
    254254    struct SetDistMap : public Dfs< Digraph, SetDistMapTraits<T> > {
     
    266266    };
    267267    ///\brief \ref named-templ-param "Named parameter" for setting
    268     ///\ref ReachedMap type.
     268    ///ReachedMap type.
    269269    ///
    270270    ///\ref named-templ-param "Named parameter" for setting
    271     ///\ref ReachedMap type.
     271    ///ReachedMap type.
    272272    template <class T>
    273273    struct SetReachedMap : public Dfs< Digraph, SetReachedMapTraits<T> > {
     
    285285    };
    286286    ///\brief \ref named-templ-param "Named parameter" for setting
    287     ///\ref ProcessedMap type.
     287    ///ProcessedMap type.
    288288    ///
    289289    ///\ref named-templ-param "Named parameter" for setting
    290     ///\ref ProcessedMap type.
     290    ///ProcessedMap type.
    291291    template <class T>
    292292    struct SetProcessedMap : public Dfs< Digraph, SetProcessedMapTraits<T> > {
     
    302302    };
    303303    ///\brief \ref named-templ-param "Named parameter" for setting
    304     ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     304    ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
    305305    ///
    306306    ///\ref named-templ-param "Named parameter" for setting
    307     ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     307    ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
    308308    ///If you don't set it explicitly, it will be automatically allocated.
    309309    struct SetStandardProcessedMap :
     
    769769    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    770770    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
    771     ///Instantiates a \ref PredMap.
    772 
    773     ///This function instantiates a \ref PredMap.
     771    ///Instantiates a PredMap.
     772
     773    ///This function instantiates a PredMap.
    774774    ///\param g is the digraph, to which we would like to define the
    775     ///\ref PredMap.
     775    ///PredMap.
    776776    static PredMap *createPredMap(const Digraph &g)
    777777    {
     
    785785    ///By default it is a NullMap.
    786786    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    787     ///Instantiates a \ref ProcessedMap.
    788 
    789     ///This function instantiates a \ref ProcessedMap.
     787    ///Instantiates a ProcessedMap.
     788
     789    ///This function instantiates a ProcessedMap.
    790790    ///\param g is the digraph, to which
    791     ///we would like to define the \ref ProcessedMap.
     791    ///we would like to define the ProcessedMap.
    792792#ifdef DOXYGEN
    793793    static ProcessedMap *createProcessedMap(const Digraph &g)
     
    804804    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
    805805    typedef typename Digraph::template NodeMap<bool> ReachedMap;
    806     ///Instantiates a \ref ReachedMap.
    807 
    808     ///This function instantiates a \ref ReachedMap.
     806    ///Instantiates a ReachedMap.
     807
     808    ///This function instantiates a ReachedMap.
    809809    ///\param g is the digraph, to which
    810     ///we would like to define the \ref ReachedMap.
     810    ///we would like to define the ReachedMap.
    811811    static ReachedMap *createReachedMap(const Digraph &g)
    812812    {
     
    819819    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    820820    typedef typename Digraph::template NodeMap<int> DistMap;
    821     ///Instantiates a \ref DistMap.
    822 
    823     ///This function instantiates a \ref DistMap.
     821    ///Instantiates a DistMap.
     822
     823    ///This function instantiates a DistMap.
    824824    ///\param g is the digraph, to which we would like to define
    825     ///the \ref DistMap
     825    ///the DistMap
    826826    static DistMap *createDistMap(const Digraph &g)
    827827    {
     
    836836  };
    837837
    838   /// Default traits class used by \ref DfsWizard
     838  /// Default traits class used by DfsWizard
    839839
    840840  /// To make it easier to use Dfs algorithm
     
    10021002    };
    10031003    ///\brief \ref named-func-param "Named parameter"
    1004     ///for setting \ref PredMap object.
     1004    ///for setting PredMap object.
    10051005    ///
    10061006    ///\ref named-func-param "Named parameter"
    1007     ///for setting \ref PredMap object.
     1007    ///for setting PredMap object.
    10081008    template<class T>
    10091009    DfsWizard<SetPredMapBase<T> > predMap(const T &t)
     
    10201020    };
    10211021    ///\brief \ref named-func-param "Named parameter"
    1022     ///for setting \ref ReachedMap object.
     1022    ///for setting ReachedMap object.
    10231023    ///
    10241024    /// \ref named-func-param "Named parameter"
    1025     ///for setting \ref ReachedMap object.
     1025    ///for setting ReachedMap object.
    10261026    template<class T>
    10271027    DfsWizard<SetReachedMapBase<T> > reachedMap(const T &t)
     
    10381038    };
    10391039    ///\brief \ref named-func-param "Named parameter"
    1040     ///for setting \ref DistMap object.
     1040    ///for setting DistMap object.
    10411041    ///
    10421042    /// \ref named-func-param "Named parameter"
    1043     ///for setting \ref DistMap object.
     1043    ///for setting DistMap object.
    10441044    template<class T>
    10451045    DfsWizard<SetDistMapBase<T> > distMap(const T &t)
     
    10561056    };
    10571057    ///\brief \ref named-func-param "Named parameter"
    1058     ///for setting \ref ProcessedMap object.
     1058    ///for setting ProcessedMap object.
    10591059    ///
    10601060    /// \ref named-func-param "Named parameter"
    1061     ///for setting \ref ProcessedMap object.
     1061    ///for setting ProcessedMap object.
    10621062    template<class T>
    10631063    DfsWizard<SetProcessedMapBase<T> > processedMap(const T &t)
     
    12141214    typedef typename Digraph::template NodeMap<bool> ReachedMap;
    12151215
    1216     /// \brief Instantiates a \ref ReachedMap.
    1217     ///
    1218     /// This function instantiates a \ref ReachedMap.
     1216    /// \brief Instantiates a ReachedMap.
     1217    ///
     1218    /// This function instantiates a ReachedMap.
    12191219    /// \param digraph is the digraph, to which
    1220     /// we would like to define the \ref ReachedMap.
     1220    /// we would like to define the ReachedMap.
    12211221    static ReachedMap *createReachedMap(const Digraph &digraph) {
    12221222      return new ReachedMap(digraph);
  • lemon/dijkstra.h

    r290 r317  
    140140    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    141141    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
    142     ///Instantiates a \ref PredMap.
    143 
    144     ///This function instantiates a \ref PredMap.
     142    ///Instantiates a PredMap.
     143
     144    ///This function instantiates a PredMap.
    145145    ///\param g is the digraph, to which we would like to define the
    146     ///\ref PredMap.
     146    ///PredMap.
    147147    static PredMap *createPredMap(const Digraph &g)
    148148    {
     
    156156    ///By default it is a NullMap.
    157157    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    158     ///Instantiates a \ref ProcessedMap.
    159 
    160     ///This function instantiates a \ref ProcessedMap.
     158    ///Instantiates a ProcessedMap.
     159
     160    ///This function instantiates a ProcessedMap.
    161161    ///\param g is the digraph, to which
    162     ///we would like to define the \ref ProcessedMap
     162    ///we would like to define the ProcessedMap
    163163#ifdef DOXYGEN
    164164    static ProcessedMap *createProcessedMap(const Digraph &g)
     
    175175    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    176176    typedef typename Digraph::template NodeMap<typename LM::Value> DistMap;
    177     ///Instantiates a \ref DistMap.
    178 
    179     ///This function instantiates a \ref DistMap.
     177    ///Instantiates a DistMap.
     178
     179    ///This function instantiates a DistMap.
    180180    ///\param g is the digraph, to which we would like to define
    181     ///the \ref DistMap
     181    ///the DistMap
    182182    static DistMap *createDistMap(const Digraph &g)
    183183    {
     
    328328    };
    329329    ///\brief \ref named-templ-param "Named parameter" for setting
    330     ///\ref PredMap type.
     330    ///PredMap type.
    331331    ///
    332332    ///\ref named-templ-param "Named parameter" for setting
    333     ///\ref PredMap type.
     333    ///PredMap type.
    334334    template <class T>
    335335    struct SetPredMap
     
    348348    };
    349349    ///\brief \ref named-templ-param "Named parameter" for setting
    350     ///\ref DistMap type.
     350    ///DistMap type.
    351351    ///
    352352    ///\ref named-templ-param "Named parameter" for setting
    353     ///\ref DistMap type.
     353    ///DistMap type.
    354354    template <class T>
    355355    struct SetDistMap
     
    368368    };
    369369    ///\brief \ref named-templ-param "Named parameter" for setting
    370     ///\ref ProcessedMap type.
     370    ///ProcessedMap type.
    371371    ///
    372372    ///\ref named-templ-param "Named parameter" for setting
    373     ///\ref ProcessedMap type.
     373    ///ProcessedMap type.
    374374    template <class T>
    375375    struct SetProcessedMap
     
    386386    };
    387387    ///\brief \ref named-templ-param "Named parameter" for setting
    388     ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     388    ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
    389389    ///
    390390    ///\ref named-templ-param "Named parameter" for setting
    391     ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     391    ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
    392392    ///If you don't set it explicitly, it will be automatically allocated.
    393393    struct SetStandardProcessedMap
     
    454454
    455455    /// \brief \ref named-templ-param "Named parameter" for setting
    456     ///\ref OperationTraits type
     456    ///\c OperationTraits type
    457457    ///
    458458    ///\ref named-templ-param "Named parameter" for setting
     
    987987    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    988988    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
    989     ///Instantiates a \ref PredMap.
    990 
    991     ///This function instantiates a \ref PredMap.
     989    ///Instantiates a PredMap.
     990
     991    ///This function instantiates a PredMap.
    992992    ///\param g is the digraph, to which we would like to define the
    993     ///\ref PredMap.
     993    ///PredMap.
    994994    static PredMap *createPredMap(const Digraph &g)
    995995    {
     
    10031003    ///By default it is a NullMap.
    10041004    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    1005     ///Instantiates a \ref ProcessedMap.
    1006 
    1007     ///This function instantiates a \ref ProcessedMap.
     1005    ///Instantiates a ProcessedMap.
     1006
     1007    ///This function instantiates a ProcessedMap.
    10081008    ///\param g is the digraph, to which
    1009     ///we would like to define the \ref ProcessedMap.
     1009    ///we would like to define the ProcessedMap.
    10101010#ifdef DOXYGEN
    10111011    static ProcessedMap *createProcessedMap(const Digraph &g)
     
    10221022    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    10231023    typedef typename Digraph::template NodeMap<typename LM::Value> DistMap;
    1024     ///Instantiates a \ref DistMap.
    1025 
    1026     ///This function instantiates a \ref DistMap.
     1024    ///Instantiates a DistMap.
     1025
     1026    ///This function instantiates a DistMap.
    10271027    ///\param g is the digraph, to which we would like to define
    1028     ///the \ref DistMap
     1028    ///the DistMap
    10291029    static DistMap *createDistMap(const Digraph &g)
    10301030    {
     
    10391039  };
    10401040
    1041   /// Default traits class used by \ref DijkstraWizard
     1041  /// Default traits class used by DijkstraWizard
    10421042
    10431043  /// To make it easier to use Dijkstra algorithm
     
    11991199    };
    12001200    ///\brief \ref named-func-param "Named parameter"
    1201     ///for setting \ref PredMap object.
     1201    ///for setting PredMap object.
    12021202    ///
    12031203    ///\ref named-func-param "Named parameter"
    1204     ///for setting \ref PredMap object.
     1204    ///for setting PredMap object.
    12051205    template<class T>
    12061206    DijkstraWizard<SetPredMapBase<T> > predMap(const T &t)
     
    12171217    };
    12181218    ///\brief \ref named-func-param "Named parameter"
    1219     ///for setting \ref DistMap object.
     1219    ///for setting DistMap object.
    12201220    ///
    12211221    ///\ref named-func-param "Named parameter"
    1222     ///for setting \ref DistMap object.
     1222    ///for setting DistMap object.
    12231223    template<class T>
    12241224    DijkstraWizard<SetDistMapBase<T> > distMap(const T &t)
     
    12351235    };
    12361236    ///\brief \ref named-func-param "Named parameter"
    1237     ///for setting \ref ProcessedMap object.
     1237    ///for setting ProcessedMap object.
    12381238    ///
    12391239    /// \ref named-func-param "Named parameter"
    1240     ///for setting \ref ProcessedMap object.
     1240    ///for setting ProcessedMap object.
    12411241    template<class T>
    12421242    DijkstraWizard<SetProcessedMapBase<T> > processedMap(const T &t)
  • lemon/dim2.h

    r253 r318  
    260260
    261261
    262   /// Bounding box of plain vectors (\ref Point points).
     262  /// Bounding box of plain vectors (points).
    263263
    264264  /// A class to calculate or store the bounding box of plain vectors
    265   /// (\ref Point points).
     265  /// (\ref Point "points").
    266266  template<typename T>
    267267  class Box {
     
    574574  }
    575575
    576   ///Map of x-coordinates of a \ref Point "Point"-map
    577 
    578   ///\ingroup maps
     576  ///Map of x-coordinates of a <tt>Point</tt>-map
     577
    579578  ///Map of x-coordinates of a \ref Point "Point"-map.
    580579  ///
     
    593592  };
    594593
    595   ///Returns an \ref XMap class
    596 
    597   ///This function just returns an \ref XMap class.
    598   ///
    599   ///\ingroup maps
     594  ///Returns an XMap class
     595
     596  ///This function just returns an XMap class.
    600597  ///\relates XMap
    601598  template<class M>
     
    611608  }
    612609
    613   ///Constant (read only) version of \ref XMap
    614 
    615   ///\ingroup maps
    616   ///Constant (read only) version of \ref XMap
     610  ///Constant (read only) version of XMap
     611
     612  ///Constant (read only) version of XMap.
    617613  ///
    618614  template<class M>
     
    629625  };
    630626
    631   ///Returns a \ref ConstXMap class
    632 
    633   ///This function just returns a \ref ConstXMap class.
    634   ///
    635   ///\ingroup maps
     627  ///Returns a ConstXMap class
     628
     629  ///This function just returns a ConstXMap class.
    636630  ///\relates ConstXMap
    637631  template<class M>
     
    641635  }
    642636
    643   ///Map of y-coordinates of a \ref Point "Point"-map
    644 
    645   ///\ingroup maps
     637  ///Map of y-coordinates of a <tt>Point</tt>-map
     638
    646639  ///Map of y-coordinates of a \ref Point "Point"-map.
    647640  ///
     
    660653  };
    661654
    662   ///Returns a \ref YMap class
    663 
    664   ///This function just returns a \ref YMap class.
    665   ///
    666   ///\ingroup maps
     655  ///Returns a YMap class
     656
     657  ///This function just returns a YMap class.
    667658  ///\relates YMap
    668659  template<class M>
     
    678669  }
    679670
    680   ///Constant (read only) version of \ref YMap
    681 
    682   ///\ingroup maps
    683   ///Constant (read only) version of \ref YMap
     671  ///Constant (read only) version of YMap
     672
     673  ///Constant (read only) version of YMap.
    684674  ///
    685675  template<class M>
     
    696686  };
    697687
    698   ///Returns a \ref ConstYMap class
    699 
    700   ///This function just returns a \ref ConstYMap class.
    701   ///
    702   ///\ingroup maps
     688  ///Returns a ConstYMap class
     689
     690  ///This function just returns a ConstYMap class.
    703691  ///\relates ConstYMap
    704692  template<class M>
     
    709697
    710698
    711   ///\brief Map of the \ref Point::normSquare() "normSquare()"
    712   ///of a \ref Point "Point"-map
     699  ///\brief Map of the normSquare() of a <tt>Point</tt>-map
    713700  ///
    714701  ///Map of the \ref Point::normSquare() "normSquare()"
    715702  ///of a \ref Point "Point"-map.
    716   ///\ingroup maps
    717703  template<class M>
    718704  class NormSquareMap
     
    728714  };
    729715
    730   ///Returns a \ref NormSquareMap class
    731 
    732   ///This function just returns a \ref NormSquareMap class.
    733   ///
    734   ///\ingroup maps
     716  ///Returns a NormSquareMap class
     717
     718  ///This function just returns a NormSquareMap class.
    735719  ///\relates NormSquareMap
    736720  template<class M>
  • lemon/graph_to_eps.h

    r291 r317  
    6363  }
    6464
    65 ///Default traits class of \ref GraphToEps
     65///Default traits class of GraphToEps
    6666
    6767///Default traits class of \ref GraphToEps.
  • lemon/lgf_reader.h

    r295 r307  
    392392  class DigraphReader;
    393393
     394  /// \brief Return a \ref DigraphReader class
     395  ///
     396  /// This function just returns a \ref DigraphReader class.
     397  /// \relates DigraphReader
    394398  template <typename Digraph>
    395399  DigraphReader<Digraph> digraphReader(Digraph& digraph,
    396                                        std::istream& is = std::cin);
    397 
     400                                       std::istream& is = std::cin) {
     401    DigraphReader<Digraph> tmp(digraph, is);
     402    return tmp;
     403  }
     404
     405  /// \brief Return a \ref DigraphReader class
     406  ///
     407  /// This function just returns a \ref DigraphReader class.
     408  /// \relates DigraphReader
    398409  template <typename Digraph>
    399   DigraphReader<Digraph> digraphReader(Digraph& digraph, const std::string& fn);
    400 
     410  DigraphReader<Digraph> digraphReader(Digraph& digraph,
     411                                       const std::string& fn) {
     412    DigraphReader<Digraph> tmp(digraph, fn);
     413    return tmp;
     414  }
     415
     416  /// \brief Return a \ref DigraphReader class
     417  ///
     418  /// This function just returns a \ref DigraphReader class.
     419  /// \relates DigraphReader
    401420  template <typename Digraph>
    402   DigraphReader<Digraph> digraphReader(Digraph& digraph, const char *fn);
     421  DigraphReader<Digraph> digraphReader(Digraph& digraph, const char* fn) {
     422    DigraphReader<Digraph> tmp(digraph, fn);
     423    return tmp;
     424  }
    403425
    404426  /// \ingroup lemon_io
     
    11901212  };
    11911213
    1192   /// \brief Return a \ref DigraphReader class
     1214  template <typename Graph>
     1215  class GraphReader;
     1216
     1217  /// \brief Return a \ref GraphReader class
    11931218  ///
    1194   /// This function just returns a \ref DigraphReader class.
    1195   /// \relates DigraphReader
    1196   template <typename Digraph>
    1197   DigraphReader<Digraph> digraphReader(Digraph& digraph,
    1198                                        std::istream& is = std::cin) {
    1199     DigraphReader<Digraph> tmp(digraph, is);
     1219  /// This function just returns a \ref GraphReader class.
     1220  /// \relates GraphReader
     1221  template <typename Graph>
     1222  GraphReader<Graph> graphReader(Graph& graph, std::istream& is = std::cin) {
     1223    GraphReader<Graph> tmp(graph, is);
    12001224    return tmp;
    12011225  }
    12021226
    1203   /// \brief Return a \ref DigraphReader class
     1227  /// \brief Return a \ref GraphReader class
    12041228  ///
    1205   /// This function just returns a \ref DigraphReader class.
    1206   /// \relates DigraphReader
    1207   template <typename Digraph>
    1208   DigraphReader<Digraph> digraphReader(Digraph& digraph,
    1209                                        const std::string& fn) {
    1210     DigraphReader<Digraph> tmp(digraph, fn);
     1229  /// This function just returns a \ref GraphReader class.
     1230  /// \relates GraphReader
     1231  template <typename Graph>
     1232  GraphReader<Graph> graphReader(Graph& graph, const std::string& fn) {
     1233    GraphReader<Graph> tmp(graph, fn);
    12111234    return tmp;
    12121235  }
    12131236
    1214   /// \brief Return a \ref DigraphReader class
     1237  /// \brief Return a \ref GraphReader class
    12151238  ///
    1216   /// This function just returns a \ref DigraphReader class.
    1217   /// \relates DigraphReader
    1218   template <typename Digraph>
    1219   DigraphReader<Digraph> digraphReader(Digraph& digraph, const char* fn) {
    1220     DigraphReader<Digraph> tmp(digraph, fn);
     1239  /// This function just returns a \ref GraphReader class.
     1240  /// \relates GraphReader
     1241  template <typename Graph>
     1242  GraphReader<Graph> graphReader(Graph& graph, const char* fn) {
     1243    GraphReader<Graph> tmp(graph, fn);
    12211244    return tmp;
    12221245  }
    1223 
    1224   template <typename Graph>
    1225   class GraphReader;
    1226 
    1227   template <typename Graph>
    1228   GraphReader<Graph> graphReader(Graph& graph,
    1229                                  std::istream& is = std::cin);
    1230 
    1231   template <typename Graph>
    1232   GraphReader<Graph> graphReader(Graph& graph, const std::string& fn);
    1233 
    1234   template <typename Graph>
    1235   GraphReader<Graph> graphReader(Graph& graph, const char *fn);
    12361246
    12371247  /// \ingroup lemon_io
     
    20312041
    20322042  };
    2033 
    2034   /// \brief Return a \ref GraphReader class
    2035   ///
    2036   /// This function just returns a \ref GraphReader class.
    2037   /// \relates GraphReader
    2038   template <typename Graph>
    2039   GraphReader<Graph> graphReader(Graph& graph, std::istream& is = std::cin) {
    2040     GraphReader<Graph> tmp(graph, is);
    2041     return tmp;
    2042   }
    2043 
    2044   /// \brief Return a \ref GraphReader class
    2045   ///
    2046   /// This function just returns a \ref GraphReader class.
    2047   /// \relates GraphReader
    2048   template <typename Graph>
    2049   GraphReader<Graph> graphReader(Graph& graph, const std::string& fn) {
    2050     GraphReader<Graph> tmp(graph, fn);
    2051     return tmp;
    2052   }
    2053 
    2054   /// \brief Return a \ref GraphReader class
    2055   ///
    2056   /// This function just returns a \ref GraphReader class.
    2057   /// \relates GraphReader
    2058   template <typename Graph>
    2059   GraphReader<Graph> graphReader(Graph& graph, const char* fn) {
    2060     GraphReader<Graph> tmp(graph, fn);
    2061     return tmp;
    2062   }
    20632043
    20642044  class SectionReader;
  • lemon/lgf_writer.h

    r295 r307  
    352352  class DigraphWriter;
    353353
     354  /// \brief Return a \ref DigraphWriter class
     355  ///
     356  /// This function just returns a \ref DigraphWriter class.
     357  /// \relates DigraphWriter
    354358  template <typename Digraph>
    355359  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
    356                                        std::ostream& os = std::cout);
    357 
     360                                       std::ostream& os = std::cout) {
     361    DigraphWriter<Digraph> tmp(digraph, os);
     362    return tmp;
     363  }
     364
     365  /// \brief Return a \ref DigraphWriter class
     366  ///
     367  /// This function just returns a \ref DigraphWriter class.
     368  /// \relates DigraphWriter
    358369  template <typename Digraph>
    359370  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
    360                                        const std::string& fn);
    361 
     371                                       const std::string& fn) {
     372    DigraphWriter<Digraph> tmp(digraph, fn);
     373    return tmp;
     374  }
     375
     376  /// \brief Return a \ref DigraphWriter class
     377  ///
     378  /// This function just returns a \ref DigraphWriter class.
     379  /// \relates DigraphWriter
    362380  template <typename Digraph>
    363381  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
    364                                        const char *fn);
     382                                       const char* fn) {
     383    DigraphWriter<Digraph> tmp(digraph, fn);
     384    return tmp;
     385  }
    365386
    366387  /// \ingroup lemon_io
     
    914935  };
    915936
    916   /// \brief Return a \ref DigraphWriter class
    917   ///
    918   /// This function just returns a \ref DigraphWriter class.
    919   /// \relates DigraphWriter
    920   template <typename Digraph>
    921   DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
    922                                        std::ostream& os = std::cout) {
    923     DigraphWriter<Digraph> tmp(digraph, os);
     937  template <typename Graph>
     938  class GraphWriter;
     939
     940  /// \brief Return a \ref GraphWriter class
     941  ///
     942  /// This function just returns a \ref GraphWriter class.
     943  /// \relates GraphWriter
     944  template <typename Graph>
     945  GraphWriter<Graph> graphWriter(const Graph& graph,
     946                                 std::ostream& os = std::cout) {
     947    GraphWriter<Graph> tmp(graph, os);
    924948    return tmp;
    925949  }
    926950
    927   /// \brief Return a \ref DigraphWriter class
    928   ///
    929   /// This function just returns a \ref DigraphWriter class.
    930   /// \relates DigraphWriter
    931   template <typename Digraph>
    932   DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
    933                                        const std::string& fn) {
    934     DigraphWriter<Digraph> tmp(digraph, fn);
     951  /// \brief Return a \ref GraphWriter class
     952  ///
     953  /// This function just returns a \ref GraphWriter class.
     954  /// \relates GraphWriter
     955  template <typename Graph>
     956  GraphWriter<Graph> graphWriter(const Graph& graph, const std::string& fn) {
     957    GraphWriter<Graph> tmp(graph, fn);
    935958    return tmp;
    936959  }
    937960
    938   /// \brief Return a \ref DigraphWriter class
    939   ///
    940   /// This function just returns a \ref DigraphWriter class.
    941   /// \relates DigraphWriter
    942   template <typename Digraph>
    943   DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
    944                                        const char* fn) {
    945     DigraphWriter<Digraph> tmp(digraph, fn);
     961  /// \brief Return a \ref GraphWriter class
     962  ///
     963  /// This function just returns a \ref GraphWriter class.
     964  /// \relates GraphWriter
     965  template <typename Graph>
     966  GraphWriter<Graph> graphWriter(const Graph& graph, const char* fn) {
     967    GraphWriter<Graph> tmp(graph, fn);
    946968    return tmp;
    947969  }
    948 
    949   template <typename Graph>
    950   class GraphWriter;
    951 
    952   template <typename Graph>
    953   GraphWriter<Graph> graphWriter(const Graph& graph,
    954                                  std::ostream& os = std::cout);
    955 
    956   template <typename Graph>
    957   GraphWriter<Graph> graphWriter(const Graph& graph, const std::string& fn);
    958 
    959   template <typename Graph>
    960   GraphWriter<Graph> graphWriter(const Graph& graph, const char *fn);
    961970
    962971  /// \ingroup lemon_io
     
    15261535    /// @}
    15271536  };
    1528 
    1529   /// \brief Return a \ref GraphWriter class
    1530   ///
    1531   /// This function just returns a \ref GraphWriter class.
    1532   /// \relates GraphWriter
    1533   template <typename Graph>
    1534   GraphWriter<Graph> graphWriter(const Graph& graph,
    1535                                  std::ostream& os = std::cout) {
    1536     GraphWriter<Graph> tmp(graph, os);
    1537     return tmp;
    1538   }
    1539 
    1540   /// \brief Return a \ref GraphWriter class
    1541   ///
    1542   /// This function just returns a \ref GraphWriter class.
    1543   /// \relates GraphWriter
    1544   template <typename Graph>
    1545   GraphWriter<Graph> graphWriter(const Graph& graph, const std::string& fn) {
    1546     GraphWriter<Graph> tmp(graph, fn);
    1547     return tmp;
    1548   }
    1549 
    1550   /// \brief Return a \ref GraphWriter class
    1551   ///
    1552   /// This function just returns a \ref GraphWriter class.
    1553   /// \relates GraphWriter
    1554   template <typename Graph>
    1555   GraphWriter<Graph> graphWriter(const Graph& graph, const char* fn) {
    1556     GraphWriter<Graph> tmp(graph, fn);
    1557     return tmp;
    1558   }
    15591537
    15601538  class SectionWriter;
  • lemon/list_graph.h

    r280 r317  
    414414    ///
    415415    ///\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
    417417    ///invalidated.
    418418    ///
  • lemon/maps.h

    r301 r320  
    4444  class MapBase {
    4545  public:
    46     /// \biref The key type of the map.
     46    /// \brief The key type of the map.
    4747    typedef K Key;
    4848    /// \brief The value type of the map.
     
    7474  };
    7575
    76   /// Returns a \ref NullMap class
    77 
    78   /// This function just returns a \ref NullMap class.
     76  /// Returns a \c NullMap class
     77
     78  /// This function just returns a \c NullMap class.
    7979  /// \relates NullMap
    8080  template <typename K, typename V>
     
    8989  /// value to each key.
    9090  ///
    91   /// In other aspects it is equivalent to \ref NullMap.
     91  /// In other aspects it is equivalent to \c NullMap.
    9292  /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap"
    9393  /// concept, but it absorbs the data written to it.
     
    134134  };
    135135
    136   /// Returns a \ref ConstMap class
    137 
    138   /// This function just returns a \ref ConstMap class.
     136  /// Returns a \c ConstMap class
     137
     138  /// This function just returns a \c ConstMap class.
    139139  /// \relates ConstMap
    140140  template<typename K, typename V>
     
    157157  /// value to each key.
    158158  ///
    159   /// In other aspects it is equivalent to \ref NullMap.
     159  /// In other aspects it is equivalent to \c NullMap.
    160160  /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap"
    161161  /// concept, but it absorbs the data written to it.
     
    183183  };
    184184
    185   /// Returns a \ref ConstMap class with inlined constant value
    186 
    187   /// This function just returns a \ref ConstMap class with inlined
     185  /// Returns a \c ConstMap class with inlined constant value
     186
     187  /// This function just returns a \c ConstMap class with inlined
    188188  /// constant value.
    189189  /// \relates ConstMap
     
    213213  };
    214214
    215   /// Returns an \ref IdentityMap class
    216 
    217   /// This function just returns an \ref IdentityMap class.
     215  /// Returns an \c IdentityMap class
     216
     217  /// This function just returns an \c IdentityMap class.
    218218  /// \relates IdentityMap
    219219  template<typename T>
     
    229229  /// values to integer keys from the range <tt>[0..size-1]</tt>.
    230230  /// It can be used with some data structures, for example
    231   /// \ref UnionFind, \ref BinHeap, when the used items are small
     231  /// \c UnionFind, \c BinHeap, when the used items are small
    232232  /// integers. This map conforms the \ref concepts::ReferenceMap
    233233  /// "ReferenceMap" concept.
     
    269269      : _vector(vector.begin(), vector.end()) {}
    270270
    271     /// Constructs the map from another \ref RangeMap.
     271    /// Constructs the map from another \c RangeMap.
    272272    template <typename V1>
    273273    RangeMap(const RangeMap<V1> &c)
     
    312312  };
    313313
    314   /// Returns a \ref RangeMap class
    315 
    316   /// This function just returns a \ref RangeMap class.
     314  /// Returns a \c RangeMap class
     315
     316  /// This function just returns a \c RangeMap class.
    317317  /// \relates RangeMap
    318318  template<typename V>
     
    321321  }
    322322
    323   /// \brief Returns a \ref RangeMap class created from an appropriate
     323  /// \brief Returns a \c RangeMap class created from an appropriate
    324324  /// \c std::vector
    325325
    326   /// This function just returns a \ref RangeMap class created from an
     326  /// This function just returns a \c RangeMap class created from an
    327327  /// appropriate \c std::vector.
    328328  /// \relates RangeMap
     
    389389      : _map(map.begin(), map.end()), _value(value) {}
    390390
    391     /// \brief Constructs the map from another \ref SparseMap.
     391    /// \brief Constructs the map from another \c SparseMap.
    392392    template<typename V1, typename Comp1>
    393393    SparseMap(const SparseMap<Key, V1, Comp1> &c)
     
    434434  };
    435435
    436   /// Returns a \ref SparseMap class
    437 
    438   /// This function just returns a \ref SparseMap class with specified
     436  /// Returns a \c SparseMap class
     437
     438  /// This function just returns a \c SparseMap class with specified
    439439  /// default value.
    440440  /// \relates SparseMap
     
    449449  }
    450450
    451   /// \brief Returns a \ref SparseMap class created from an appropriate
     451  /// \brief Returns a \c SparseMap class created from an appropriate
    452452  /// \c std::map
    453453
    454   /// This function just returns a \ref SparseMap class created from an
     454  /// This function just returns a \c SparseMap class created from an
    455455  /// appropriate \c std::map.
    456456  /// \relates SparseMap
     
    502502  };
    503503
    504   /// Returns a \ref ComposeMap class
    505 
    506   /// This function just returns a \ref ComposeMap class.
     504  /// Returns a \c ComposeMap class
     505
     506  /// This function just returns a \c ComposeMap class.
    507507  ///
    508508  /// If \c m1 and \c m2 are maps and the \c Value type of \c m2 is
     
    557557  };
    558558
    559   /// Returns a \ref CombineMap class
    560 
    561   /// This function just returns a \ref CombineMap class.
     559  /// Returns a \c CombineMap class
     560
     561  /// This function just returns a \c CombineMap class.
    562562  ///
    563563  /// For example, if \c m1 and \c m2 are both maps with \c double
     
    626626  };
    627627
    628   /// Returns a \ref FunctorToMap class
    629 
    630   /// This function just returns a \ref FunctorToMap class.
     628  /// Returns a \c FunctorToMap class
     629
     630  /// This function just returns a \c FunctorToMap class.
    631631  ///
    632632  /// This function is specialized for adaptable binary function
     
    685685  };
    686686
    687   /// Returns a \ref MapToFunctor class
    688 
    689   /// This function just returns a \ref MapToFunctor class.
     687  /// Returns a \c MapToFunctor class
     688
     689  /// This function just returns a \c MapToFunctor class.
    690690  /// \relates MapToFunctor
    691691  template<typename M>
     
    724724  };
    725725
    726   /// Returns a \ref ConvertMap class
    727 
    728   /// This function just returns a \ref ConvertMap class.
     726  /// Returns a \c ConvertMap class
     727
     728  /// This function just returns a \c ConvertMap class.
    729729  /// \relates ConvertMap
    730730  template<typename V, typename M>
     
    764764  };
    765765
    766   /// Returns a \ref ForkMap class
    767 
    768   /// This function just returns a \ref ForkMap class.
     766  /// Returns a \c ForkMap class
     767
     768  /// This function just returns a \c ForkMap class.
    769769  /// \relates ForkMap
    770770  template <typename M1, typename M2>
     
    808808  };
    809809
    810   /// Returns an \ref AddMap class
    811 
    812   /// This function just returns an \ref AddMap class.
     810  /// Returns an \c AddMap class
     811
     812  /// This function just returns an \c AddMap class.
    813813  ///
    814814  /// For example, if \c m1 and \c m2 are both maps with \c double
     
    856856  };
    857857
    858   /// Returns a \ref SubMap class
    859 
    860   /// This function just returns a \ref SubMap class.
     858  /// Returns a \c SubMap class
     859
     860  /// This function just returns a \c SubMap class.
    861861  ///
    862862  /// For example, if \c m1 and \c m2 are both maps with \c double
     
    905905  };
    906906
    907   /// Returns a \ref MulMap class
    908 
    909   /// This function just returns a \ref MulMap class.
     907  /// Returns a \c MulMap class
     908
     909  /// This function just returns a \c MulMap class.
    910910  ///
    911911  /// For example, if \c m1 and \c m2 are both maps with \c double
     
    953953  };
    954954
    955   /// Returns a \ref DivMap class
    956 
    957   /// This function just returns a \ref DivMap class.
     955  /// Returns a \c DivMap class
     956
     957  /// This function just returns a \c DivMap class.
    958958  ///
    959959  /// For example, if \c m1 and \c m2 are both maps with \c double
     
    10391039  };
    10401040
    1041   /// Returns a \ref ShiftMap class
    1042 
    1043   /// This function just returns a \ref ShiftMap class.
     1041  /// Returns a \c ShiftMap class
     1042
     1043  /// This function just returns a \c ShiftMap class.
    10441044  ///
    10451045  /// For example, if \c m is a map with \c double values and \c v is
     
    10531053  }
    10541054
    1055   /// Returns a \ref ShiftWriteMap class
    1056 
    1057   /// This function just returns a \ref ShiftWriteMap class.
     1055  /// Returns a \c ShiftWriteMap class
     1056
     1057  /// This function just returns a \c ShiftWriteMap class.
    10581058  ///
    10591059  /// For example, if \c m is a map with \c double values and \c v is
     
    11411141  };
    11421142
    1143   /// Returns a \ref ScaleMap class
    1144 
    1145   /// This function just returns a \ref ScaleMap class.
     1143  /// Returns a \c ScaleMap class
     1144
     1145  /// This function just returns a \c ScaleMap class.
    11461146  ///
    11471147  /// For example, if \c m is a map with \c double values and \c v is
     
    11551155  }
    11561156
    1157   /// Returns a \ref ScaleWriteMap class
    1158 
    1159   /// This function just returns a \ref ScaleWriteMap class.
     1157  /// Returns a \c ScaleWriteMap class
     1158
     1159  /// This function just returns a \c ScaleWriteMap class.
    11601160  ///
    11611161  /// For example, if \c m is a map with \c double values and \c v is
     
    12411241  };
    12421242
    1243   /// Returns a \ref NegMap class
    1244 
    1245   /// This function just returns a \ref NegMap class.
     1243  /// Returns a \c NegMap class
     1244
     1245  /// This function just returns a \c NegMap class.
    12461246  ///
    12471247  /// For example, if \c m is a map with \c double values, then
     
    12541254  }
    12551255
    1256   /// Returns a \ref NegWriteMap class
    1257 
    1258   /// This function just returns a \ref NegWriteMap class.
     1256  /// Returns a \c NegWriteMap class
     1257
     1258  /// This function just returns a \c NegWriteMap class.
    12591259  ///
    12601260  /// For example, if \c m is a map with \c double values, then
     
    12971297  };
    12981298
    1299   /// Returns an \ref AbsMap class
    1300 
    1301   /// This function just returns an \ref AbsMap class.
     1299  /// Returns an \c AbsMap class
     1300
     1301  /// This function just returns an \c AbsMap class.
    13021302  ///
    13031303  /// For example, if \c m is a map with \c double values, then
     
    13461346  };
    13471347
    1348   /// Returns a \ref TrueMap class
    1349 
    1350   /// This function just returns a \ref TrueMap class.
     1348  /// Returns a \c TrueMap class
     1349
     1350  /// This function just returns a \c TrueMap class.
    13511351  /// \relates TrueMap
    13521352  template<typename K>
     
    13831383  };
    13841384
    1385   /// Returns a \ref FalseMap class
    1386 
    1387   /// This function just returns a \ref FalseMap class.
     1385  /// Returns a \c FalseMap class
     1386
     1387  /// This function just returns a \c FalseMap class.
    13881388  /// \relates FalseMap
    13891389  template<typename K>
     
    14301430  };
    14311431
    1432   /// Returns an \ref AndMap class
    1433 
    1434   /// This function just returns an \ref AndMap class.
     1432  /// Returns an \c AndMap class
     1433
     1434  /// This function just returns an \c AndMap class.
    14351435  ///
    14361436  /// For example, if \c m1 and \c m2 are both maps with \c bool values,
     
    14781478  };
    14791479
    1480   /// Returns an \ref OrMap class
    1481 
    1482   /// This function just returns an \ref OrMap class.
     1480  /// Returns an \c OrMap class
     1481
     1482  /// This function just returns an \c OrMap class.
    14831483  ///
    14841484  /// For example, if \c m1 and \c m2 are both maps with \c bool values,
     
    15451545  };
    15461546
    1547   /// Returns a \ref NotMap class
    1548 
    1549   /// This function just returns a \ref NotMap class.
     1547  /// Returns a \c NotMap class
     1548
     1549  /// This function just returns a \c NotMap class.
    15501550  ///
    15511551  /// For example, if \c m is a map with \c bool values, then
     
    15581558  }
    15591559
    1560   /// Returns a \ref NotWriteMap class
    1561 
    1562   /// This function just returns a \ref NotWriteMap class.
     1560  /// Returns a \c NotWriteMap class
     1561
     1562  /// This function just returns a \c NotWriteMap class.
    15631563  ///
    15641564  /// For example, if \c m is a map with \c bool values, then
     
    16061606  };
    16071607
    1608   /// Returns an \ref EqualMap class
    1609 
    1610   /// This function just returns an \ref EqualMap class.
     1608  /// Returns an \c EqualMap class
     1609
     1610  /// This function just returns an \c EqualMap class.
    16111611  ///
    16121612  /// For example, if \c m1 and \c m2 are maps with keys and values of
     
    16541654  };
    16551655
    1656   /// Returns an \ref LessMap class
    1657 
    1658   /// This function just returns an \ref LessMap class.
     1656  /// Returns an \c LessMap class
     1657
     1658  /// This function just returns an \c LessMap class.
    16591659  ///
    16601660  /// For example, if \c m1 and \c m2 are maps with keys and values of
     
    16831683
    16841684  }
     1685
     1686  /// @}
     1687
     1688  /// \addtogroup maps
     1689  /// @{
    16851690
    16861691  /// \brief Writable bool map for logging each \c true assigned element
     
    17461751  };
    17471752
    1748   /// Returns a \ref LoggerBoolMap class
    1749 
    1750   /// This function just returns a \ref LoggerBoolMap class.
     1753  /// Returns a \c LoggerBoolMap class
     1754
     1755  /// This function just returns a \c LoggerBoolMap class.
    17511756  ///
    17521757  /// The most important usage of it is storing certain nodes or arcs
     
    17681773  /// \note LoggerBoolMap is just \ref concepts::WriteMap "writable", so
    17691774  /// it cannot be used when a readable map is needed, for example as
    1770   /// \c ReachedMap for \ref Bfs, \ref Dfs and \ref Dijkstra algorithms.
     1775  /// \c ReachedMap for \c Bfs, \c Dfs and \c Dijkstra algorithms.
    17711776  ///
    17721777  /// \relates LoggerBoolMap
     
    17751780    return LoggerBoolMap<Iterator>(it);
    17761781  }
     1782
     1783  /// @}
     1784
     1785  /// \addtogroup graph_maps
     1786  /// @{
    17771787
    17781788  /// Provides an immutable and unique id for each item in the graph.
     
    18621872    ///
    18631873    /// Constructor
    1864     /// \param _digraph The digraph that the map belongs to.
     1874    /// \param digraph The digraph that the map belongs to.
    18651875    explicit SourceMap(const Digraph& digraph) : _digraph(digraph) {}
    18661876
     
    18781888  };
    18791889
    1880   /// \brief Returns a \ref SourceMap class.
    1881   ///
    1882   /// This function just returns an \ref SourceMap class.
     1890  /// \brief Returns a \c SourceMap class.
     1891  ///
     1892  /// This function just returns an \c SourceMap class.
    18831893  /// \relates SourceMap
    18841894  template <typename Digraph>
     
    19011911    ///
    19021912    /// Constructor
    1903     /// \param _digraph The digraph that the map belongs to.
     1913    /// \param digraph The digraph that the map belongs to.
    19041914    explicit TargetMap(const Digraph& digraph) : _digraph(digraph) {}
    19051915
     
    19171927  };
    19181928
    1919   /// \brief Returns a \ref TargetMap class.
    1920   ///
    1921   /// This function just returns a \ref TargetMap class.
     1929  /// \brief Returns a \c TargetMap class.
     1930  ///
     1931  /// This function just returns a \c TargetMap class.
    19221932  /// \relates TargetMap
    19231933  template <typename Digraph>
     
    19401950    ///
    19411951    /// Constructor
    1942     /// \param _graph The graph that the map belongs to.
     1952    /// \param graph The graph that the map belongs to.
    19431953    explicit ForwardMap(const Graph& graph) : _graph(graph) {}
    19441954
     
    19561966  };
    19571967
    1958   /// \brief Returns a \ref ForwardMap class.
    1959   ///
    1960   /// This function just returns an \ref ForwardMap class.
     1968  /// \brief Returns a \c ForwardMap class.
     1969  ///
     1970  /// This function just returns an \c ForwardMap class.
    19611971  /// \relates ForwardMap
    19621972  template <typename Graph>
     
    19791989    ///
    19801990    /// Constructor
    1981     /// \param _graph The graph that the map belongs to.
     1991    /// \param graph The graph that the map belongs to.
    19821992    explicit BackwardMap(const Graph& graph) : _graph(graph) {}
    19831993
     
    19952005  };
    19962006
    1997   /// \brief Returns a \ref BackwardMap class
    1998 
    1999   /// This function just returns a \ref BackwardMap class.
     2007  /// \brief Returns a \c BackwardMap class
     2008
     2009  /// This function just returns a \c BackwardMap class.
    20002010  /// \relates BackwardMap
    20012011  template <typename Graph>
  • lemon/path.h

    r236 r317  
    850850    int empty() const { return len == 0; }
    851851
    852     /// \break Erase all arcs in the digraph.
     852    /// \brief Erase all arcs in the digraph.
    853853    void clear() {
    854854      len = 0;
  • lemon/smart_graph.h

    r280 r317  
    366366
    367367      ///This constructor immediately makes a snapshot of the digraph.
    368       ///\param _g The digraph we make a snapshot of.
     368      ///\param graph The digraph we make a snapshot of.
    369369      Snapshot(SmartDigraph &graph) : _graph(&graph) {
    370370        node_num=_graph->nodes.size();
     
    378378      ///This function can be called more than once. In case of a repeated
    379379      ///call, the previous snapshot gets lost.
    380       ///\param _g The digraph we make the snapshot of.
     380      ///\param graph The digraph we make the snapshot of.
    381381      void save(SmartDigraph &graph)
    382382      {
     
    776776
    777777      ///This constructor immediately makes a snapshot of the digraph.
    778       ///\param g The digraph we make a snapshot of.
     778      ///\param graph The digraph we make a snapshot of.
    779779      Snapshot(SmartGraph &graph) {
    780780        graph.saveSnapshot(*this);
     
    787787      ///This function can be called more than once. In case of a repeated
    788788      ///call, the previous snapshot gets lost.
    789       ///\param g The digraph we make the snapshot of.
     789      ///\param graph The digraph we make the snapshot of.
    790790      void save(SmartGraph &graph)
    791791      {
  • lemon/time_measure.h

    r280 r318  
    312312    ///Basically a Timer can be either running or stopped,
    313313    ///but it provides a bit finer control on the execution.
    314     ///The \ref Timer also counts the number of \ref start()
    315     ///executions, and is stops only after the same amount (or more)
    316     ///\ref stop() "stop()"s. This can be useful e.g. to compute
    317     ///the running time
     314    ///The \ref lemon::Timer "Timer" also counts the number of
     315    ///\ref lemon::Timer::start() "start()" executions, and it stops
     316    ///only after the same amount (or more) \ref lemon::Timer::stop()
     317    ///"stop()"s. This can be useful e.g. to compute the running time
    318318    ///of recursive functions.
    319     ///
    320319
    321320    ///@{
     
    473472  };
    474473
    475   ///Same as \ref Timer but prints a report on destruction.
     474  ///Same as Timer but prints a report on destruction.
    476475
    477476  ///Same as \ref Timer but prints a report on destruction.
     
    492491    std::ostream &_os;
    493492  public:
    494     ///\e
    495 
     493    ///Constructor
     494
     495    ///Constructor.
    496496    ///\param title This text will be printed before the ellapsed time.
    497497    ///\param os The stream to print the report to.
    498498    ///\param run Sets whether the timer should start immediately.
    499 
    500499    TimeReport(std::string title,std::ostream &os=std::cerr,bool run=true)
    501500      : Timer(run), _title(title), _os(os){}
    502     ///\e Prints the ellapsed time on destruction.
     501    ///Destructor that prints the ellapsed time
    503502    ~TimeReport()
    504503    {
     
    507506  };
    508507
    509   ///'Do nothing' version of \ref TimeReport
     508  ///'Do nothing' version of TimeReport
    510509
    511510  ///\sa TimeReport
  • tools/Makefile.am

    r146 r314  
    22
    33bin_PROGRAMS +=
     4dist_bin_SCRIPTS += tools/lemon-0.x-to-1.x.sh
    45
    56endif WANT_TOOLS
Note: See TracChangeset for help on using the changeset viewer.