COIN-OR::LEMON - Graph Library

Changeset 314:2cc60866a0c9 in lemon-main


Ignore:
Timestamp:
10/09/08 13:27:35 (16 years ago)
Author:
Peter Kovacs <kpeter@…>
Branch:
default
Phase:
public
Message:

Doc reorganization + improvements

  • Reorganize several tools (move them to other modules).
  • Add new module for map concepts.
  • Remove the doc of all tools in lemon/bits.
  • Improvements in groups.dox.
  • Fix some doxygen warnings.
Files:
17 edited

Legend:

Unmodified
Added
Removed
  • doc/groups.dox

    r236 r314  
    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 structures.
     57with any graph structure.
     58
     59<b>See also:</b> \ref graph_concepts "Graph Structure Concepts".
    5860*/
    5961
     
    7577This group describes the map structures implemented in LEMON.
    7678
    77 LEMON provides several special purpose maps that e.g. combine
     79LEMON provides several special purpose maps and map adaptors that e.g. combine
    7880new maps from existing ones.
     81
     82<b>See also:</b> \ref map_concepts "Map Concepts".
    7983*/
    8084
     
    8791values to the nodes and arcs of graphs.
    8892*/
    89 
    9093
    9194/**
     
    105108algorithms.  If a function type algorithm is called then the function
    106109type map adaptors can be used comfortable. For example let's see the
    107 usage of map adaptors with the \c digraphToEps() function.
     110usage of map adaptors with the \c graphToEps() function.
    108111\code
    109112  Color nodeColor(int deg) {
     
    119122  Digraph::NodeMap<int> degree_map(graph);
    120123
    121   digraphToEps(graph, "graph.eps")
     124  graphToEps(graph, "graph.eps")
    122125    .coords(coords).scaleToA4().undirected()
    123126    .nodeColors(composeMap(functorToMap(nodeColor), degree_map))
     
    125128\endcode
    126129The \c functorToMap() function makes an \c int to \c Color map from the
    127 \e nodeColor() function. The \c composeMap() compose the \e degree_map
     130\c nodeColor() function. The \c composeMap() compose the \c degree_map
    128131and the previously created map. The composed map is a proper function to
    129132get the color of each node.
     
    174177
    175178\sa lemon::concepts::Path
    176 
    177179*/
    178180
     
    186188*/
    187189
    188 
    189190/**
    190191@defgroup algs Algorithms
     
    202203
    203204This group describes the common graph search algorithms like
    204 Breadth-first search (Bfs) and Depth-first search (Dfs).
    205 */
    206 
    207 /**
    208 @defgroup shortest_path Shortest Path algorithms
     205Breadth-First Search (BFS) and Depth-First Search (DFS).
     206*/
     207
     208/**
     209@defgroup shortest_path Shortest Path Algorithms
    209210@ingroup algs
    210211\brief Algorithms for finding shortest paths.
     
    214215
    215216/**
    216 @defgroup max_flow Maximum Flow algorithms
     217@defgroup max_flow Maximum Flow Algorithms
    217218@ingroup algs
    218219\brief Algorithms for finding maximum flows.
     
    242243provides functions to query the minimum cut, which is the dual linear
    243244programming problem of the maximum flow.
    244 
    245 */
    246 
    247 /**
    248 @defgroup min_cost_flow Minimum Cost Flow algorithms
     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 /**
    289 @defgroup graph_prop Connectivity and other graph properties
     285*/
     286
     287/**
     288@defgroup graph_prop Connectivity and Other Graph Properties
    290289@ingroup algs
    291290\brief Algorithms for discovering the graph properties
     
    299298
    300299/**
    301 @defgroup planar Planarity embedding and drawing
     300@defgroup planar Planarity Embedding and Drawing
    302301@ingroup algs
    303302\brief Algorithms for planarity checking, embedding and drawing
     
    311310
    312311/**
    313 @defgroup matching Matching algorithms
     312@defgroup matching Matching Algorithms
    314313@ingroup algs
    315314\brief Algorithms for finding matchings in graphs and bipartite graphs.
     
    349348\image html bipartite_matching.png
    350349\image latex bipartite_matching.eps "Bipartite Matching" width=\textwidth
    351 
    352 */
    353 
    354 /**
    355 @defgroup spantree Minimum Spanning Tree algorithms
     350*/
     351
     352/**
     353@defgroup spantree Minimum Spanning Tree Algorithms
    356354@ingroup algs
    357355\brief Algorithms for finding a minimum cost spanning tree in a graph.
     
    361359*/
    362360
    363 
    364 /**
    365 @defgroup auxalg Auxiliary algorithms
     361/**
     362@defgroup auxalg Auxiliary Algorithms
    366363@ingroup algs
    367364\brief Auxiliary algorithms implemented in LEMON.
     
    372369
    373370/**
    374 @defgroup approx Approximation algorithms
     371@defgroup approx Approximation Algorithms
     372@ingroup algs
    375373\brief Approximation algorithms.
    376374
     
    386384This group describes some general optimization frameworks
    387385implemented in LEMON.
    388 
    389 */
    390 
    391 /**
    392 @defgroup lp_group Lp and Mip solvers
     386*/
     387
     388/**
     389@defgroup lp_group Lp and Mip Solvers
    393390@ingroup gen_opt_group
    394391\brief Lp and Mip solver interfaces for LEMON.
     
    397394various LP solvers could be used in the same manner with this
    398395interface.
    399 
    400 */
    401 
    402 /**
    403 @defgroup lp_utils Tools for Lp and Mip solvers
     396*/
     397
     398/**
     399@defgroup lp_utils Tools for Lp and Mip Solvers
    404400@ingroup lp_group
    405401\brief Helper tools to the Lp and Mip solvers.
     
    442438
    443439/**
    444 @defgroup timecount Time measuring and Counting
     440@defgroup timecount Time Measuring and Counting
    445441@ingroup misc
    446442\brief Simple tools for measuring the performance of algorithms.
     
    448444This group describes simple tools for measuring the performance
    449445of 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 
    457 This group describes the tools that makes it easier to create graphs and
    458 the maps that dynamically update with the graph changes.
    459446*/
    460447
     
    472459
    473460This group describes the tools for importing and exporting graphs
    474 and graph related data. Now it supports the LEMON format, the
    475 \c DIMACS format and the encapsulated postscript (EPS) format.
     461and graph related data. Now it supports the \ref lgf-format
     462"LEMON Graph Format", the \c DIMACS format and the encapsulated
     463postscript (EPS) format.
    476464*/
    477465
     
    479467@defgroup lemon_io LEMON Input-Output
    480468@ingroup io_group
    481 \brief Reading and writing \ref lgf-format "LEMON Graph Format".
     469\brief Reading and writing LEMON Graph Format.
    482470
    483471This group describes methods for reading and writing
     
    486474
    487475/**
    488 @defgroup eps_io Postscript exporting
     476@defgroup eps_io Postscript Exporting
    489477@ingroup io_group
    490478\brief General \c EPS drawer and graph exporter
     
    493481graph exporting tools.
    494482*/
    495 
    496483
    497484/**
     
    522509
    523510- Finally, They can serve as a skeleton of a new implementation of a concept.
    524 
    525 */
    526 
     511*/
    527512
    528513/**
     
    535520*/
    536521
    537 /* --- Unused group
    538 @defgroup experimental Experimental Structures and Algorithms
    539 This group describes some Experimental structures and algorithms.
    540 The stuff here is subject to change.
     522/**
     523@defgroup map_concepts Map Concepts
     524@ingroup concept
     525\brief Skeleton and concept checking classes for maps
     526
     527This group describes the skeletons and concept checking classes of maps.
    541528*/
    542529
  • doc/mainpage.dox

    r307 r314  
    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 \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
     60\ref migration "Migration Guide" for the backward incompatibilities.
    6061*/
  • doc/migration.dox

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

    r313 r314  
    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 \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.
    9696
    9797  template <typename _Container, typename _Item>
     
    104104    typedef _Item Item;
    105105
    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.
     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.
    114114    struct ImmediateDetach {};
    115115
    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.
    130 
     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.
    131130    class ObserverBase {
    132131    protected:
     
    135134      friend class AlterationNotifier;
    136135
    137       /// \brief Default constructor.
    138       ///
    139       /// Default constructor for ObserverBase.
    140       ///
     136      // \brief Default constructor.
     137      //
     138      // Default constructor for ObserverBase.
    141139      ObserverBase() : _notifier(0) {}
    142140
    143       /// \brief Constructor which attach the observer into notifier.
    144       ///
    145       /// Constructor which attach the observer into notifier.
     141      // \brief Constructor which attach the observer into notifier.
     142      //
     143      // Constructor which attach the observer into notifier.
    146144      ObserverBase(AlterationNotifier& nf) {
    147145        attach(nf);
    148146      }
    149147
    150       /// \brief Constructor which attach the obserever to the same notifier.
    151       ///
    152       /// Constructor which attach the obserever to the same notifier as
    153       /// the other observer is attached to.
     148      // \brief Constructor which attach the obserever to the same notifier.
     149      //
     150      // Constructor which attach the obserever to the same notifier as
     151      // the other observer is attached to.
    154152      ObserverBase(const ObserverBase& copy) {
    155153        if (copy.attached()) {
     
    158156      }
    159157
    160       /// \brief Destructor
     158      // \brief Destructor
    161159      virtual ~ObserverBase() {
    162160        if (attached()) {
     
    165163      }
    166164
    167       /// \brief Attaches the observer into an AlterationNotifier.
    168       ///
    169       /// This member attaches the observer into an AlterationNotifier.
    170       ///
     165      // \brief Attaches the observer into an AlterationNotifier.
     166      //
     167      // This member attaches the observer into an AlterationNotifier.
    171168      void attach(AlterationNotifier& nf) {
    172169        nf.attach(*this);
    173170      }
    174171
    175       /// \brief Detaches the observer into an AlterationNotifier.
    176       ///
    177       /// This member detaches the observer from an AlterationNotifier.
    178       ///
     172      // \brief Detaches the observer into an AlterationNotifier.
     173      //
     174      // This member detaches the observer from an AlterationNotifier.
    179175      void detach() {
    180176        _notifier->detach(*this);
    181177      }
    182178
    183       /// \brief Gives back a pointer to the notifier which the map
    184       /// attached into.
    185       ///
    186       /// This function gives back a pointer to the notifier which the map
    187       /// attached into.
    188       ///
     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.
    189184      Notifier* notifier() const { return const_cast<Notifier*>(_notifier); }
    190185
    191       /// Gives back true when the observer is attached into a notifier.
     186      // Gives back true when the observer is attached into a notifier.
    192187      bool attached() const { return _notifier != 0; }
    193188
     
    201196      typename std::list<ObserverBase*>::iterator _index;
    202197
    203       /// \brief The member function to notificate the observer about an
    204       /// item is added to the container.
    205       ///
    206       /// The add() member function notificates the observer about an item
    207       /// is added to the container. It have to be overrided in the
    208       /// subclasses.
     198      // \brief The member function to notificate the observer about an
     199      // item is added to the container.
     200      //
     201      // The add() member function notificates the observer about an item
     202      // is added to the container. It have to be overrided in the
     203      // subclasses.
    209204      virtual void add(const Item&) = 0;
    210205
    211       /// \brief The member function to notificate the observer about
    212       /// more item is added to the container.
    213       ///
    214       /// The add() member function notificates the observer about more item
    215       /// is added to the container. It have to be overrided in the
    216       /// subclasses.
     206      // \brief The member function to notificate the observer about
     207      // more item is added to the container.
     208      //
     209      // The add() member function notificates the observer about more item
     210      // is added to the container. It have to be overrided in the
     211      // subclasses.
    217212      virtual void add(const std::vector<Item>& items) = 0;
    218213
    219       /// \brief The member function to notificate the observer about an
    220       /// item is erased from the container.
    221       ///
    222       /// The erase() member function notificates the observer about an
    223       /// item is erased from the container. It have to be overrided in
    224       /// the subclasses.
     214      // \brief The member function to notificate the observer about an
     215      // item is erased from the container.
     216      //
     217      // The erase() member function notificates the observer about an
     218      // item is erased from the container. It have to be overrided in
     219      // the subclasses.
    225220      virtual void erase(const Item&) = 0;
    226221
    227       /// \brief The member function to notificate the observer about
    228       /// more item is erased from the container.
    229       ///
    230       /// The erase() member function notificates the observer about more item
    231       /// is erased from the container. It have to be overrided in the
    232       /// subclasses.
     222      // \brief The member function to notificate the observer about
     223      // more item is erased from the container.
     224      //
     225      // The erase() member function notificates the observer about more item
     226      // is erased from the container. It have to be overrided in the
     227      // subclasses.
    233228      virtual void erase(const std::vector<Item>& items) = 0;
    234229
    235       /// \brief The member function to notificate the observer about the
    236       /// container is built.
    237       ///
    238       /// The build() member function notificates the observer about the
    239       /// container is built from an empty container. It have to be
    240       /// overrided in the subclasses.
    241 
     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.
    242236      virtual void build() = 0;
    243237
    244       /// \brief The member function to notificate the observer about all
    245       /// items are erased from the container.
    246       ///
    247       /// The clear() member function notificates the observer about all
    248       /// items are erased from the container. It have to be overrided in
    249       /// the subclasses.
     238      // \brief The member function to notificate the observer about all
     239      // items are erased from the container.
     240      //
     241      // The clear() member function notificates the observer about all
     242      // items are erased from the container. It have to be overrided in
     243      // the subclasses.
    250244      virtual void clear() = 0;
    251245
     
    262256  public:
    263257
    264     /// \brief Default constructor.
    265     ///
    266     /// The default constructor of the AlterationNotifier.
    267     /// It creates an empty notifier.
     258    // \brief Default constructor.
     259    //
     260    // The default constructor of the AlterationNotifier.
     261    // It creates an empty notifier.
    268262    AlterationNotifier()
    269263      : container(0) {}
    270264
    271     /// \brief Constructor.
    272     ///
    273     /// Constructor with the observed container parameter.
     265    // \brief Constructor.
     266    //
     267    // Constructor with the observed container parameter.
    274268    AlterationNotifier(const Container& _container)
    275269      : container(&_container) {}
    276270
    277     /// \brief Copy Constructor of the AlterationNotifier.
    278     ///
    279     /// Copy constructor of the AlterationNotifier.
    280     /// It creates only an empty notifier because the copiable
    281     /// notifier's observers have to be registered still into that notifier.
     271    // \brief Copy Constructor of the AlterationNotifier.
     272    //
     273    // Copy constructor of the AlterationNotifier.
     274    // It creates only an empty notifier because the copiable
     275    // notifier's observers have to be registered still into that notifier.
    282276    AlterationNotifier(const AlterationNotifier& _notifier)
    283277      : container(_notifier.container) {}
    284278
    285     /// \brief Destructor.
    286     ///
    287     /// Destructor of the AlterationNotifier.
    288     ///
     279    // \brief Destructor.
     280    //
     281    // Destructor of the AlterationNotifier.
    289282    ~AlterationNotifier() {
    290283      typename Observers::iterator it;
     
    294287    }
    295288
    296     /// \brief Sets the container.
    297     ///
    298     /// Sets the container.
     289    // \brief Sets the container.
     290    //
     291    // Sets the container.
    299292    void setContainer(const Container& _container) {
    300293      container = &_container;
     
    307300  public:
    308301
    309 
    310 
    311     /// \brief First item in the container.
    312     ///
    313     /// Returns the first item in the container. It is
    314     /// for start the iteration on the container.
     302    // \brief First item in the container.
     303    //
     304    // Returns the first item in the container. It is
     305    // for start the iteration on the container.
    315306    void first(Item& item) const {
    316307      container->first(item);
    317308    }
    318309
    319     /// \brief Next item in the container.
    320     ///
    321     /// Returns the next item in the container. It is
    322     /// for iterate on the container.
     310    // \brief Next item in the container.
     311    //
     312    // Returns the next item in the container. It is
     313    // for iterate on the container.
    323314    void next(Item& item) const {
    324315      container->next(item);
    325316    }
    326317
    327     /// \brief Returns the id of the item.
    328     ///
    329     /// Returns the id of the item provided by the container.
     318    // \brief Returns the id of the item.
     319    //
     320    // Returns the id of the item provided by the container.
    330321    int id(const Item& item) const {
    331322      return container->id(item);
    332323    }
    333324
    334     /// \brief Returns the maximum id of the container.
    335     ///
    336     /// Returns the maximum id of the container.
     325    // \brief Returns the maximum id of the container.
     326    //
     327    // Returns the maximum id of the container.
    337328    int maxId() const {
    338329      return container->maxId(Item());
     
    354345  public:
    355346
    356     /// \brief Notifies all the registed observers about an item added to
    357     /// the container.
    358     ///
    359     /// It notifies all the registed observers about an item added to
    360     /// the container.
    361     ///
     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.
    362352    void add(const Item& item) {
    363353      typename Observers::reverse_iterator it;
     
    375365    }
    376366
    377     /// \brief Notifies all the registed observers about more item added to
    378     /// the container.
    379     ///
    380     /// It notifies all the registed observers about more item added to
    381     /// the container.
    382     ///
     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.
    383372    void add(const std::vector<Item>& items) {
    384373      typename Observers::reverse_iterator it;
     
    396385    }
    397386
    398     /// \brief Notifies all the registed observers about an item erased from
    399     /// the container.
    400     ///
    401     /// It notifies all the registed observers about an item erased from
    402     /// the container.
    403     ///
     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.
    404392    void erase(const Item& item) throw() {
    405393      typename Observers::iterator it = _observers.begin();
     
    416404    }
    417405
    418     /// \brief Notifies all the registed observers about more item erased
    419     /// from the container.
    420     ///
    421     /// It notifies all the registed observers about more item erased from
    422     /// the container.
    423     ///
     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.
    424411    void erase(const std::vector<Item>& items) {
    425412      typename Observers::iterator it = _observers.begin();
     
    436423    }
    437424
    438     /// \brief Notifies all the registed observers about the container is
    439     /// built.
    440     ///
    441     /// Notifies all the registed observers about the container is built
    442     /// from an empty container.
     425    // \brief Notifies all the registed observers about the container is
     426    // built.
     427    //
     428    // Notifies all the registed observers about the container is built
     429    // from an empty container.
    443430    void build() {
    444431      typename Observers::reverse_iterator it;
     
    456443    }
    457444
    458     /// \brief Notifies all the registed observers about all items are
    459     /// erased.
    460     ///
    461     /// Notifies all the registed observers about all items are erased
    462     /// from the container.
     445    // \brief Notifies all the registed observers about all items are
     446    // erased.
     447    //
     448    // Notifies all the registed observers about all items are erased
     449    // from the container.
    463450    void clear() {
    464451      typename Observers::iterator it = _observers.begin();
  • lemon/bits/array_map.h

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

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

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

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

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

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

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

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

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

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

    r313 r314  
    577577
    578578  ///Map of x-coordinates of a \ref Point "Point"-map.
    579   ///\ingroup maps
     579  ///
    580580  template<class M>
    581581  class XMap
     
    595595
    596596  ///This function just returns an XMap class.
    597   ///
    598   ///\ingroup maps
    599597  ///\relates XMap
    600598  template<class M>
     
    613611
    614612  ///Constant (read only) version of XMap.
    615   ///\ingroup maps
     613  ///
    616614  template<class M>
    617615  class ConstXMap
     
    630628
    631629  ///This function just returns a ConstXMap class.
    632   ///
    633   ///\ingroup maps
    634630  ///\relates ConstXMap
    635631  template<class M>
     
    642638
    643639  ///Map of y-coordinates of a \ref Point "Point"-map.
    644   ///\ingroup maps
     640  ///
    645641  template<class M>
    646642  class YMap
     
    660656
    661657  ///This function just returns a YMap class.
    662   ///
    663   ///\ingroup maps
    664658  ///\relates YMap
    665659  template<class M>
     
    678672
    679673  ///Constant (read only) version of YMap.
    680   ///\ingroup maps
     674  ///
    681675  template<class M>
    682676  class ConstYMap
     
    695689
    696690  ///This function just returns a ConstYMap class.
    697   ///
    698   ///\ingroup maps
    699691  ///\relates ConstYMap
    700692  template<class M>
     
    709701  ///Map of the \ref Point::normSquare() "normSquare()"
    710702  ///of a \ref Point "Point"-map.
    711   ///\ingroup maps
    712703  template<class M>
    713704  class NormSquareMap
     
    726717
    727718  ///This function just returns a NormSquareMap class.
    728   ///
    729   ///\ingroup maps
    730719  ///\relates NormSquareMap
    731720  template<class M>
  • lemon/maps.h

    r313 r314  
    16841684  }
    16851685
     1686  /// @}
     1687
     1688  /// \addtogroup maps
     1689  /// @{
     1690
    16861691  /// \brief Writable bool map for logging each \c true assigned element
    16871692  ///
     
    17761781  }
    17771782
     1783  /// @}
     1784
     1785  /// \addtogroup graph_maps
     1786  /// @{
     1787
    17781788  /// Provides an immutable and unique id for each item in the graph.
    17791789
     
    18821892    /// The value type of the InvertableMap.
    18831893    typedef typename Map::Value Value;
    1884 
    1885 
    18861894
    18871895    /// \brief Constructor.
     
    20492057      return InverseMap(*this);
    20502058    }
    2051 
    2052 
    20532059
    20542060  };
  • lemon/time_measure.h

    r313 r314  
    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 
     314    ///The \ref lemon::Timer "Timer" also counts the number of
     315    ///\ref lemon::Timer::start() "start()" executions, and it stops
    316316    ///only after the same amount (or more) \ref lemon::Timer::stop()
    317317    ///"stop()"s. This can be useful e.g. to compute the running time
Note: See TracChangeset for help on using the changeset viewer.