COIN-OR::LEMON - Graph Library

Changeset 318:2cc60866a0c9 in lemon-1.0 for lemon


Ignore:
Timestamp:
10/09/08 13:27:35 (11 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.
Location:
lemon
Files:
14 edited

Legend:

Unmodified
Added
Removed
  • lemon/bits/alteration_notifier.h

    r317 r318  
    2525#include <lemon/core.h>
    2626
    27 ///\ingroup graphbits
    28 ///\file
    29 ///\brief Observer notifier for graph alteration observers.
     27//\ingroup graphbits
     28//\file
     29//\brief Observer notifier for graph alteration observers.
    3030
    3131namespace lemon {
    3232
    33   /// \ingroup graphbits
    34   ///
    35   /// \brief Notifier class to notify observes about alterations in
    36   /// a container.
    37   ///
    38   /// The simple graph's can be refered as two containers, one node container
    39   /// and one edge container. But they are not standard containers they
    40   /// does not store values directly they are just key continars for more
    41   /// value containers which are the node and edge maps.
    42   ///
    43   /// The graph's node and edge sets can be changed as we add or erase
    44   /// nodes and edges in the graph. LEMON would like to handle easily
    45   /// that the node and edge maps should contain values for all nodes or
    46   /// edges. If we want to check on every indicing if the map contains
    47   /// the current indicing key that cause a drawback in the performance
    48   /// in the library. We use another solution we notify all maps about
    49   /// an alteration in the graph, which cause only drawback on the
    50   /// alteration of the graph.
    51   ///
    52   /// This class provides an interface to the container. The \e first() and \e
    53   /// next() member functions make possible to iterate on the keys of the
    54   /// container. The \e id() function returns an integer id for each key.
    55   /// The \e maxId() function gives back an upper bound of the ids.
    56   ///
    57   /// For the proper functonality of this class, we should notify it
    58   /// about each alteration in the container. The alterations have four type
    59   /// as \e add(), \e erase(), \e build() and \e clear(). The \e add() and
    60   /// \e erase() signals that only one or few items added or erased to or
    61   /// from the graph. If all items are erased from the graph or from an empty
    62   /// graph a new graph is builded then it can be signaled with the
    63   /// clear() and build() members. Important rule that if we erase items
    64   /// from graph we should first signal the alteration and after that erase
    65   /// them from the container, on the other way on item addition we should
    66   /// first extend the container and just after that signal the alteration.
    67   ///
    68   /// The alteration can be observed with a class inherited from the
    69   /// \e ObserverBase nested class. The signals can be handled with
    70   /// overriding the virtual functions defined in the base class.  The
    71   /// observer base can be attached to the notifier with the
    72   /// \e attach() member and can be detached with detach() function. The
    73   /// alteration handlers should not call any function which signals
    74   /// an other alteration in the same notifier and should not
    75   /// detach any observer from the notifier.
    76   ///
    77   /// Alteration observers try to be exception safe. If an \e add() or
    78   /// a \e clear() function throws an exception then the remaining
    79   /// observeres will not be notified and the fulfilled additions will
    80   /// be rolled back by calling the \e erase() or \e clear()
    81   /// functions. Thence the \e erase() and \e clear() should not throw
    82   /// exception. Actullay, it can be throw only \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 r318  
    2727#include <lemon/concepts/maps.h>
    2828
    29 /// \ingroup graphbits
    30 /// \file
    31 /// \brief Graph map based on the array storage.
     29// \ingroup graphbits
     30// \file
     31// \brief Graph map based on the array storage.
    3232
    3333namespace lemon {
    3434
    35   /// \ingroup graphbits
    36   ///
    37   /// \brief Graph map based on the array storage.
    38   ///
    39   /// The ArrayMap template class is graph map structure what
    40   /// automatically updates the map when a key is added to or erased from
    41   /// the map. This map uses the allocators to implement
    42   /// the container functionality.
    43   ///
    44   /// The template parameters are the Graph the current Item type and
    45   /// the Value type of the map.
     35  // \ingroup graphbits
     36  //
     37  // \brief Graph map based on the array storage.
     38  //
     39  // The ArrayMap template class is graph map structure what
     40  // automatically updates the map when a key is added to or erased from
     41  // the map. This map uses the allocators to implement
     42  // the container functionality.
     43  //
     44  // The template parameters are the Graph the current Item type and
     45  // the Value type of the map.
    4646  template <typename _Graph, typename _Item, typename _Value>
    4747  class ArrayMap
    4848    : public ItemSetTraits<_Graph, _Item>::ItemNotifier::ObserverBase {
    4949  public:
    50     /// The graph type of the maps.
     50    // The graph type of the maps.
    5151    typedef _Graph Graph;
    52     /// The item type of the map.
     52    // The item type of the map.
    5353    typedef _Item Item;
    54     /// The reference map tag.
     54    // The reference map tag.
    5555    typedef True ReferenceMapTag;
    5656
    57     /// The key type of the maps.
     57    // The key type of the maps.
    5858    typedef _Item Key;
    59     /// The value type of the map.
     59    // The value type of the map.
    6060    typedef _Value Value;
    6161
    62     /// The const reference type of the map.
     62    // The const reference type of the map.
    6363    typedef const _Value& ConstReference;
    64     /// The reference type of the map.
     64    // The reference type of the map.
    6565    typedef _Value& Reference;
    6666
    67     /// The notifier type.
     67    // The notifier type.
    6868    typedef typename ItemSetTraits<_Graph, _Item>::ItemNotifier Notifier;
    6969
    70     /// The MapBase of the Map which imlements the core regisitry function.
     70    // The MapBase of the Map which imlements the core regisitry function.
    7171    typedef typename Notifier::ObserverBase Parent;
    7272
     
    7676  public:
    7777
    78     /// \brief Graph initialized map constructor.
    79     ///
    80     /// Graph initialized map constructor.
     78    // \brief Graph initialized map constructor.
     79    //
     80    // Graph initialized map constructor.
    8181    explicit ArrayMap(const Graph& graph) {
    8282      Parent::attach(graph.notifier(Item()));
     
    9090    }
    9191
    92     /// \brief Constructor to use default value to initialize the map.
    93     ///
    94     /// It constructs a map and initialize all of the the map.
     92    // \brief Constructor to use default value to initialize the map.
     93    //
     94    // It constructs a map and initialize all of the the map.
    9595    ArrayMap(const Graph& graph, const Value& value) {
    9696      Parent::attach(graph.notifier(Item()));
     
    105105
    106106  private:
    107     /// \brief Constructor to copy a map of the same map type.
    108     ///
    109     /// Constructor to copy a map of the same map type.
     107    // \brief Constructor to copy a map of the same map type.
     108    //
     109    // Constructor to copy a map of the same map type.
    110110    ArrayMap(const ArrayMap& copy) : Parent() {
    111111      if (copy.attached()) {
     
    123123    }
    124124
    125     /// \brief Assign operator.
    126     ///
    127     /// This operator assigns for each item in the map the
    128     /// value mapped to the same item in the copied map.
    129     /// The parameter map should be indiced with the same
    130     /// itemset because this assign operator does not change
    131     /// the container of the map.
     125    // \brief Assign operator.
     126    //
     127    // This operator assigns for each item in the map the
     128    // value mapped to the same item in the copied map.
     129    // The parameter map should be indiced with the same
     130    // itemset because this assign operator does not change
     131    // the container of the map.
    132132    ArrayMap& operator=(const ArrayMap& cmap) {
    133133      return operator=<ArrayMap>(cmap);
     
    135135
    136136
    137     /// \brief Template assign operator.
    138     ///
    139     /// The given parameter should be conform to the ReadMap
    140     /// concecpt and could be indiced by the current item set of
    141     /// the NodeMap. In this case the value for each item
    142     /// is assigned by the value of the given ReadMap.
     137    // \brief Template assign operator.
     138    //
     139    // The given parameter should be conform to the ReadMap
     140    // concecpt and could be indiced by the current item set of
     141    // the NodeMap. In this case the value for each item
     142    // is assigned by the value of the given ReadMap.
    143143    template <typename CMap>
    144144    ArrayMap& operator=(const CMap& cmap) {
     
    153153
    154154  public:
    155     /// \brief The destructor of the map.
    156     ///
    157     /// The destructor of the map.
     155    // \brief The destructor of the map.
     156    //
     157    // The destructor of the map.
    158158    virtual ~ArrayMap() {
    159159      if (attached()) {
     
    171171  public:
    172172
    173     /// \brief The subscript operator.
    174     ///
    175     /// The subscript operator. The map can be subscripted by the
    176     /// actual keys of the graph.
     173    // \brief The subscript operator.
     174    //
     175    // The subscript operator. The map can be subscripted by the
     176    // actual keys of the graph.
    177177    Value& operator[](const Key& key) {
    178178      int id = Parent::notifier()->id(key);
     
    180180    }
    181181
    182     /// \brief The const subscript operator.
    183     ///
    184     /// The const subscript operator. The map can be subscripted by the
    185     /// actual keys of the graph.
     182    // \brief The const subscript operator.
     183    //
     184    // The const subscript operator. The map can be subscripted by the
     185    // actual keys of the graph.
    186186    const Value& operator[](const Key& key) const {
    187187      int id = Parent::notifier()->id(key);
     
    189189    }
    190190
    191     /// \brief Setter function of the map.
    192     ///
    193     /// Setter function of the map. Equivalent with map[key] = val.
    194     /// This is a compatibility feature with the not dereferable maps.
     191    // \brief Setter function of the map.
     192    //
     193    // Setter function of the map. Equivalent with map[key] = val.
     194    // This is a compatibility feature with the not dereferable maps.
    195195    void set(const Key& key, const Value& val) {
    196196      (*this)[key] = val;
     
    199199  protected:
    200200
    201     /// \brief Adds a new key to the map.
    202     ///
    203     /// It adds a new key to the map. It called by the observer notifier
    204     /// and it overrides the add() member function of the observer base.
     201    // \brief Adds a new key to the map.
     202    //
     203    // It adds a new key to the map. It called by the observer notifier
     204    // and it overrides the add() member function of the observer base.
    205205    virtual void add(const Key& key) {
    206206      Notifier* nf = Parent::notifier();
     
    227227    }
    228228
    229     /// \brief Adds more new keys to the map.
    230     ///
    231     /// It adds more new keys to the map. It called by the observer notifier
    232     /// and it overrides the add() member function of the observer base.
     229    // \brief Adds more new keys to the map.
     230    //
     231    // It adds more new keys to the map. It called by the observer notifier
     232    // and it overrides the add() member function of the observer base.
    233233    virtual void add(const std::vector<Key>& keys) {
    234234      Notifier* nf = Parent::notifier();
     
    271271    }
    272272
    273     /// \brief Erase a key from the map.
    274     ///
    275     /// Erase a key from the map. It called by the observer notifier
    276     /// and it overrides the erase() member function of the observer base.
     273    // \brief Erase a key from the map.
     274    //
     275    // Erase a key from the map. It called by the observer notifier
     276    // and it overrides the erase() member function of the observer base.
    277277    virtual void erase(const Key& key) {
    278278      int id = Parent::notifier()->id(key);
     
    280280    }
    281281
    282     /// \brief Erase more keys from the map.
    283     ///
    284     /// Erase more keys from the map. It called by the observer notifier
    285     /// and it overrides the erase() member function of the observer base.
     282    // \brief Erase more keys from the map.
     283    //
     284    // Erase more keys from the map. It called by the observer notifier
     285    // and it overrides the erase() member function of the observer base.
    286286    virtual void erase(const std::vector<Key>& keys) {
    287287      for (int i = 0; i < int(keys.size()); ++i) {
     
    291291    }
    292292
    293     /// \brief Buildes the map.
    294     ///
    295     /// It buildes the map. It called by the observer notifier
    296     /// and it overrides the build() member function of the observer base.
     293    // \brief Buildes the map.
     294    //
     295    // It buildes the map. It called by the observer notifier
     296    // and it overrides the build() member function of the observer base.
    297297    virtual void build() {
    298298      Notifier* nf = Parent::notifier();
     
    305305    }
    306306
    307     /// \brief Clear the map.
    308     ///
    309     /// It erase all items from the map. It called by the observer notifier
    310     /// and it overrides the clear() member function of the observer base.
     307    // \brief Clear the map.
     308    //
     309    // It erase all items from the map. It called by the observer notifier
     310    // and it overrides the clear() member function of the observer base.
    311311    virtual void clear() {
    312312      Notifier* nf = Parent::notifier();
  • lemon/bits/base_extender.h

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

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

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

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

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

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

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

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

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

    r317 r318  
    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

    r317 r318  
    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

    r317 r318  
    312312    ///Basically a Timer can be either running or stopped,
    313313    ///but it provides a bit finer control on the execution.
    314     ///The \ref 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.