COIN-OR::LEMON - Graph Library

Changeset 314:2cc60866a0c9 in lemon


Ignore:
Timestamp:
10/09/08 13:27:35 (10 years ago)
Author:
Peter Kovacs <kpeter@…>
Branch:
default
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.