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 / [315:c175e387da19:312:a4d499904482] in lemon-main


Ignore:
Files:
28 edited

Legend:

Unmodified
Added
Removed

  • 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/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 r307  
    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.
     59If you are a user of the old (0.x) series of LEMON, please check out the \ref migration "Migration Guide" for the backward incompatibilities.
    6160*/

  • doc/migration.dox

    r314 r308  
    5858in strings, comments etc. as well as in all identifiers.</b>
    5959
    60 \section migration-lgf LGF tools
     60\section migration-lgf LGF tools 
    6161 - The \ref lgf-format "LGF file format" has changed,
    6262   <tt>\@nodeset</tt> has changed to <tt>\@nodes</tt>,

  • 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 r300  
    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 r301  
    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

  • lemon/dijkstra.h

    r313 r301  
    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
    … …  
    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

  • 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/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 r301  
    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.
    … …  
    16831683
    16841684  }
    1685 
    1686   /// @}
    1687 
    1688   /// \addtogroup maps
    1689   /// @{
    16901685
    16911686  /// \brief Writable bool map for logging each \c true assigned element
    … …  
    17811776  }
    17821777
    1783   /// @}
    1784 
    1785   /// \addtogroup graph_maps
    1786   /// @{
    1787 
    17881778  /// Provides an immutable and unique id for each item in the graph.
    17891779
    … …  
    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
    … …  
    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
    … …  
    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
    … …  
    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

  • 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
Note: See TracChangeset for help on using the changeset viewer.