COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

Changes in / [317:a0ab96ad65fe:316:689f24ee83e6] in lemon-main


Ignore:
Files:
1 added
2 deleted
38 edited

Legend:

Unmodified
Added
Removed

  • Makefile.am

    r310 r227  
    2525bin_PROGRAMS =
    2626check_PROGRAMS =
    27 dist_bin_SCRIPTS =
    2827TESTS =
    2928XFAIL_TESTS =
    … …  
    3332include doc/Makefile.am
    3433include demo/Makefile.am
     34include benchmark/Makefile.am
    3535include tools/Makefile.am
    3636

  • README

    r310 r246  
    3838   Contains programs to check the integrity and correctness of LEMON.
    3939
     40benchmark/
     41 
     42   Contains programs for measuring the performance of algorithms.
     43
    4044tools/
    4145

  • configure.ac

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

  • demo/arg_parser_demo.cc

    r311 r209  
    2828
    2929using namespace lemon;
    30 int main(int argc, char **argv)
     30int main(int argc, const char **argv)
    3131{
    3232  // Initialize the argument parser

  • demo/graph_to_eps_demo.cc

    r313 r220  
    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 graph maps.
     29/// using appropriate \ref maps-page "graph maps".
    3030///
    3131/// \include graph_to_eps_demo.cc

  • doc/Makefile.am

    r317 r316  
    88        doc/license.dox \
    99        doc/mainpage.dox \
    10         doc/migration.dox \
    1110        doc/named-param.dox \
    1211        doc/namespaces.dox \

  • doc/groups.dox

    r314 r236  
    5555You are free to use the graph structure that fit your requirements
    5656the best, most graph algorithms and auxiliary data structures can be used
    57 with any graph structure.
    58 
    59 <b>See also:</b> \ref graph_concepts "Graph Structure Concepts".
     57with any graph structures.
    6058*/
    6159
    … …  
    7775This group describes the map structures implemented in LEMON.
    7876
    79 LEMON provides several special purpose maps and map adaptors that e.g. combine
     77LEMON provides several special purpose maps that e.g. combine
    8078new maps from existing ones.
    81 
    82 <b>See also:</b> \ref map_concepts "Map Concepts".
    8379*/
    8480
    … …  
    9187values to the nodes and arcs of graphs.
    9288*/
     89
    9390
    9491/**
    … …  
    108105algorithms.  If a function type algorithm is called then the function
    109106type map adaptors can be used comfortable. For example let's see the
    110 usage of map adaptors with the \c graphToEps() function.
     107usage of map adaptors with the \c digraphToEps() function.
    111108\code
    112109  Color nodeColor(int deg) {
    … …  
    122119  Digraph::NodeMap<int> degree_map(graph);
    123120
    124   graphToEps(graph, "graph.eps")
     121  digraphToEps(graph, "graph.eps")
    125122    .coords(coords).scaleToA4().undirected()
    126123    .nodeColors(composeMap(functorToMap(nodeColor), degree_map))
    … …  
    128125\endcode
    129126The \c functorToMap() function makes an \c int to \c Color map from the
    130 \c nodeColor() function. The \c composeMap() compose the \c degree_map
     127\e nodeColor() function. The \c composeMap() compose the \e degree_map
    131128and the previously created map. The composed map is a proper function to
    132129get the color of each node.
    … …  
    177174
    178175\sa lemon::concepts::Path
     176
    179177*/
    180178
    … …  
    188186*/
    189187
     188
    190189/**
    191190@defgroup algs Algorithms
    … …  
    203202
    204203This group describes the common graph search algorithms like
    205 Breadth-First Search (BFS) and Depth-First Search (DFS).
    206 */
    207 
    208 /**
    209 @defgroup shortest_path Shortest Path Algorithms
     204Breadth-first search (Bfs) and Depth-first search (Dfs).
     205*/
     206
     207/**
     208@defgroup shortest_path Shortest Path algorithms
    210209@ingroup algs
    211210\brief Algorithms for finding shortest paths.
    … …  
    215214
    216215/**
    217 @defgroup max_flow Maximum Flow Algorithms
     216@defgroup max_flow Maximum Flow algorithms
    218217@ingroup algs
    219218\brief Algorithms for finding maximum flows.
    … …  
    243242provides functions to query the minimum cut, which is the dual linear
    244243programming problem of the maximum flow.
    245 */
    246 
    247 /**
    248 @defgroup min_cost_flow Minimum Cost Flow Algorithms
     244
     245*/
     246
     247/**
     248@defgroup min_cost_flow Minimum Cost Flow algorithms
    249249@ingroup algs
    250250
    … …  
    256256
    257257/**
    258 @defgroup min_cut Minimum Cut Algorithms
     258@defgroup min_cut Minimum Cut algorithms
    259259@ingroup algs
    260260
    … …  
    283283If you want to find minimum cut just between two distinict nodes,
    284284please see the \ref max_flow "Maximum Flow page".
    285 */
    286 
    287 /**
    288 @defgroup graph_prop Connectivity and Other Graph Properties
     285
     286*/
     287
     288/**
     289@defgroup graph_prop Connectivity and other graph properties
    289290@ingroup algs
    290291\brief Algorithms for discovering the graph properties
    … …  
    298299
    299300/**
    300 @defgroup planar Planarity Embedding and Drawing
     301@defgroup planar Planarity embedding and drawing
    301302@ingroup algs
    302303\brief Algorithms for planarity checking, embedding and drawing
    … …  
    310311
    311312/**
    312 @defgroup matching Matching Algorithms
     313@defgroup matching Matching algorithms
    313314@ingroup algs
    314315\brief Algorithms for finding matchings in graphs and bipartite graphs.
    … …  
    348349\image html bipartite_matching.png
    349350\image latex bipartite_matching.eps "Bipartite Matching" width=\textwidth
    350 */
    351 
    352 /**
    353 @defgroup spantree Minimum Spanning Tree Algorithms
     351
     352*/
     353
     354/**
     355@defgroup spantree Minimum Spanning Tree algorithms
    354356@ingroup algs
    355357\brief Algorithms for finding a minimum cost spanning tree in a graph.
    … …  
    359361*/
    360362
    361 /**
    362 @defgroup auxalg Auxiliary Algorithms
     363
     364/**
     365@defgroup auxalg Auxiliary algorithms
    363366@ingroup algs
    364367\brief Auxiliary algorithms implemented in LEMON.
    … …  
    369372
    370373/**
    371 @defgroup approx Approximation Algorithms
    372 @ingroup algs
     374@defgroup approx Approximation algorithms
    373375\brief Approximation algorithms.
    374376
    … …  
    384386This group describes some general optimization frameworks
    385387implemented in LEMON.
    386 */
    387 
    388 /**
    389 @defgroup lp_group Lp and Mip Solvers
     388
     389*/
     390
     391/**
     392@defgroup lp_group Lp and Mip solvers
    390393@ingroup gen_opt_group
    391394\brief Lp and Mip solver interfaces for LEMON.
    … …  
    394397various LP solvers could be used in the same manner with this
    395398interface.
    396 */
    397 
    398 /**
    399 @defgroup lp_utils Tools for Lp and Mip Solvers
     399
     400*/
     401
     402/**
     403@defgroup lp_utils Tools for Lp and Mip solvers
    400404@ingroup lp_group
    401405\brief Helper tools to the Lp and Mip solvers.
    … …  
    438442
    439443/**
    440 @defgroup timecount Time Measuring and Counting
     444@defgroup timecount Time measuring and Counting
    441445@ingroup misc
    442446\brief Simple tools for measuring the performance of algorithms.
    … …  
    444448This group describes simple tools for measuring the performance
    445449of algorithms.
     450*/
     451
     452/**
     453@defgroup graphbits Tools for Graph Implementation
     454@ingroup utils
     455\brief Tools to make it easier to create graphs.
     456
     457This group describes the tools that makes it easier to create graphs and
     458the maps that dynamically update with the graph changes.
    446459*/
    447460
    … …  
    459472
    460473This group describes the tools for importing and exporting graphs
    461 and graph related data. Now it supports the \ref lgf-format
    462 "LEMON Graph Format", the \c DIMACS format and the encapsulated
    463 postscript (EPS) format.
     474and graph related data. Now it supports the LEMON format, the
     475\c DIMACS format and the encapsulated postscript (EPS) format.
    464476*/
    465477
    … …  
    467479@defgroup lemon_io LEMON Input-Output
    468480@ingroup io_group
    469 \brief Reading and writing LEMON Graph Format.
     481\brief Reading and writing \ref lgf-format "LEMON Graph Format".
    470482
    471483This group describes methods for reading and writing
    … …  
    474486
    475487/**
    476 @defgroup eps_io Postscript Exporting
     488@defgroup eps_io Postscript exporting
    477489@ingroup io_group
    478490\brief General \c EPS drawer and graph exporter
    … …  
    481493graph exporting tools.
    482494*/
     495
    483496
    484497/**
    … …  
    509522
    510523- Finally, They can serve as a skeleton of a new implementation of a concept.
    511 */
     524
     525*/
     526
    512527
    513528/**
    … …  
    520535*/
    521536
    522 /**
    523 @defgroup map_concepts Map Concepts
    524 @ingroup concept
    525 \brief Skeleton and concept checking classes for maps
    526 
    527 This group describes the skeletons and concept checking classes of maps.
     537/* --- Unused group
     538@defgroup experimental Experimental Structures and Algorithms
     539This group describes some Experimental structures and algorithms.
     540The stuff here is subject to change.
    528541*/
    529542

  • doc/lgf.dox

    r313 r236  
    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

    r314 r209  
    5151If you
    5252want to see how LEMON works, see
    53 some \ref demoprograms "demo programs".
     53some \ref demoprograms "demo programs"!
    5454
    5555If you know what you are looking for then try to find it under the
    … …  
    5757section.
    5858
    59 If you are a user of the old (0.x) series of LEMON, please check out the
    60 \ref migration "Migration Guide" for the backward incompatibilities.
     59
    6160*/

  • lemon/arg_parser.cc

    r311 r214  
    2727  }
    2828
    29   ArgParser::ArgParser(int argc, const char * const *argv)
    30     :_argc(argc), _argv(argv), _command_name(argv[0]) {
     29  ArgParser::ArgParser(int argc, const char **argv) :_argc(argc), _argv(argv),
     30                                                    _command_name(argv[0]) {
    3131    funcOption("-help","Print a short help message",_showHelp,this);
    3232    synonym("help","-help");
    3333    synonym("h","-help");
     34
    3435  }
    3536

  • lemon/arg_parser.h

    r311 r290  
    4747
    4848    int _argc;
    49     const char * const *_argv;
     49    const char **_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 * const *argv);
     122    ArgParser(int argc, const char **argv);
    123123
    124124    ~ArgParser();

  • lemon/bfs.h

    r301 r292  
    5050    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    5151    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
    52     ///Instantiates a PredMap.
    53 
    54     ///This function instantiates a PredMap.
     52    ///Instantiates a \ref PredMap.
     53
     54    ///This function instantiates a \ref PredMap.
    5555    ///\param g is the digraph, to which we would like to define the
    56     ///PredMap.
     56    ///\ref 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 ProcessedMap.
    68 
    69     ///This function instantiates a ProcessedMap.
     67    ///Instantiates a \ref ProcessedMap.
     68
     69    ///This function instantiates a \ref ProcessedMap.
    7070    ///\param g is the digraph, to which
    71     ///we would like to define the ProcessedMap
     71    ///we would like to define the \ref 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 ReachedMap.
    87 
    88     ///This function instantiates a ReachedMap.
     86    ///Instantiates a \ref ReachedMap.
     87
     88    ///This function instantiates a \ref ReachedMap.
    8989    ///\param g is the digraph, to which
    90     ///we would like to define the ReachedMap.
     90    ///we would like to define the \ref 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 DistMap.
    102 
    103     ///This function instantiates a DistMap.
     101    ///Instantiates a \ref DistMap.
     102
     103    ///This function instantiates a \ref DistMap.
    104104    ///\param g is the digraph, to which we would like to define the
    105     ///DistMap.
     105    ///\ref DistMap.
    106106    static DistMap *createDistMap(const Digraph &g)
    107107    {
    … …  
    228228    };
    229229    ///\brief \ref named-templ-param "Named parameter" for setting
    230     ///PredMap type.
     230    ///\ref PredMap type.
    231231    ///
    232232    ///\ref named-templ-param "Named parameter" for setting
    233     ///PredMap type.
     233    ///\ref 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     ///DistMap type.
     249    ///\ref DistMap type.
    250250    ///
    251251    ///\ref named-templ-param "Named parameter" for setting
    252     ///DistMap type.
     252    ///\ref 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     ///ReachedMap type.
     268    ///\ref ReachedMap type.
    269269    ///
    270270    ///\ref named-templ-param "Named parameter" for setting
    271     ///ReachedMap type.
     271    ///\ref 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     ///ProcessedMap type.
     287    ///\ref ProcessedMap type.
    288288    ///
    289289    ///\ref named-templ-param "Named parameter" for setting
    290     ///ProcessedMap type.
     290    ///\ref 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     ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     305    ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
    306306    ///
    307307    ///\ref named-templ-param "Named parameter" for setting
    308     ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     308    ///\ref 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 PredMap.
    839 
    840     ///This function instantiates a PredMap.
     838    ///Instantiates a \ref PredMap.
     839
     840    ///This function instantiates a \ref PredMap.
    841841    ///\param g is the digraph, to which we would like to define the
    842     ///PredMap.
     842    ///\ref 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 ProcessedMap.
    855 
    856     ///This function instantiates a ProcessedMap.
     854    ///Instantiates a \ref ProcessedMap.
     855
     856    ///This function instantiates a \ref ProcessedMap.
    857857    ///\param g is the digraph, to which
    858     ///we would like to define the ProcessedMap.
     858    ///we would like to define the \ref 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 ReachedMap.
    874 
    875     ///This function instantiates a ReachedMap.
     873    ///Instantiates a \ref ReachedMap.
     874
     875    ///This function instantiates a \ref ReachedMap.
    876876    ///\param g is the digraph, to which
    877     ///we would like to define the ReachedMap.
     877    ///we would like to define the \ref 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 DistMap.
    889 
    890     ///This function instantiates a DistMap.
     888    ///Instantiates a \ref DistMap.
     889
     890    ///This function instantiates a \ref DistMap.
    891891    ///\param g is the digraph, to which we would like to define
    892     ///the DistMap
     892    ///the \ref DistMap
    893893    static DistMap *createDistMap(const Digraph &g)
    894894    {
    … …  
    903903  };
    904904
    905   /// Default traits class used by BfsWizard
     905  /// Default traits class used by \ref BfsWizard
    906906
    907907  /// To make it easier to use Bfs algorithm
    … …  
    10691069    };
    10701070    ///\brief \ref named-func-param "Named parameter"
    1071     ///for setting PredMap object.
     1071    ///for setting \ref PredMap object.
    10721072    ///
    10731073    ///\ref named-func-param "Named parameter"
    1074     ///for setting PredMap object.
     1074    ///for setting \ref 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 ReachedMap object.
     1089    ///for setting \ref ReachedMap object.
    10901090    ///
    10911091    /// \ref named-func-param "Named parameter"
    1092     ///for setting ReachedMap object.
     1092    ///for setting \ref 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 DistMap object.
     1107    ///for setting \ref DistMap object.
    11081108    ///
    11091109    /// \ref named-func-param "Named parameter"
    1110     ///for setting DistMap object.
     1110    ///for setting \ref 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 ProcessedMap object.
     1125    ///for setting \ref ProcessedMap object.
    11261126    ///
    11271127    /// \ref named-func-param "Named parameter"
    1128     ///for setting ProcessedMap object.
     1128    ///for setting \ref 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 ReachedMap.
    1271     ///
    1272     /// This function instantiates a ReachedMap.
     1270    /// \brief Instantiates a \ref ReachedMap.
     1271    ///
     1272    /// This function instantiates a \ref ReachedMap.
    12731273    /// \param digraph is the digraph, to which
    1274     /// we would like to define the ReachedMap.
     1274    /// we would like to define the \ref ReachedMap.
    12751275    static ReachedMap *createReachedMap(const Digraph &digraph) {
    12761276      return new ReachedMap(digraph);

  • lemon/bits/alteration_notifier.h

    r314 r236  
    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 \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.
     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.
    9697
    9798  template <typename _Container, typename _Item>
    … …  
    104105    typedef _Item Item;
    105106
    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.
     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.
    114115    struct ImmediateDetach {};
    115116
    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.
     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
    130132    class ObserverBase {
    131133    protected:
    … …  
    134136      friend class AlterationNotifier;
    135137
    136       // \brief Default constructor.
    137       //
    138       // Default constructor for ObserverBase.
     138      /// \brief Default constructor.
     139      ///
     140      /// Default constructor for ObserverBase.
     141      ///
    139142      ObserverBase() : _notifier(0) {}
    140143
    141       // \brief Constructor which attach the observer into notifier.
    142       //
    143       // Constructor which attach the observer into notifier.
     144      /// \brief Constructor which attach the observer into notifier.
     145      ///
     146      /// Constructor which attach the observer into notifier.
    144147      ObserverBase(AlterationNotifier& nf) {
    145148        attach(nf);
    146149      }
    147150
    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.
     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.
    152155      ObserverBase(const ObserverBase& copy) {
    153156        if (copy.attached()) {
    … …  
    156159      }
    157160
    158       // \brief Destructor
     161      /// \brief Destructor
    159162      virtual ~ObserverBase() {
    160163        if (attached()) {
    … …  
    163166      }
    164167
    165       // \brief Attaches the observer into an AlterationNotifier.
    166       //
    167       // This member attaches the observer into an AlterationNotifier.
     168      /// \brief Attaches the observer into an AlterationNotifier.
     169      ///
     170      /// This member attaches the observer into an AlterationNotifier.
     171      ///
    168172      void attach(AlterationNotifier& nf) {
    169173        nf.attach(*this);
    170174      }
    171175
    172       // \brief Detaches the observer into an AlterationNotifier.
    173       //
    174       // This member detaches the observer from an AlterationNotifier.
     176      /// \brief Detaches the observer into an AlterationNotifier.
     177      ///
     178      /// This member detaches the observer from an AlterationNotifier.
     179      ///
    175180      void detach() {
    176181        _notifier->detach(*this);
    177182      }
    178183
    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.
     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      ///
    184190      Notifier* notifier() const { return const_cast<Notifier*>(_notifier); }
    185191
    186       // Gives back true when the observer is attached into a notifier.
     192      /// Gives back true when the observer is attached into a notifier.
    187193      bool attached() const { return _notifier != 0; }
    188194
    … …  
    196202      typename std::list<ObserverBase*>::iterator _index;
    197203
    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.
     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.
    204210      virtual void add(const Item&) = 0;
    205211
    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.
     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.
    212218      virtual void add(const std::vector<Item>& items) = 0;
    213219
    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.
     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.
    220226      virtual void erase(const Item&) = 0;
    221227
    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.
     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.
    228234      virtual void erase(const std::vector<Item>& items) = 0;
    229235
    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.
     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
    236243      virtual void build() = 0;
    237244
    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.
     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.
    244251      virtual void clear() = 0;
    245252
    … …  
    256263  public:
    257264
    258     // \brief Default constructor.
    259     //
    260     // The default constructor of the AlterationNotifier.
    261     // It creates an empty notifier.
     265    /// \brief Default constructor.
     266    ///
     267    /// The default constructor of the AlterationNotifier.
     268    /// It creates an empty notifier.
    262269    AlterationNotifier()
    263270      : container(0) {}
    264271
    265     // \brief Constructor.
    266     //
    267     // Constructor with the observed container parameter.
     272    /// \brief Constructor.
     273    ///
     274    /// Constructor with the observed container parameter.
    268275    AlterationNotifier(const Container& _container)
    269276      : container(&_container) {}
    270277
    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.
     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.
    276283    AlterationNotifier(const AlterationNotifier& _notifier)
    277284      : container(_notifier.container) {}
    278285
    279     // \brief Destructor.
    280     //
    281     // Destructor of the AlterationNotifier.
     286    /// \brief Destructor.
     287    ///
     288    /// Destructor of the AlterationNotifier.
     289    ///
    282290    ~AlterationNotifier() {
    283291      typename Observers::iterator it;
    … …  
    287295    }
    288296
    289     // \brief Sets the container.
    290     //
    291     // Sets the container.
     297    /// \brief Sets the container.
     298    ///
     299    /// Sets the container.
    292300    void setContainer(const Container& _container) {
    293301      container = &_container;
    … …  
    300308  public:
    301309
    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.
     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.
    306316    void first(Item& item) const {
    307317      container->first(item);
    308318    }
    309319
    310     // \brief Next item in the container.
    311     //
    312     // Returns the next item in the container. It is
    313     // for iterate on the container.
     320    /// \brief Next item in the container.
     321    ///
     322    /// Returns the next item in the container. It is
     323    /// for iterate on the container.
    314324    void next(Item& item) const {
    315325      container->next(item);
    316326    }
    317327
    318     // \brief Returns the id of the item.
    319     //
    320     // Returns the id of the item provided by the container.
     328    /// \brief Returns the id of the item.
     329    ///
     330    /// Returns the id of the item provided by the container.
    321331    int id(const Item& item) const {
    322332      return container->id(item);
    323333    }
    324334
    325     // \brief Returns the maximum id of the container.
    326     //
    327     // Returns the maximum id of the container.
     335    /// \brief Returns the maximum id of the container.
     336    ///
     337    /// Returns the maximum id of the container.
    328338    int maxId() const {
    329339      return container->maxId(Item());
    … …  
    345355  public:
    346356
    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.
     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    ///
    352363    void add(const Item& item) {
    353364      typename Observers::reverse_iterator it;
    … …  
    365376    }
    366377
    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.
     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    ///
    372384    void add(const std::vector<Item>& items) {
    373385      typename Observers::reverse_iterator it;
    … …  
    385397    }
    386398
    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.
     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    ///
    392405    void erase(const Item& item) throw() {
    393406      typename Observers::iterator it = _observers.begin();
    … …  
    404417    }
    405418
    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.
     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    ///
    411425    void erase(const std::vector<Item>& items) {
    412426      typename Observers::iterator it = _observers.begin();
    … …  
    423437    }
    424438
    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.
     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.
    430444    void build() {
    431445      typename Observers::reverse_iterator it;
    … …  
    443457    }
    444458
    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.
     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.
    450464    void clear() {
    451465      typename Observers::iterator it = _observers.begin();

  • lemon/bits/array_map.h

    r314 r263  
    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

    r314 r289  
    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

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

    r314 r209  
    2020#define LEMON_BITS_DEFAULT_MAP_H
    2121
     22
    2223#include <lemon/bits/array_map.h>
    2324#include <lemon/bits/vector_map.h>
    2425//#include <lemon/bits/debug_map.h>
    2526
    26 //\ingroup graphbits
    27 //\file
    28 //\brief Graph maps that construct and destruct their elements dynamically.
     27///\ingroup graphbits
     28///\file
     29///\brief Graph maps that construct and destruct their elements dynamically.
    2930
    3031namespace lemon {
    … …  
    149150// #endif
    150151
    151   // DefaultMap class
     152  /// \e
    152153  template <typename _Graph, typename _Item, typename _Value>
    153154  class DefaultMap

  • lemon/bits/enable_if.h

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

    r314 r263  
    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

    r314 r263  
    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

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

    r314 r280  
    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

    r313 r209  
    9393  extern const Color DARK_CYAN;
    9494
    95   ///Map <tt>int</tt>s to different <tt>Color</tt>s
     95  ///Map <tt>int</tt>s to different \ref Color "Color"s
    9696
    9797  ///This map assigns one of the predefined \ref Color "Color"s to

  • lemon/concepts/graph_components.h

    r313 r263  
    983983    ///
    984984    /// This class describes the common interface of the graph maps
    985     /// (NodeMap, ArcMap), that is maps that can be used to
     985    /// (NodeMap, ArcMap), that is \ref maps-page "maps" which 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

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

  • lemon/core.h

    r313 r282  
    5959  /// @{
    6060
    61   ///Create convenience typedefs for the digraph types and iterators
     61  ///Create convenient 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 convenience typedefs for the digraph types and iterators
     83  typedef Digraph::ArcMap<double> DoubleArcMap;
     84
     85  ///Create convenient 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 convenience typedefs for the graph types and iterators
     103  typedef typename Digraph::template ArcMap<double> DoubleArcMap;
     104
     105  ///Create convenient 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 convenience typedefs for the graph types and iterators
     122  typedef Graph::EdgeMap<double> DoubleEdgeMap;
     123
     124  ///Create convenient 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>),
    1703     ///where <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>), where
     1703    ///<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,
    1821     ///where <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, where
     1821    ///<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

    r313 r292  
    5151    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    5252    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
    53     ///Instantiates a PredMap.
    54 
    55     ///This function instantiates a PredMap.
     53    ///Instantiates a \ref PredMap.
     54
     55    ///This function instantiates a \ref PredMap.
    5656    ///\param g is the digraph, to which we would like to define the
    57     ///PredMap.
     57    ///\ref 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 ProcessedMap.
    69 
    70     ///This function instantiates a ProcessedMap.
     68    ///Instantiates a \ref ProcessedMap.
     69
     70    ///This function instantiates a \ref ProcessedMap.
    7171    ///\param g is the digraph, to which
    72     ///we would like to define the ProcessedMap
     72    ///we would like to define the \ref 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 ReachedMap.
    88 
    89     ///This function instantiates a ReachedMap.
     87    ///Instantiates a \ref ReachedMap.
     88
     89    ///This function instantiates a \ref ReachedMap.
    9090    ///\param g is the digraph, to which
    91     ///we would like to define the ReachedMap.
     91    ///we would like to define the \ref 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 DistMap.
    103 
    104     ///This function instantiates a DistMap.
     102    ///Instantiates a \ref DistMap.
     103
     104    ///This function instantiates a \ref DistMap.
    105105    ///\param g is the digraph, to which we would like to define the
    106     ///DistMap.
     106    ///\ref DistMap.
    107107    static DistMap *createDistMap(const Digraph &g)
    108108    {
    … …  
    228228    };
    229229    ///\brief \ref named-templ-param "Named parameter" for setting
    230     ///PredMap type.
     230    ///\ref PredMap type.
    231231    ///
    232232    ///\ref named-templ-param "Named parameter" for setting
    233     ///PredMap type.
     233    ///\ref 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     ///DistMap type.
     249    ///\ref DistMap type.
    250250    ///
    251251    ///\ref named-templ-param "Named parameter" for setting
    252     ///DistMap type.
     252    ///\ref 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     ///ReachedMap type.
     268    ///\ref ReachedMap type.
    269269    ///
    270270    ///\ref named-templ-param "Named parameter" for setting
    271     ///ReachedMap type.
     271    ///\ref 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     ///ProcessedMap type.
     287    ///\ref ProcessedMap type.
    288288    ///
    289289    ///\ref named-templ-param "Named parameter" for setting
    290     ///ProcessedMap type.
     290    ///\ref 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     ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     304    ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
    305305    ///
    306306    ///\ref named-templ-param "Named parameter" for setting
    307     ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     307    ///\ref 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 PredMap.
    772 
    773     ///This function instantiates a PredMap.
     771    ///Instantiates a \ref PredMap.
     772
     773    ///This function instantiates a \ref PredMap.
    774774    ///\param g is the digraph, to which we would like to define the
    775     ///PredMap.
     775    ///\ref 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 ProcessedMap.
    788 
    789     ///This function instantiates a ProcessedMap.
     787    ///Instantiates a \ref ProcessedMap.
     788
     789    ///This function instantiates a \ref ProcessedMap.
    790790    ///\param g is the digraph, to which
    791     ///we would like to define the ProcessedMap.
     791    ///we would like to define the \ref 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 ReachedMap.
    807 
    808     ///This function instantiates a ReachedMap.
     806    ///Instantiates a \ref ReachedMap.
     807
     808    ///This function instantiates a \ref ReachedMap.
    809809    ///\param g is the digraph, to which
    810     ///we would like to define the ReachedMap.
     810    ///we would like to define the \ref 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 DistMap.
    822 
    823     ///This function instantiates a DistMap.
     821    ///Instantiates a \ref DistMap.
     822
     823    ///This function instantiates a \ref DistMap.
    824824    ///\param g is the digraph, to which we would like to define
    825     ///the DistMap
     825    ///the \ref DistMap
    826826    static DistMap *createDistMap(const Digraph &g)
    827827    {
    … …  
    836836  };
    837837
    838   /// Default traits class used by DfsWizard
     838  /// Default traits class used by \ref DfsWizard
    839839
    840840  /// To make it easier to use Dfs algorithm
    … …  
    10021002    };
    10031003    ///\brief \ref named-func-param "Named parameter"
    1004     ///for setting PredMap object.
     1004    ///for setting \ref PredMap object.
    10051005    ///
    10061006    ///\ref named-func-param "Named parameter"
    1007     ///for setting PredMap object.
     1007    ///for setting \ref 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 ReachedMap object.
     1022    ///for setting \ref ReachedMap object.
    10231023    ///
    10241024    /// \ref named-func-param "Named parameter"
    1025     ///for setting ReachedMap object.
     1025    ///for setting \ref 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 DistMap object.
     1040    ///for setting \ref DistMap object.
    10411041    ///
    10421042    /// \ref named-func-param "Named parameter"
    1043     ///for setting DistMap object.
     1043    ///for setting \ref 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 ProcessedMap object.
     1058    ///for setting \ref ProcessedMap object.
    10591059    ///
    10601060    /// \ref named-func-param "Named parameter"
    1061     ///for setting ProcessedMap object.
     1061    ///for setting \ref 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 ReachedMap.
    1217     ///
    1218     /// This function instantiates a ReachedMap.
     1216    /// \brief Instantiates a \ref ReachedMap.
     1217    ///
     1218    /// This function instantiates a \ref ReachedMap.
    12191219    /// \param digraph is the digraph, to which
    1220     /// we would like to define the ReachedMap.
     1220    /// we would like to define the \ref ReachedMap.
    12211221    static ReachedMap *createReachedMap(const Digraph &digraph) {
    12221222      return new ReachedMap(digraph);

  • lemon/dijkstra.h

    r313 r290  
    140140    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    141141    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
    142     ///Instantiates a PredMap.
    143 
    144     ///This function instantiates a PredMap.
     142    ///Instantiates a \ref PredMap.
     143
     144    ///This function instantiates a \ref PredMap.
    145145    ///\param g is the digraph, to which we would like to define the
    146     ///PredMap.
     146    ///\ref 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 ProcessedMap.
    159 
    160     ///This function instantiates a ProcessedMap.
     158    ///Instantiates a \ref ProcessedMap.
     159
     160    ///This function instantiates a \ref ProcessedMap.
    161161    ///\param g is the digraph, to which
    162     ///we would like to define the ProcessedMap
     162    ///we would like to define the \ref 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 DistMap.
    178 
    179     ///This function instantiates a DistMap.
     177    ///Instantiates a \ref DistMap.
     178
     179    ///This function instantiates a \ref DistMap.
    180180    ///\param g is the digraph, to which we would like to define
    181     ///the DistMap
     181    ///the \ref DistMap
    182182    static DistMap *createDistMap(const Digraph &g)
    183183    {
    … …  
    328328    };
    329329    ///\brief \ref named-templ-param "Named parameter" for setting
    330     ///PredMap type.
     330    ///\ref PredMap type.
    331331    ///
    332332    ///\ref named-templ-param "Named parameter" for setting
    333     ///PredMap type.
     333    ///\ref PredMap type.
    334334    template <class T>
    335335    struct SetPredMap
    … …  
    348348    };
    349349    ///\brief \ref named-templ-param "Named parameter" for setting
    350     ///DistMap type.
     350    ///\ref DistMap type.
    351351    ///
    352352    ///\ref named-templ-param "Named parameter" for setting
    353     ///DistMap type.
     353    ///\ref DistMap type.
    354354    template <class T>
    355355    struct SetDistMap
    … …  
    368368    };
    369369    ///\brief \ref named-templ-param "Named parameter" for setting
    370     ///ProcessedMap type.
     370    ///\ref ProcessedMap type.
    371371    ///
    372372    ///\ref named-templ-param "Named parameter" for setting
    373     ///ProcessedMap type.
     373    ///\ref ProcessedMap type.
    374374    template <class T>
    375375    struct SetProcessedMap
    … …  
    386386    };
    387387    ///\brief \ref named-templ-param "Named parameter" for setting
    388     ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     388    ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
    389389    ///
    390390    ///\ref named-templ-param "Named parameter" for setting
    391     ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     391    ///\ref 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     ///\c OperationTraits type
     456    ///\ref 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 PredMap.
    990 
    991     ///This function instantiates a PredMap.
     989    ///Instantiates a \ref PredMap.
     990
     991    ///This function instantiates a \ref PredMap.
    992992    ///\param g is the digraph, to which we would like to define the
    993     ///PredMap.
     993    ///\ref 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 ProcessedMap.
    1006 
    1007     ///This function instantiates a ProcessedMap.
     1005    ///Instantiates a \ref ProcessedMap.
     1006
     1007    ///This function instantiates a \ref ProcessedMap.
    10081008    ///\param g is the digraph, to which
    1009     ///we would like to define the ProcessedMap.
     1009    ///we would like to define the \ref 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 DistMap.
    1025 
    1026     ///This function instantiates a DistMap.
     1024    ///Instantiates a \ref DistMap.
     1025
     1026    ///This function instantiates a \ref DistMap.
    10271027    ///\param g is the digraph, to which we would like to define
    1028     ///the DistMap
     1028    ///the \ref DistMap
    10291029    static DistMap *createDistMap(const Digraph &g)
    10301030    {
    … …  
    10391039  };
    10401040
    1041   /// Default traits class used by DijkstraWizard
     1041  /// Default traits class used by \ref DijkstraWizard
    10421042
    10431043  /// To make it easier to use Dijkstra algorithm
    … …  
    11991199    };
    12001200    ///\brief \ref named-func-param "Named parameter"
    1201     ///for setting PredMap object.
     1201    ///for setting \ref PredMap object.
    12021202    ///
    12031203    ///\ref named-func-param "Named parameter"
    1204     ///for setting PredMap object.
     1204    ///for setting \ref 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 DistMap object.
     1219    ///for setting \ref DistMap object.
    12201220    ///
    12211221    ///\ref named-func-param "Named parameter"
    1222     ///for setting DistMap object.
     1222    ///for setting \ref 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 ProcessedMap object.
     1237    ///for setting \ref ProcessedMap object.
    12381238    ///
    12391239    /// \ref named-func-param "Named parameter"
    1240     ///for setting ProcessedMap object.
     1240    ///for setting \ref ProcessedMap object.
    12411241    template<class T>
    12421242    DijkstraWizard<SetProcessedMapBase<T> > processedMap(const T &t)

  • lemon/dim2.h

    r314 r253  
    260260
    261261
    262   /// Bounding box of plain vectors (points).
     262  /// Bounding box of plain vectors (\ref Point 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 <tt>Point</tt>-map
    577 
     576  ///Map of x-coordinates of a \ref Point "Point"-map
     577
     578  ///\ingroup maps
    578579  ///Map of x-coordinates of a \ref Point "Point"-map.
    579580  ///
    … …  
    592593  };
    593594
    594   ///Returns an XMap class
    595 
    596   ///This function just returns an XMap class.
     595  ///Returns an \ref XMap class
     596
     597  ///This function just returns an \ref XMap class.
     598  ///
     599  ///\ingroup maps
    597600  ///\relates XMap
    598601  template<class M>
    … …  
    608611  }
    609612
    610   ///Constant (read only) version of XMap
    611 
    612   ///Constant (read only) version of XMap.
     613  ///Constant (read only) version of \ref XMap
     614
     615  ///\ingroup maps
     616  ///Constant (read only) version of \ref XMap
    613617  ///
    614618  template<class M>
    … …  
    625629  };
    626630
    627   ///Returns a ConstXMap class
    628 
    629   ///This function just returns a ConstXMap class.
     631  ///Returns a \ref ConstXMap class
     632
     633  ///This function just returns a \ref ConstXMap class.
     634  ///
     635  ///\ingroup maps
    630636  ///\relates ConstXMap
    631637  template<class M>
    … …  
    635641  }
    636642
    637   ///Map of y-coordinates of a <tt>Point</tt>-map
    638 
     643  ///Map of y-coordinates of a \ref Point "Point"-map
     644
     645  ///\ingroup maps
    639646  ///Map of y-coordinates of a \ref Point "Point"-map.
    640647  ///
    … …  
    653660  };
    654661
    655   ///Returns a YMap class
    656 
    657   ///This function just returns a YMap class.
     662  ///Returns a \ref YMap class
     663
     664  ///This function just returns a \ref YMap class.
     665  ///
     666  ///\ingroup maps
    658667  ///\relates YMap
    659668  template<class M>
    … …  
    669678  }
    670679
    671   ///Constant (read only) version of YMap
    672 
    673   ///Constant (read only) version of YMap.
     680  ///Constant (read only) version of \ref YMap
     681
     682  ///\ingroup maps
     683  ///Constant (read only) version of \ref YMap
    674684  ///
    675685  template<class M>
    … …  
    686696  };
    687697
    688   ///Returns a ConstYMap class
    689 
    690   ///This function just returns a ConstYMap class.
     698  ///Returns a \ref ConstYMap class
     699
     700  ///This function just returns a \ref ConstYMap class.
     701  ///
     702  ///\ingroup maps
    691703  ///\relates ConstYMap
    692704  template<class M>
    … …  
    697709
    698710
    699   ///\brief Map of the normSquare() of a <tt>Point</tt>-map
     711  ///\brief Map of the \ref Point::normSquare() "normSquare()"
     712  ///of a \ref Point "Point"-map
    700713  ///
    701714  ///Map of the \ref Point::normSquare() "normSquare()"
    702715  ///of a \ref Point "Point"-map.
     716  ///\ingroup maps
    703717  template<class M>
    704718  class NormSquareMap
    … …  
    714728  };
    715729
    716   ///Returns a NormSquareMap class
    717 
    718   ///This function just returns a NormSquareMap class.
     730  ///Returns a \ref NormSquareMap class
     731
     732  ///This function just returns a \ref NormSquareMap class.
     733  ///
     734  ///\ingroup maps
    719735  ///\relates NormSquareMap
    720736  template<class M>

  • lemon/graph_to_eps.h

    r313 r291  
    6363  }
    6464
    65 ///Default traits class of GraphToEps
     65///Default traits class of \ref GraphToEps
    6666
    6767///Default traits class of \ref GraphToEps.

  • lemon/lgf_reader.h

    r303 r295  
    392392  class DigraphReader;
    393393
    394   /// \brief Return a \ref DigraphReader class
    395   ///
    396   /// This function just returns a \ref DigraphReader class.
    397   /// \relates DigraphReader
    398394  template <typename Digraph>
    399395  DigraphReader<Digraph> digraphReader(Digraph& digraph,
    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
     396                                       std::istream& is = std::cin);
     397
    409398  template <typename Digraph>
    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
     399  DigraphReader<Digraph> digraphReader(Digraph& digraph, const std::string& fn);
     400
    420401  template <typename Digraph>
    421   DigraphReader<Digraph> digraphReader(Digraph& digraph, const char* fn) {
    422     DigraphReader<Digraph> tmp(digraph, fn);
    423     return tmp;
    424   }
     402  DigraphReader<Digraph> digraphReader(Digraph& digraph, const char *fn);
    425403
    426404  /// \ingroup lemon_io
    … …  
    12121190  };
    12131191
     1192  /// \brief Return a \ref DigraphReader class
     1193  ///
     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);
     1200    return tmp;
     1201  }
     1202
     1203  /// \brief Return a \ref DigraphReader class
     1204  ///
     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);
     1211    return tmp;
     1212  }
     1213
     1214  /// \brief Return a \ref DigraphReader class
     1215  ///
     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);
     1221    return tmp;
     1222  }
     1223
    12141224  template <typename Graph>
    12151225  class GraphReader;
    12161226
    1217   /// \brief Return a \ref GraphReader class
    1218   ///
    1219   /// This function just returns a \ref GraphReader class.
    1220   /// \relates GraphReader
    12211227  template <typename Graph>
    1222   GraphReader<Graph> graphReader(Graph& graph, std::istream& is = std::cin) {
    1223     GraphReader<Graph> tmp(graph, is);
    1224     return tmp;
    1225   }
    1226 
    1227   /// \brief Return a \ref GraphReader class
    1228   ///
    1229   /// This function just returns a \ref GraphReader class.
    1230   /// \relates GraphReader
     1228  GraphReader<Graph> graphReader(Graph& graph,
     1229                                 std::istream& is = std::cin);
     1230
    12311231  template <typename Graph>
    1232   GraphReader<Graph> graphReader(Graph& graph, const std::string& fn) {
    1233     GraphReader<Graph> tmp(graph, fn);
    1234     return tmp;
    1235   }
    1236 
    1237   /// \brief Return a \ref GraphReader class
    1238   ///
    1239   /// This function just returns a \ref GraphReader class.
    1240   /// \relates GraphReader
     1232  GraphReader<Graph> graphReader(Graph& graph, const std::string& fn);
     1233
    12411234  template <typename Graph>
    1242   GraphReader<Graph> graphReader(Graph& graph, const char* fn) {
    1243     GraphReader<Graph> tmp(graph, fn);
    1244     return tmp;
    1245   }
     1235  GraphReader<Graph> graphReader(Graph& graph, const char *fn);
    12461236
    12471237  /// \ingroup lemon_io
    … …  
    20412031
    20422032  };
     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  }
    20432063
    20442064  class SectionReader;

  • lemon/lgf_writer.h

    r303 r295  
    352352  class DigraphWriter;
    353353
    354   /// \brief Return a \ref DigraphWriter class
    355   ///
    356   /// This function just returns a \ref DigraphWriter class.
    357   /// \relates DigraphWriter
    358354  template <typename Digraph>
    359355  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
    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
     356                                       std::ostream& os = std::cout);
     357
    369358  template <typename Digraph>
    370359  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
    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
     360                                       const std::string& fn);
     361
    380362  template <typename Digraph>
    381363  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
    382                                        const char* fn) {
    383     DigraphWriter<Digraph> tmp(digraph, fn);
    384     return tmp;
    385   }
     364                                       const char *fn);
    386365
    387366  /// \ingroup lemon_io
    … …  
    935914  };
    936915
     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);
     924    return tmp;
     925  }
     926
     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);
     935    return tmp;
     936  }
     937
     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);
     946    return tmp;
     947  }
     948
    937949  template <typename Graph>
    938950  class GraphWriter;
    939951
    940   /// \brief Return a \ref GraphWriter class
    941   ///
    942   /// This function just returns a \ref GraphWriter class.
    943   /// \relates GraphWriter
    944952  template <typename Graph>
    945953  GraphWriter<Graph> graphWriter(const Graph& graph,
    946                                  std::ostream& os = std::cout) {
    947     GraphWriter<Graph> tmp(graph, os);
    948     return tmp;
    949   }
    950 
    951   /// \brief Return a \ref GraphWriter class
    952   ///
    953   /// This function just returns a \ref GraphWriter class.
    954   /// \relates GraphWriter
     954                                 std::ostream& os = std::cout);
     955
    955956  template <typename Graph>
    956   GraphWriter<Graph> graphWriter(const Graph& graph, const std::string& fn) {
    957     GraphWriter<Graph> tmp(graph, fn);
    958     return tmp;
    959   }
    960 
    961   /// \brief Return a \ref GraphWriter class
    962   ///
    963   /// This function just returns a \ref GraphWriter class.
    964   /// \relates GraphWriter
     957  GraphWriter<Graph> graphWriter(const Graph& graph, const std::string& fn);
     958
    965959  template <typename Graph>
    966   GraphWriter<Graph> graphWriter(const Graph& graph, const char* fn) {
    967     GraphWriter<Graph> tmp(graph, fn);
    968     return tmp;
    969   }
     960  GraphWriter<Graph> graphWriter(const Graph& graph, const char *fn);
    970961
    971962  /// \ingroup lemon_io
    … …  
    15351526    /// @}
    15361527  };
     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  }
    15371559
    15381560  class SectionWriter;

  • lemon/list_graph.h

    r313 r280  
    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

    r314 r280  
    4444  class MapBase {
    4545  public:
    46     /// \brief The key type of the map.
     46    /// \biref The key type of the map.
    4747    typedef K Key;
    4848    /// \brief The value type of the map.
    … …  
    7474  };
    7575
    76   /// Returns a \c NullMap class
    77 
    78   /// This function just returns a \c NullMap class.
     76  /// Returns a \ref NullMap class
     77
     78  /// This function just returns a \ref 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 \c NullMap.
     91  /// In other aspects it is equivalent to \ref 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 \c ConstMap class
    137 
    138   /// This function just returns a \c ConstMap class.
     136  /// Returns a \ref ConstMap class
     137
     138  /// This function just returns a \ref 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 \c NullMap.
     159  /// In other aspects it is equivalent to \ref 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 \c ConstMap class with inlined constant value
    186 
    187   /// This function just returns a \c ConstMap class with inlined
     185  /// Returns a \ref ConstMap class with inlined constant value
     186
     187  /// This function just returns a \ref ConstMap class with inlined
    188188  /// constant value.
    189189  /// \relates ConstMap
    … …  
    213213  };
    214214
    215   /// Returns an \c IdentityMap class
    216 
    217   /// This function just returns an \c IdentityMap class.
     215  /// Returns an \ref IdentityMap class
     216
     217  /// This function just returns an \ref 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   /// \c UnionFind, \c BinHeap, when the used items are small
     231  /// \ref UnionFind, \ref 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 \c RangeMap.
     271    /// Constructs the map from another \ref RangeMap.
    272272    template <typename V1>
    273273    RangeMap(const RangeMap<V1> &c)
    … …  
    312312  };
    313313
    314   /// Returns a \c RangeMap class
    315 
    316   /// This function just returns a \c RangeMap class.
     314  /// Returns a \ref RangeMap class
     315
     316  /// This function just returns a \ref RangeMap class.
    317317  /// \relates RangeMap
    318318  template<typename V>
    … …  
    321321  }
    322322
    323   /// \brief Returns a \c RangeMap class created from an appropriate
     323  /// \brief Returns a \ref RangeMap class created from an appropriate
    324324  /// \c std::vector
    325325
    326   /// This function just returns a \c RangeMap class created from an
     326  /// This function just returns a \ref 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 \c SparseMap.
     391    /// \brief Constructs the map from another \ref SparseMap.
    392392    template<typename V1, typename Comp1>
    393393    SparseMap(const SparseMap<Key, V1, Comp1> &c)
    … …  
    434434  };
    435435
    436   /// Returns a \c SparseMap class
    437 
    438   /// This function just returns a \c SparseMap class with specified
     436  /// Returns a \ref SparseMap class
     437
     438  /// This function just returns a \ref SparseMap class with specified
    439439  /// default value.
    440440  /// \relates SparseMap
    … …  
    449449  }
    450450
    451   /// \brief Returns a \c SparseMap class created from an appropriate
     451  /// \brief Returns a \ref SparseMap class created from an appropriate
    452452  /// \c std::map
    453453
    454   /// This function just returns a \c SparseMap class created from an
     454  /// This function just returns a \ref SparseMap class created from an
    455455  /// appropriate \c std::map.
    456456  /// \relates SparseMap
    … …  
    502502  };
    503503
    504   /// Returns a \c ComposeMap class
    505 
    506   /// This function just returns a \c ComposeMap class.
     504  /// Returns a \ref ComposeMap class
     505
     506  /// This function just returns a \ref 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 \c CombineMap class
    560 
    561   /// This function just returns a \c CombineMap class.
     559  /// Returns a \ref CombineMap class
     560
     561  /// This function just returns a \ref CombineMap class.
    562562  ///
    563563  /// For example, if \c m1 and \c m2 are both maps with \c double
    … …  
    626626  };
    627627
    628   /// Returns a \c FunctorToMap class
    629 
    630   /// This function just returns a \c FunctorToMap class.
     628  /// Returns a \ref FunctorToMap class
     629
     630  /// This function just returns a \ref FunctorToMap class.
    631631  ///
    632632  /// This function is specialized for adaptable binary function
    … …  
    685685  };
    686686
    687   /// Returns a \c MapToFunctor class
    688 
    689   /// This function just returns a \c MapToFunctor class.
     687  /// Returns a \ref MapToFunctor class
     688
     689  /// This function just returns a \ref MapToFunctor class.
    690690  /// \relates MapToFunctor
    691691  template<typename M>
    … …  
    724724  };
    725725
    726   /// Returns a \c ConvertMap class
    727 
    728   /// This function just returns a \c ConvertMap class.
     726  /// Returns a \ref ConvertMap class
     727
     728  /// This function just returns a \ref ConvertMap class.
    729729  /// \relates ConvertMap
    730730  template<typename V, typename M>
    … …  
    764764  };
    765765
    766   /// Returns a \c ForkMap class
    767 
    768   /// This function just returns a \c ForkMap class.
     766  /// Returns a \ref ForkMap class
     767
     768  /// This function just returns a \ref ForkMap class.
    769769  /// \relates ForkMap
    770770  template <typename M1, typename M2>
    … …  
    808808  };
    809809
    810   /// Returns an \c AddMap class
    811 
    812   /// This function just returns an \c AddMap class.
     810  /// Returns an \ref AddMap class
     811
     812  /// This function just returns an \ref AddMap class.
    813813  ///
    814814  /// For example, if \c m1 and \c m2 are both maps with \c double
    … …  
    856856  };
    857857
    858   /// Returns a \c SubMap class
    859 
    860   /// This function just returns a \c SubMap class.
     858  /// Returns a \ref SubMap class
     859
     860  /// This function just returns a \ref SubMap class.
    861861  ///
    862862  /// For example, if \c m1 and \c m2 are both maps with \c double
    … …  
    905905  };
    906906
    907   /// Returns a \c MulMap class
    908 
    909   /// This function just returns a \c MulMap class.
     907  /// Returns a \ref MulMap class
     908
     909  /// This function just returns a \ref MulMap class.
    910910  ///
    911911  /// For example, if \c m1 and \c m2 are both maps with \c double
    … …  
    953953  };
    954954
    955   /// Returns a \c DivMap class
    956 
    957   /// This function just returns a \c DivMap class.
     955  /// Returns a \ref DivMap class
     956
     957  /// This function just returns a \ref DivMap class.
    958958  ///
    959959  /// For example, if \c m1 and \c m2 are both maps with \c double
    … …  
    10391039  };
    10401040
    1041   /// Returns a \c ShiftMap class
    1042 
    1043   /// This function just returns a \c ShiftMap class.
     1041  /// Returns a \ref ShiftMap class
     1042
     1043  /// This function just returns a \ref 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 \c ShiftWriteMap class
    1056 
    1057   /// This function just returns a \c ShiftWriteMap class.
     1055  /// Returns a \ref ShiftWriteMap class
     1056
     1057  /// This function just returns a \ref 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 \c ScaleMap class
    1144 
    1145   /// This function just returns a \c ScaleMap class.
     1143  /// Returns a \ref ScaleMap class
     1144
     1145  /// This function just returns a \ref 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 \c ScaleWriteMap class
    1158 
    1159   /// This function just returns a \c ScaleWriteMap class.
     1157  /// Returns a \ref ScaleWriteMap class
     1158
     1159  /// This function just returns a \ref 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 \c NegMap class
    1244 
    1245   /// This function just returns a \c NegMap class.
     1243  /// Returns a \ref NegMap class
     1244
     1245  /// This function just returns a \ref NegMap class.
    12461246  ///
    12471247  /// For example, if \c m is a map with \c double values, then
    … …  
    12541254  }
    12551255
    1256   /// Returns a \c NegWriteMap class
    1257 
    1258   /// This function just returns a \c NegWriteMap class.
     1256  /// Returns a \ref NegWriteMap class
     1257
     1258  /// This function just returns a \ref NegWriteMap class.
    12591259  ///
    12601260  /// For example, if \c m is a map with \c double values, then
    … …  
    12971297  };
    12981298
    1299   /// Returns an \c AbsMap class
    1300 
    1301   /// This function just returns an \c AbsMap class.
     1299  /// Returns an \ref AbsMap class
     1300
     1301  /// This function just returns an \ref AbsMap class.
    13021302  ///
    13031303  /// For example, if \c m is a map with \c double values, then
    … …  
    13461346  };
    13471347
    1348   /// Returns a \c TrueMap class
    1349 
    1350   /// This function just returns a \c TrueMap class.
     1348  /// Returns a \ref TrueMap class
     1349
     1350  /// This function just returns a \ref TrueMap class.
    13511351  /// \relates TrueMap
    13521352  template<typename K>
    … …  
    13831383  };
    13841384
    1385   /// Returns a \c FalseMap class
    1386 
    1387   /// This function just returns a \c FalseMap class.
     1385  /// Returns a \ref FalseMap class
     1386
     1387  /// This function just returns a \ref FalseMap class.
    13881388  /// \relates FalseMap
    13891389  template<typename K>
    … …  
    14301430  };
    14311431
    1432   /// Returns an \c AndMap class
    1433 
    1434   /// This function just returns an \c AndMap class.
     1432  /// Returns an \ref AndMap class
     1433
     1434  /// This function just returns an \ref AndMap class.
    14351435  ///
    14361436  /// For example, if \c m1 and \c m2 are both maps with \c bool values,
    … …  
    14781478  };
    14791479
    1480   /// Returns an \c OrMap class
    1481 
    1482   /// This function just returns an \c OrMap class.
     1480  /// Returns an \ref OrMap class
     1481
     1482  /// This function just returns an \ref OrMap class.
    14831483  ///
    14841484  /// For example, if \c m1 and \c m2 are both maps with \c bool values,
    … …  
    15451545  };
    15461546
    1547   /// Returns a \c NotMap class
    1548 
    1549   /// This function just returns a \c NotMap class.
     1547  /// Returns a \ref NotMap class
     1548
     1549  /// This function just returns a \ref NotMap class.
    15501550  ///
    15511551  /// For example, if \c m is a map with \c bool values, then
    … …  
    15581558  }
    15591559
    1560   /// Returns a \c NotWriteMap class
    1561 
    1562   /// This function just returns a \c NotWriteMap class.
     1560  /// Returns a \ref NotWriteMap class
     1561
     1562  /// This function just returns a \ref NotWriteMap class.
    15631563  ///
    15641564  /// For example, if \c m is a map with \c bool values, then
    … …  
    16061606  };
    16071607
    1608   /// Returns an \c EqualMap class
    1609 
    1610   /// This function just returns an \c EqualMap class.
     1608  /// Returns an \ref EqualMap class
     1609
     1610  /// This function just returns an \ref EqualMap class.
    16111611  ///
    16121612  /// For example, if \c m1 and \c m2 are maps with keys and values of
    … …  
    16541654  };
    16551655
    1656   /// Returns an \c LessMap class
    1657 
    1658   /// This function just returns an \c LessMap class.
     1656  /// Returns an \ref LessMap class
     1657
     1658  /// This function just returns an \ref 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   /// @{
    16901685
    16911686  /// \brief Writable bool map for logging each \c true assigned element
    … …  
    17511746  };
    17521747
    1753   /// Returns a \c LoggerBoolMap class
    1754 
    1755   /// This function just returns a \c LoggerBoolMap class.
     1748  /// Returns a \ref LoggerBoolMap class
     1749
     1750  /// This function just returns a \ref LoggerBoolMap class.
    17561751  ///
    17571752  /// The most important usage of it is storing certain nodes or arcs
    … …  
    17731768  /// \note LoggerBoolMap is just \ref concepts::WriteMap "writable", so
    17741769  /// it cannot be used when a readable map is needed, for example as
    1775   /// \c ReachedMap for \c Bfs, \c Dfs and \c Dijkstra algorithms.
     1770  /// \c ReachedMap for \ref Bfs, \ref Dfs and \ref Dijkstra algorithms.
    17761771  ///
    17771772  /// \relates LoggerBoolMap
    … …  
    17801775    return LoggerBoolMap<Iterator>(it);
    17811776  }
    1782 
    1783   /// @}
    1784 
    1785   /// \addtogroup graph_maps
    1786   /// @{
    17871777
    17881778  /// Provides an immutable and unique id for each item in the graph.
    … …  
    18921882    /// The value type of the InvertableMap.
    18931883    typedef typename Map::Value Value;
     1884
     1885
    18941886
    18951887    /// \brief Constructor.
    … …  
    20582050    }
    20592051
     2052
     2053
    20602054  };
    20612055
    … …  
    22732267    ///
    22742268    /// Constructor
    2275     /// \param digraph The digraph that the map belongs to.
     2269    /// \param _digraph The digraph that the map belongs to.
    22762270    explicit SourceMap(const Digraph& digraph) : _digraph(digraph) {}
    22772271
    … …  
    22892283  };
    22902284
    2291   /// \brief Returns a \c SourceMap class.
    2292   ///
    2293   /// This function just returns an \c SourceMap class.
     2285  /// \brief Returns a \ref SourceMap class.
     2286  ///
     2287  /// This function just returns an \ref SourceMap class.
    22942288  /// \relates SourceMap
    22952289  template <typename Digraph>
    … …  
    23122306    ///
    23132307    /// Constructor
    2314     /// \param digraph The digraph that the map belongs to.
     2308    /// \param _digraph The digraph that the map belongs to.
    23152309    explicit TargetMap(const Digraph& digraph) : _digraph(digraph) {}
    23162310
    … …  
    23282322  };
    23292323
    2330   /// \brief Returns a \c TargetMap class.
    2331   ///
    2332   /// This function just returns a \c TargetMap class.
     2324  /// \brief Returns a \ref TargetMap class.
     2325  ///
     2326  /// This function just returns a \ref TargetMap class.
    23332327  /// \relates TargetMap
    23342328  template <typename Digraph>
    … …  
    23512345    ///
    23522346    /// Constructor
    2353     /// \param graph The graph that the map belongs to.
     2347    /// \param _graph The graph that the map belongs to.
    23542348    explicit ForwardMap(const Graph& graph) : _graph(graph) {}
    23552349
    … …  
    23672361  };
    23682362
    2369   /// \brief Returns a \c ForwardMap class.
    2370   ///
    2371   /// This function just returns an \c ForwardMap class.
     2363  /// \brief Returns a \ref ForwardMap class.
     2364  ///
     2365  /// This function just returns an \ref ForwardMap class.
    23722366  /// \relates ForwardMap
    23732367  template <typename Graph>
    … …  
    23902384    ///
    23912385    /// Constructor
    2392     /// \param graph The graph that the map belongs to.
     2386    /// \param _graph The graph that the map belongs to.
    23932387    explicit BackwardMap(const Graph& graph) : _graph(graph) {}
    23942388
    … …  
    24062400  };
    24072401
    2408   /// \brief Returns a \c BackwardMap class
    2409 
    2410   /// This function just returns a \c BackwardMap class.
     2402  /// \brief Returns a \ref BackwardMap class
     2403
     2404  /// This function just returns a \ref BackwardMap class.
    24112405  /// \relates BackwardMap
    24122406  template <typename Graph>

  • lemon/path.h

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

  • lemon/smart_graph.h

    r313 r280  
    366366
    367367      ///This constructor immediately makes a snapshot of the digraph.
    368       ///\param graph The digraph we make a snapshot of.
     368      ///\param _g 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 graph The digraph we make the snapshot of.
     380      ///\param _g 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 graph The digraph we make a snapshot of.
     778      ///\param g 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 graph The digraph we make the snapshot of.
     789      ///\param g The digraph we make the snapshot of.
    790790      void save(SmartGraph &graph)
    791791      {

  • lemon/time_measure.h

    r314 r280  
    312312    ///Basically a Timer can be either running or stopped,
    313313    ///but it provides a bit finer control on the execution.
    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
     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
    318318    ///of recursive functions.
     319    ///
    319320
    320321    ///@{
    … …  
    472473  };
    473474
    474   ///Same as Timer but prints a report on destruction.
     475  ///Same as \ref Timer but prints a report on destruction.
    475476
    476477  ///Same as \ref Timer but prints a report on destruction.
    … …  
    491492    std::ostream &_os;
    492493  public:
    493     ///Constructor
    494 
    495     ///Constructor.
     494    ///\e
     495
    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
    499500    TimeReport(std::string title,std::ostream &os=std::cerr,bool run=true)
    500501      : Timer(run), _title(title), _os(os){}
    501     ///Destructor that prints the ellapsed time
     502    ///\e Prints the ellapsed time on destruction.
    502503    ~TimeReport()
    503504    {
    … …  
    506507  };
    507508
    508   ///'Do nothing' version of TimeReport
     509  ///'Do nothing' version of \ref TimeReport
    509510
    510511  ///\sa TimeReport

  • tools/Makefile.am

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