COIN-OR::LEMON - Graph Library

Ticket #119: 9db8964f0cf6.patch

File 9db8964f0cf6.patch, 43.4 KB (added by Peter Kovacs, 11 years ago)
  • lemon/bfs.h

    # HG changeset patch
    # User Peter Kovacs <kpeter@inf.elte.hu>
    # Date 1223466020 -7200
    # Node ID 9db8964f0cf6cd936aba513d7dde0d7bb7d187e8
    # Parent  907446600ca9618c543cd9ba27d594bf79fe2dba
    Fix several doxygen warings
    
    diff --git a/lemon/bfs.h b/lemon/bfs.h
    a b  
    4949    ///arcs of the shortest paths.
    5050    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    5151    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
    52     ///Instantiates a \ref PredMap.
     52    ///Instantiates a PredMap.
    5353
    54     ///This function instantiates a \ref PredMap.
     54    ///This function instantiates a PredMap.
    5555    ///\param g is the digraph, to which we would like to define the
    56     ///\ref PredMap.
     56    ///PredMap.
    5757    static PredMap *createPredMap(const Digraph &g)
    5858    {
    5959      return new PredMap(g);
     
    6464    ///The type of the map that indicates which nodes are processed.
    6565    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    6666    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    67     ///Instantiates a \ref ProcessedMap.
     67    ///Instantiates a ProcessedMap.
    6868
    69     ///This function instantiates a \ref ProcessedMap.
     69    ///This function instantiates a ProcessedMap.
    7070    ///\param g is the digraph, to which
    71     ///we would like to define the \ref ProcessedMap
     71    ///we would like to define the ProcessedMap
    7272#ifdef DOXYGEN
    7373    static ProcessedMap *createProcessedMap(const Digraph &g)
    7474#else
     
    8383    ///The type of the map that indicates which nodes are reached.
    8484    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
    8585    typedef typename Digraph::template NodeMap<bool> ReachedMap;
    86     ///Instantiates a \ref ReachedMap.
     86    ///Instantiates a ReachedMap.
    8787
    88     ///This function instantiates a \ref ReachedMap.
     88    ///This function instantiates a ReachedMap.
    8989    ///\param g is the digraph, to which
    90     ///we would like to define the \ref ReachedMap.
     90    ///we would like to define the ReachedMap.
    9191    static ReachedMap *createReachedMap(const Digraph &g)
    9292    {
    9393      return new ReachedMap(g);
     
    9898    ///The type of the map that stores the distances of the nodes.
    9999    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    100100    typedef typename Digraph::template NodeMap<int> DistMap;
    101     ///Instantiates a \ref DistMap.
     101    ///Instantiates a DistMap.
    102102
    103     ///This function instantiates a \ref DistMap.
     103    ///This function instantiates a DistMap.
    104104    ///\param g is the digraph, to which we would like to define the
    105     ///\ref DistMap.
     105    ///DistMap.
    106106    static DistMap *createDistMap(const Digraph &g)
    107107    {
    108108      return new DistMap(g);
     
    227227      }
    228228    };
    229229    ///\brief \ref named-templ-param "Named parameter" for setting
    230     ///\ref PredMap type.
     230    ///PredMap type.
    231231    ///
    232232    ///\ref named-templ-param "Named parameter" for setting
    233     ///\ref PredMap type.
     233    ///PredMap type.
    234234    template <class T>
    235235    struct SetPredMap : public Bfs< Digraph, SetPredMapTraits<T> > {
    236236      typedef Bfs< Digraph, SetPredMapTraits<T> > Create;
     
    246246      }
    247247    };
    248248    ///\brief \ref named-templ-param "Named parameter" for setting
    249     ///\ref DistMap type.
     249    ///DistMap type.
    250250    ///
    251251    ///\ref named-templ-param "Named parameter" for setting
    252     ///\ref DistMap type.
     252    ///DistMap type.
    253253    template <class T>
    254254    struct SetDistMap : public Bfs< Digraph, SetDistMapTraits<T> > {
    255255      typedef Bfs< Digraph, SetDistMapTraits<T> > Create;
     
    265265      }
    266266    };
    267267    ///\brief \ref named-templ-param "Named parameter" for setting
    268     ///\ref ReachedMap type.
     268    ///ReachedMap type.
    269269    ///
    270270    ///\ref named-templ-param "Named parameter" for setting
    271     ///\ref ReachedMap type.
     271    ///ReachedMap type.
    272272    template <class T>
    273273    struct SetReachedMap : public Bfs< Digraph, SetReachedMapTraits<T> > {
    274274      typedef Bfs< Digraph, SetReachedMapTraits<T> > Create;
     
    284284      }
    285285    };
    286286    ///\brief \ref named-templ-param "Named parameter" for setting
    287     ///\ref ProcessedMap type.
     287    ///ProcessedMap type.
    288288    ///
    289289    ///\ref named-templ-param "Named parameter" for setting
    290     ///\ref ProcessedMap type.
     290    ///ProcessedMap type.
    291291    template <class T>
    292292    struct SetProcessedMap : public Bfs< Digraph, SetProcessedMapTraits<T> > {
    293293      typedef Bfs< Digraph, SetProcessedMapTraits<T> > Create;
     
    302302      }
    303303    };
    304304    ///\brief \ref named-templ-param "Named parameter" for setting
    305     ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     305    ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
    306306    ///
    307307    ///\ref named-templ-param "Named parameter" for setting
    308     ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     308    ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
    309309    ///If you don't set it explicitly, it will be automatically allocated.
    310310    struct SetStandardProcessedMap :
    311311      public Bfs< Digraph, SetStandardProcessedMapTraits > {
     
    835835    ///arcs of the shortest paths.
    836836    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    837837    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
    838     ///Instantiates a \ref PredMap.
     838    ///Instantiates a PredMap.
    839839
    840     ///This function instantiates a \ref PredMap.
     840    ///This function instantiates a PredMap.
    841841    ///\param g is the digraph, to which we would like to define the
    842     ///\ref PredMap.
     842    ///PredMap.
    843843    static PredMap *createPredMap(const Digraph &g)
    844844    {
    845845      return new PredMap(g);
     
    851851    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    852852    ///By default it is a NullMap.
    853853    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    854     ///Instantiates a \ref ProcessedMap.
     854    ///Instantiates a ProcessedMap.
    855855
    856     ///This function instantiates a \ref ProcessedMap.
     856    ///This function instantiates a ProcessedMap.
    857857    ///\param g is the digraph, to which
    858     ///we would like to define the \ref ProcessedMap.
     858    ///we would like to define the ProcessedMap.
    859859#ifdef DOXYGEN
    860860    static ProcessedMap *createProcessedMap(const Digraph &g)
    861861#else
     
    870870    ///The type of the map that indicates which nodes are reached.
    871871    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
    872872    typedef typename Digraph::template NodeMap<bool> ReachedMap;
    873     ///Instantiates a \ref ReachedMap.
     873    ///Instantiates a ReachedMap.
    874874
    875     ///This function instantiates a \ref ReachedMap.
     875    ///This function instantiates a ReachedMap.
    876876    ///\param g is the digraph, to which
    877     ///we would like to define the \ref ReachedMap.
     877    ///we would like to define the ReachedMap.
    878878    static ReachedMap *createReachedMap(const Digraph &g)
    879879    {
    880880      return new ReachedMap(g);
     
    885885    ///The type of the map that stores the distances of the nodes.
    886886    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    887887    typedef typename Digraph::template NodeMap<int> DistMap;
    888     ///Instantiates a \ref DistMap.
     888    ///Instantiates a DistMap.
    889889
    890     ///This function instantiates a \ref DistMap.
     890    ///This function instantiates a DistMap.
    891891    ///\param g is the digraph, to which we would like to define
    892     ///the \ref DistMap
     892    ///the DistMap
    893893    static DistMap *createDistMap(const Digraph &g)
    894894    {
    895895      return new DistMap(g);
     
    902902    typedef lemon::Path<Digraph> Path;
    903903  };
    904904
    905   /// Default traits class used by \ref BfsWizard
     905  /// Default traits class used by BfsWizard
    906906
    907907  /// To make it easier to use Bfs algorithm
    908908  /// we have created a wizard class.
     
    10681068      SetPredMapBase(const TR &b) : TR(b) {}
    10691069    };
    10701070    ///\brief \ref named-func-param "Named parameter"
    1071     ///for setting \ref PredMap object.
     1071    ///for setting PredMap object.
    10721072    ///
    10731073    ///\ref named-func-param "Named parameter"
    1074     ///for setting \ref PredMap object.
     1074    ///for setting PredMap object.
    10751075    template<class T>
    10761076    BfsWizard<SetPredMapBase<T> > predMap(const T &t)
    10771077    {
     
    10861086      SetReachedMapBase(const TR &b) : TR(b) {}
    10871087    };
    10881088    ///\brief \ref named-func-param "Named parameter"
    1089     ///for setting \ref ReachedMap object.
     1089    ///for setting ReachedMap object.
    10901090    ///
    10911091    /// \ref named-func-param "Named parameter"
    1092     ///for setting \ref ReachedMap object.
     1092    ///for setting ReachedMap object.
    10931093    template<class T>
    10941094    BfsWizard<SetReachedMapBase<T> > reachedMap(const T &t)
    10951095    {
     
    11041104      SetDistMapBase(const TR &b) : TR(b) {}
    11051105    };
    11061106    ///\brief \ref named-func-param "Named parameter"
    1107     ///for setting \ref DistMap object.
     1107    ///for setting DistMap object.
    11081108    ///
    11091109    /// \ref named-func-param "Named parameter"
    1110     ///for setting \ref DistMap object.
     1110    ///for setting DistMap object.
    11111111    template<class T>
    11121112    BfsWizard<SetDistMapBase<T> > distMap(const T &t)
    11131113    {
     
    11221122      SetProcessedMapBase(const TR &b) : TR(b) {}
    11231123    };
    11241124    ///\brief \ref named-func-param "Named parameter"
    1125     ///for setting \ref ProcessedMap object.
     1125    ///for setting ProcessedMap object.
    11261126    ///
    11271127    /// \ref named-func-param "Named parameter"
    1128     ///for setting \ref ProcessedMap object.
     1128    ///for setting ProcessedMap object.
    11291129    template<class T>
    11301130    BfsWizard<SetProcessedMapBase<T> > processedMap(const T &t)
    11311131    {
     
    12671267    /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
    12681268    typedef typename Digraph::template NodeMap<bool> ReachedMap;
    12691269
    1270     /// \brief Instantiates a \ref ReachedMap.
     1270    /// \brief Instantiates a ReachedMap.
    12711271    ///
    1272     /// This function instantiates a \ref ReachedMap.
     1272    /// This function instantiates a ReachedMap.
    12731273    /// \param digraph is the digraph, to which
    1274     /// we would like to define the \ref ReachedMap.
     1274    /// we would like to define the ReachedMap.
    12751275    static ReachedMap *createReachedMap(const Digraph &digraph) {
    12761276      return new ReachedMap(digraph);
    12771277    }
  • lemon/dfs.h

    diff --git a/lemon/dfs.h b/lemon/dfs.h
    a b  
    5050    ///arcs of the %DFS paths.
    5151    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    5252    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
    53     ///Instantiates a \ref PredMap.
     53    ///Instantiates a PredMap.
    5454
    55     ///This function instantiates a \ref PredMap.
     55    ///This function instantiates a PredMap.
    5656    ///\param g is the digraph, to which we would like to define the
    57     ///\ref PredMap.
     57    ///PredMap.
    5858    static PredMap *createPredMap(const Digraph &g)
    5959    {
    6060      return new PredMap(g);
     
    6565    ///The type of the map that indicates which nodes are processed.
    6666    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    6767    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    68     ///Instantiates a \ref ProcessedMap.
     68    ///Instantiates a ProcessedMap.
    6969
    70     ///This function instantiates a \ref ProcessedMap.
     70    ///This function instantiates a ProcessedMap.
    7171    ///\param g is the digraph, to which
    72     ///we would like to define the \ref ProcessedMap
     72    ///we would like to define the ProcessedMap
    7373#ifdef DOXYGEN
    7474    static ProcessedMap *createProcessedMap(const Digraph &g)
    7575#else
     
    8484    ///The type of the map that indicates which nodes are reached.
    8585    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
    8686    typedef typename Digraph::template NodeMap<bool> ReachedMap;
    87     ///Instantiates a \ref ReachedMap.
     87    ///Instantiates a ReachedMap.
    8888
    89     ///This function instantiates a \ref ReachedMap.
     89    ///This function instantiates a ReachedMap.
    9090    ///\param g is the digraph, to which
    91     ///we would like to define the \ref ReachedMap.
     91    ///we would like to define the ReachedMap.
    9292    static ReachedMap *createReachedMap(const Digraph &g)
    9393    {
    9494      return new ReachedMap(g);
     
    9999    ///The type of the map that stores the distances of the nodes.
    100100    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    101101    typedef typename Digraph::template NodeMap<int> DistMap;
    102     ///Instantiates a \ref DistMap.
     102    ///Instantiates a DistMap.
    103103
    104     ///This function instantiates a \ref DistMap.
     104    ///This function instantiates a DistMap.
    105105    ///\param g is the digraph, to which we would like to define the
    106     ///\ref DistMap.
     106    ///DistMap.
    107107    static DistMap *createDistMap(const Digraph &g)
    108108    {
    109109      return new DistMap(g);
     
    227227      }
    228228    };
    229229    ///\brief \ref named-templ-param "Named parameter" for setting
    230     ///\ref PredMap type.
     230    ///PredMap type.
    231231    ///
    232232    ///\ref named-templ-param "Named parameter" for setting
    233     ///\ref PredMap type.
     233    ///PredMap type.
    234234    template <class T>
    235235    struct SetPredMap : public Dfs<Digraph, SetPredMapTraits<T> > {
    236236      typedef Dfs<Digraph, SetPredMapTraits<T> > Create;
     
    246246      }
    247247    };
    248248    ///\brief \ref named-templ-param "Named parameter" for setting
    249     ///\ref DistMap type.
     249    ///DistMap type.
    250250    ///
    251251    ///\ref named-templ-param "Named parameter" for setting
    252     ///\ref DistMap type.
     252    ///DistMap type.
    253253    template <class T>
    254254    struct SetDistMap : public Dfs< Digraph, SetDistMapTraits<T> > {
    255255      typedef Dfs<Digraph, SetDistMapTraits<T> > Create;
     
    265265      }
    266266    };
    267267    ///\brief \ref named-templ-param "Named parameter" for setting
    268     ///\ref ReachedMap type.
     268    ///ReachedMap type.
    269269    ///
    270270    ///\ref named-templ-param "Named parameter" for setting
    271     ///\ref ReachedMap type.
     271    ///ReachedMap type.
    272272    template <class T>
    273273    struct SetReachedMap : public Dfs< Digraph, SetReachedMapTraits<T> > {
    274274      typedef Dfs< Digraph, SetReachedMapTraits<T> > Create;
     
    284284      }
    285285    };
    286286    ///\brief \ref named-templ-param "Named parameter" for setting
    287     ///\ref ProcessedMap type.
     287    ///ProcessedMap type.
    288288    ///
    289289    ///\ref named-templ-param "Named parameter" for setting
    290     ///\ref ProcessedMap type.
     290    ///ProcessedMap type.
    291291    template <class T>
    292292    struct SetProcessedMap : public Dfs< Digraph, SetProcessedMapTraits<T> > {
    293293      typedef Dfs< Digraph, SetProcessedMapTraits<T> > Create;
     
    301301      }
    302302    };
    303303    ///\brief \ref named-templ-param "Named parameter" for setting
    304     ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     304    ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
    305305    ///
    306306    ///\ref named-templ-param "Named parameter" for setting
    307     ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     307    ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
    308308    ///If you don't set it explicitly, it will be automatically allocated.
    309309    struct SetStandardProcessedMap :
    310310      public Dfs< Digraph, SetStandardProcessedMapTraits > {
     
    768768    ///arcs of the %DFS paths.
    769769    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    770770    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
    771     ///Instantiates a \ref PredMap.
     771    ///Instantiates a PredMap.
    772772
    773     ///This function instantiates a \ref PredMap.
     773    ///This function instantiates a PredMap.
    774774    ///\param g is the digraph, to which we would like to define the
    775     ///\ref PredMap.
     775    ///PredMap.
    776776    static PredMap *createPredMap(const Digraph &g)
    777777    {
    778778      return new PredMap(g);
     
    784784    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    785785    ///By default it is a NullMap.
    786786    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    787     ///Instantiates a \ref ProcessedMap.
     787    ///Instantiates a ProcessedMap.
    788788
    789     ///This function instantiates a \ref ProcessedMap.
     789    ///This function instantiates a ProcessedMap.
    790790    ///\param g is the digraph, to which
    791     ///we would like to define the \ref ProcessedMap.
     791    ///we would like to define the ProcessedMap.
    792792#ifdef DOXYGEN
    793793    static ProcessedMap *createProcessedMap(const Digraph &g)
    794794#else
     
    803803    ///The type of the map that indicates which nodes are reached.
    804804    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
    805805    typedef typename Digraph::template NodeMap<bool> ReachedMap;
    806     ///Instantiates a \ref ReachedMap.
     806    ///Instantiates a ReachedMap.
    807807
    808     ///This function instantiates a \ref ReachedMap.
     808    ///This function instantiates a ReachedMap.
    809809    ///\param g is the digraph, to which
    810     ///we would like to define the \ref ReachedMap.
     810    ///we would like to define the ReachedMap.
    811811    static ReachedMap *createReachedMap(const Digraph &g)
    812812    {
    813813      return new ReachedMap(g);
     
    818818    ///The type of the map that stores the distances of the nodes.
    819819    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    820820    typedef typename Digraph::template NodeMap<int> DistMap;
    821     ///Instantiates a \ref DistMap.
     821    ///Instantiates a DistMap.
    822822
    823     ///This function instantiates a \ref DistMap.
     823    ///This function instantiates a DistMap.
    824824    ///\param g is the digraph, to which we would like to define
    825     ///the \ref DistMap
     825    ///the DistMap
    826826    static DistMap *createDistMap(const Digraph &g)
    827827    {
    828828      return new DistMap(g);
     
    10011001      SetPredMapBase(const TR &b) : TR(b) {}
    10021002    };
    10031003    ///\brief \ref named-func-param "Named parameter"
    1004     ///for setting \ref PredMap object.
     1004    ///for setting PredMap object.
    10051005    ///
    10061006    ///\ref named-func-param "Named parameter"
    1007     ///for setting \ref PredMap object.
     1007    ///for setting PredMap object.
    10081008    template<class T>
    10091009    DfsWizard<SetPredMapBase<T> > predMap(const T &t)
    10101010    {
     
    10191019      SetReachedMapBase(const TR &b) : TR(b) {}
    10201020    };
    10211021    ///\brief \ref named-func-param "Named parameter"
    1022     ///for setting \ref ReachedMap object.
     1022    ///for setting ReachedMap object.
    10231023    ///
    10241024    /// \ref named-func-param "Named parameter"
    1025     ///for setting \ref ReachedMap object.
     1025    ///for setting ReachedMap object.
    10261026    template<class T>
    10271027    DfsWizard<SetReachedMapBase<T> > reachedMap(const T &t)
    10281028    {
     
    10371037      SetDistMapBase(const TR &b) : TR(b) {}
    10381038    };
    10391039    ///\brief \ref named-func-param "Named parameter"
    1040     ///for setting \ref DistMap object.
     1040    ///for setting DistMap object.
    10411041    ///
    10421042    /// \ref named-func-param "Named parameter"
    1043     ///for setting \ref DistMap object.
     1043    ///for setting DistMap object.
    10441044    template<class T>
    10451045    DfsWizard<SetDistMapBase<T> > distMap(const T &t)
    10461046    {
     
    10551055      SetProcessedMapBase(const TR &b) : TR(b) {}
    10561056    };
    10571057    ///\brief \ref named-func-param "Named parameter"
    1058     ///for setting \ref ProcessedMap object.
     1058    ///for setting ProcessedMap object.
    10591059    ///
    10601060    /// \ref named-func-param "Named parameter"
    1061     ///for setting \ref ProcessedMap object.
     1061    ///for setting ProcessedMap object.
    10621062    template<class T>
    10631063    DfsWizard<SetProcessedMapBase<T> > processedMap(const T &t)
    10641064    {
     
    12131213    /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
    12141214    typedef typename Digraph::template NodeMap<bool> ReachedMap;
    12151215
    1216     /// \brief Instantiates a \ref ReachedMap.
     1216    /// \brief Instantiates a ReachedMap.
    12171217    ///
    1218     /// This function instantiates a \ref ReachedMap.
     1218    /// This function instantiates a ReachedMap.
    12191219    /// \param digraph is the digraph, to which
    1220     /// we would like to define the \ref ReachedMap.
     1220    /// we would like to define the ReachedMap.
    12211221    static ReachedMap *createReachedMap(const Digraph &digraph) {
    12221222      return new ReachedMap(digraph);
    12231223    }
  • lemon/dijkstra.h

    diff --git a/lemon/dijkstra.h b/lemon/dijkstra.h
    a b  
    139139    ///arcs of the shortest paths.
    140140    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    141141    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
    142     ///Instantiates a \ref PredMap.
     142    ///Instantiates a PredMap.
    143143
    144     ///This function instantiates a \ref PredMap.
     144    ///This function instantiates a PredMap.
    145145    ///\param g is the digraph, to which we would like to define the
    146     ///\ref PredMap.
     146    ///PredMap.
    147147    static PredMap *createPredMap(const Digraph &g)
    148148    {
    149149      return new PredMap(g);
     
    155155    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    156156    ///By default it is a NullMap.
    157157    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    158     ///Instantiates a \ref ProcessedMap.
     158    ///Instantiates a ProcessedMap.
    159159
    160     ///This function instantiates a \ref ProcessedMap.
     160    ///This function instantiates a ProcessedMap.
    161161    ///\param g is the digraph, to which
    162     ///we would like to define the \ref ProcessedMap
     162    ///we would like to define the ProcessedMap
    163163#ifdef DOXYGEN
    164164    static ProcessedMap *createProcessedMap(const Digraph &g)
    165165#else
     
    174174    ///The type of the map that stores the distances of the nodes.
    175175    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    176176    typedef typename Digraph::template NodeMap<typename LM::Value> DistMap;
    177     ///Instantiates a \ref DistMap.
     177    ///Instantiates a DistMap.
    178178
    179     ///This function instantiates a \ref DistMap.
     179    ///This function instantiates a DistMap.
    180180    ///\param g is the digraph, to which we would like to define
    181     ///the \ref DistMap
     181    ///the DistMap
    182182    static DistMap *createDistMap(const Digraph &g)
    183183    {
    184184      return new DistMap(g);
     
    327327      }
    328328    };
    329329    ///\brief \ref named-templ-param "Named parameter" for setting
    330     ///\ref PredMap type.
     330    ///PredMap type.
    331331    ///
    332332    ///\ref named-templ-param "Named parameter" for setting
    333     ///\ref PredMap type.
     333    ///PredMap type.
    334334    template <class T>
    335335    struct SetPredMap
    336336      : public Dijkstra< Digraph, LengthMap, SetPredMapTraits<T> > {
     
    347347      }
    348348    };
    349349    ///\brief \ref named-templ-param "Named parameter" for setting
    350     ///\ref DistMap type.
     350    ///DistMap type.
    351351    ///
    352352    ///\ref named-templ-param "Named parameter" for setting
    353     ///\ref DistMap type.
     353    ///DistMap type.
    354354    template <class T>
    355355    struct SetDistMap
    356356      : public Dijkstra< Digraph, LengthMap, SetDistMapTraits<T> > {
     
    367367      }
    368368    };
    369369    ///\brief \ref named-templ-param "Named parameter" for setting
    370     ///\ref ProcessedMap type.
     370    ///ProcessedMap type.
    371371    ///
    372372    ///\ref named-templ-param "Named parameter" for setting
    373     ///\ref ProcessedMap type.
     373    ///ProcessedMap type.
    374374    template <class T>
    375375    struct SetProcessedMap
    376376      : public Dijkstra< Digraph, LengthMap, SetProcessedMapTraits<T> > {
     
    385385      }
    386386    };
    387387    ///\brief \ref named-templ-param "Named parameter" for setting
    388     ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     388    ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
    389389    ///
    390390    ///\ref named-templ-param "Named parameter" for setting
    391     ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     391    ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
    392392    ///If you don't set it explicitly, it will be automatically allocated.
    393393    struct SetStandardProcessedMap
    394394      : public Dijkstra< Digraph, LengthMap, SetStandardProcessedMapTraits > {
     
    986986    ///arcs of the shortest paths.
    987987    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    988988    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
    989     ///Instantiates a \ref PredMap.
     989    ///Instantiates a PredMap.
    990990
    991     ///This function instantiates a \ref PredMap.
     991    ///This function instantiates a PredMap.
    992992    ///\param g is the digraph, to which we would like to define the
    993     ///\ref PredMap.
     993    ///PredMap.
    994994    static PredMap *createPredMap(const Digraph &g)
    995995    {
    996996      return new PredMap(g);
     
    10021002    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    10031003    ///By default it is a NullMap.
    10041004    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    1005     ///Instantiates a \ref ProcessedMap.
     1005    ///Instantiates a ProcessedMap.
    10061006
    1007     ///This function instantiates a \ref ProcessedMap.
     1007    ///This function instantiates a ProcessedMap.
    10081008    ///\param g is the digraph, to which
    1009     ///we would like to define the \ref ProcessedMap.
     1009    ///we would like to define the ProcessedMap.
    10101010#ifdef DOXYGEN
    10111011    static ProcessedMap *createProcessedMap(const Digraph &g)
    10121012#else
     
    10211021    ///The type of the map that stores the distances of the nodes.
    10221022    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    10231023    typedef typename Digraph::template NodeMap<typename LM::Value> DistMap;
    1024     ///Instantiates a \ref DistMap.
     1024    ///Instantiates a DistMap.
    10251025
    1026     ///This function instantiates a \ref DistMap.
     1026    ///This function instantiates a DistMap.
    10271027    ///\param g is the digraph, to which we would like to define
    1028     ///the \ref DistMap
     1028    ///the DistMap
    10291029    static DistMap *createDistMap(const Digraph &g)
    10301030    {
    10311031      return new DistMap(g);
     
    11981198      SetPredMapBase(const TR &b) : TR(b) {}
    11991199    };
    12001200    ///\brief \ref named-func-param "Named parameter"
    1201     ///for setting \ref PredMap object.
     1201    ///for setting PredMap object.
    12021202    ///
    12031203    ///\ref named-func-param "Named parameter"
    1204     ///for setting \ref PredMap object.
     1204    ///for setting PredMap object.
    12051205    template<class T>
    12061206    DijkstraWizard<SetPredMapBase<T> > predMap(const T &t)
    12071207    {
     
    12161216      SetDistMapBase(const TR &b) : TR(b) {}
    12171217    };
    12181218    ///\brief \ref named-func-param "Named parameter"
    1219     ///for setting \ref DistMap object.
     1219    ///for setting DistMap object.
    12201220    ///
    12211221    ///\ref named-func-param "Named parameter"
    1222     ///for setting \ref DistMap object.
     1222    ///for setting DistMap object.
    12231223    template<class T>
    12241224    DijkstraWizard<SetDistMapBase<T> > distMap(const T &t)
    12251225    {
     
    12341234      SetProcessedMapBase(const TR &b) : TR(b) {}
    12351235    };
    12361236    ///\brief \ref named-func-param "Named parameter"
    1237     ///for setting \ref ProcessedMap object.
     1237    ///for setting ProcessedMap object.
    12381238    ///
    12391239    /// \ref named-func-param "Named parameter"
    1240     ///for setting \ref ProcessedMap object.
     1240    ///for setting ProcessedMap object.
    12411241    template<class T>
    12421242    DijkstraWizard<SetProcessedMapBase<T> > processedMap(const T &t)
    12431243    {
  • lemon/maps.h

    diff --git a/lemon/maps.h b/lemon/maps.h
    a b  
    7373    void set(const Key&, const Value&) {}
    7474  };
    7575
    76   /// Returns a \ref NullMap class
     76  /// Returns a \c NullMap class
    7777
    78   /// This function just returns a \ref NullMap class.
     78  /// This function just returns a \c NullMap class.
    7979  /// \relates NullMap
    8080  template <typename K, typename V>
    8181  NullMap<K, V> nullMap() {
     
    8888  /// This \ref concepts::ReadMap "readable map" assigns a specified
    8989  /// value to each key.
    9090  ///
    91   /// In other aspects it is equivalent to \ref NullMap.
     91  /// In other aspects it is equivalent to \c NullMap.
    9292  /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap"
    9393  /// concept, but it absorbs the data written to it.
    9494  ///
     
    133133    ConstMap(const ConstMap<K, V1> &, const Value &v) : _value(v) {}
    134134  };
    135135
    136   /// Returns a \ref ConstMap class
     136  /// Returns a \c ConstMap class
    137137
    138   /// This function just returns a \ref ConstMap class.
     138  /// This function just returns a \c ConstMap class.
    139139  /// \relates ConstMap
    140140  template<typename K, typename V>
    141141  inline ConstMap<K, V> constMap(const V &v) {
     
    156156  /// This \ref concepts::ReadMap "readable map" assigns a specified
    157157  /// value to each key.
    158158  ///
    159   /// In other aspects it is equivalent to \ref NullMap.
     159  /// In other aspects it is equivalent to \c NullMap.
    160160  /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap"
    161161  /// concept, but it absorbs the data written to it.
    162162  ///
     
    182182    void set(const Key&, const Value&) {}
    183183  };
    184184
    185   /// Returns a \ref ConstMap class with inlined constant value
     185  /// Returns a \c ConstMap class with inlined constant value
    186186
    187   /// This function just returns a \ref ConstMap class with inlined
     187  /// This function just returns a \c ConstMap class with inlined
    188188  /// constant value.
    189189  /// \relates ConstMap
    190190  template<typename K, typename V, V v>
     
    212212    }
    213213  };
    214214
    215   /// Returns an \ref IdentityMap class
     215  /// Returns an \c IdentityMap class
    216216
    217   /// This function just returns an \ref IdentityMap class.
     217  /// This function just returns an \c IdentityMap class.
    218218  /// \relates IdentityMap
    219219  template<typename T>
    220220  inline IdentityMap<T> identityMap() {
     
    228228  /// This map is essentially a wrapper for \c std::vector. It assigns
    229229  /// values to integer keys from the range <tt>[0..size-1]</tt>.
    230230  /// It can be used with some data structures, for example
    231   /// \ref UnionFind, \ref BinHeap, when the used items are small
     231  /// \c UnionFind, \c BinHeap, when the used items are small
    232232  /// integers. This map conforms the \ref concepts::ReferenceMap
    233233  /// "ReferenceMap" concept.
    234234  ///
     
    268268    RangeMap(const std::vector<V1>& vector)
    269269      : _vector(vector.begin(), vector.end()) {}
    270270
    271     /// Constructs the map from another \ref RangeMap.
     271    /// Constructs the map from another \c RangeMap.
    272272    template <typename V1>
    273273    RangeMap(const RangeMap<V1> &c)
    274274      : _vector(c._vector.begin(), c._vector.end()) {}
     
    311311    }
    312312  };
    313313
    314   /// Returns a \ref RangeMap class
     314  /// Returns a \c RangeMap class
    315315
    316   /// This function just returns a \ref RangeMap class.
     316  /// This function just returns a \c RangeMap class.
    317317  /// \relates RangeMap
    318318  template<typename V>
    319319  inline RangeMap<V> rangeMap(int size = 0, const V &value = V()) {
    320320    return RangeMap<V>(size, value);
    321321  }
    322322
    323   /// \brief Returns a \ref RangeMap class created from an appropriate
     323  /// \brief Returns a \c RangeMap class created from an appropriate
    324324  /// \c std::vector
    325325
    326   /// This function just returns a \ref RangeMap class created from an
     326  /// This function just returns a \c RangeMap class created from an
    327327  /// appropriate \c std::vector.
    328328  /// \relates RangeMap
    329329  template<typename V>
     
    388388              const Value &value = Value())
    389389      : _map(map.begin(), map.end()), _value(value) {}
    390390
    391     /// \brief Constructs the map from another \ref SparseMap.
     391    /// \brief Constructs the map from another \c SparseMap.
    392392    template<typename V1, typename Comp1>
    393393    SparseMap(const SparseMap<Key, V1, Comp1> &c)
    394394      : _map(c._map.begin(), c._map.end()), _value(c._value) {}
     
    433433    }
    434434  };
    435435
    436   /// Returns a \ref SparseMap class
     436  /// Returns a \c SparseMap class
    437437
    438   /// This function just returns a \ref SparseMap class with specified
     438  /// This function just returns a \c SparseMap class with specified
    439439  /// default value.
    440440  /// \relates SparseMap
    441441  template<typename K, typename V, typename Compare>
     
    448448    return SparseMap<K, V, std::less<K> >(value);
    449449  }
    450450
    451   /// \brief Returns a \ref SparseMap class created from an appropriate
     451  /// \brief Returns a \c SparseMap class created from an appropriate
    452452  /// \c std::map
    453453
    454   /// This function just returns a \ref SparseMap class created from an
     454  /// This function just returns a \c SparseMap class created from an
    455455  /// appropriate \c std::map.
    456456  /// \relates SparseMap
    457457  template<typename K, typename V, typename Compare>
     
    501501    operator[](const Key &k) const { return _m1[_m2[k]]; }
    502502  };
    503503
    504   /// Returns a \ref ComposeMap class
     504  /// Returns a \c ComposeMap class
    505505
    506   /// This function just returns a \ref ComposeMap class.
     506  /// This function just returns a \c ComposeMap class.
    507507  ///
    508508  /// If \c m1 and \c m2 are maps and the \c Value type of \c m2 is
    509509  /// convertible to the \c Key of \c m1, then <tt>composeMap(m1,m2)[x]</tt>
     
    556556    Value operator[](const Key &k) const { return _f(_m1[k],_m2[k]); }
    557557  };
    558558
    559   /// Returns a \ref CombineMap class
     559  /// Returns a \c CombineMap class
    560560
    561   /// This function just returns a \ref CombineMap class.
     561  /// This function just returns a \c CombineMap class.
    562562  ///
    563563  /// For example, if \c m1 and \c m2 are both maps with \c double
    564564  /// values, then
     
    625625    Value operator[](const Key &k) const { return _f(k); }
    626626  };
    627627
    628   /// Returns a \ref FunctorToMap class
     628  /// Returns a \c FunctorToMap class
    629629
    630   /// This function just returns a \ref FunctorToMap class.
     630  /// This function just returns a \c FunctorToMap class.
    631631  ///
    632632  /// This function is specialized for adaptable binary function
    633633  /// classes and C++ functions.
     
    684684    Value operator[](const Key &k) const { return _m[k]; }
    685685  };
    686686
    687   /// Returns a \ref MapToFunctor class
     687  /// Returns a \c MapToFunctor class
    688688
    689   /// This function just returns a \ref MapToFunctor class.
     689  /// This function just returns a \c MapToFunctor class.
    690690  /// \relates MapToFunctor
    691691  template<typename M>
    692692  inline MapToFunctor<M> mapToFunctor(const M &m) {
     
    723723    Value operator[](const Key &k) const { return _m[k]; }
    724724  };
    725725
    726   /// Returns a \ref ConvertMap class
     726  /// Returns a \c ConvertMap class
    727727
    728   /// This function just returns a \ref ConvertMap class.
     728  /// This function just returns a \c ConvertMap class.
    729729  /// \relates ConvertMap
    730730  template<typename V, typename M>
    731731  inline ConvertMap<M, V> convertMap(const M &map) {
     
    763763    void set(const Key &k, const Value &v) { _m1.set(k,v); _m2.set(k,v); }
    764764  };
    765765
    766   /// Returns a \ref ForkMap class
     766  /// Returns a \c ForkMap class
    767767
    768   /// This function just returns a \ref ForkMap class.
     768  /// This function just returns a \c ForkMap class.
    769769  /// \relates ForkMap
    770770  template <typename M1, typename M2>
    771771  inline ForkMap<M1,M2> forkMap(M1 &m1, M2 &m2) {
     
    807807    Value operator[](const Key &k) const { return _m1[k]+_m2[k]; }
    808808  };
    809809
    810   /// Returns an \ref AddMap class
     810  /// Returns an \c AddMap class
    811811
    812   /// This function just returns an \ref AddMap class.
     812  /// This function just returns an \c AddMap class.
    813813  ///
    814814  /// For example, if \c m1 and \c m2 are both maps with \c double
    815815  /// values, then <tt>addMap(m1,m2)[x]</tt> will be equal to
     
    855855    Value operator[](const Key &k) const { return _m1[k]-_m2[k]; }
    856856  };
    857857
    858   /// Returns a \ref SubMap class
     858  /// Returns a \c SubMap class
    859859
    860   /// This function just returns a \ref SubMap class.
     860  /// This function just returns a \c SubMap class.
    861861  ///
    862862  /// For example, if \c m1 and \c m2 are both maps with \c double
    863863  /// values, then <tt>subMap(m1,m2)[x]</tt> will be equal to
     
    904904    Value operator[](const Key &k) const { return _m1[k]*_m2[k]; }
    905905  };
    906906
    907   /// Returns a \ref MulMap class
     907  /// Returns a \c MulMap class
    908908
    909   /// This function just returns a \ref MulMap class.
     909  /// This function just returns a \c MulMap class.
    910910  ///
    911911  /// For example, if \c m1 and \c m2 are both maps with \c double
    912912  /// values, then <tt>mulMap(m1,m2)[x]</tt> will be equal to
     
    952952    Value operator[](const Key &k) const { return _m1[k]/_m2[k]; }
    953953  };
    954954
    955   /// Returns a \ref DivMap class
     955  /// Returns a \c DivMap class
    956956
    957   /// This function just returns a \ref DivMap class.
     957  /// This function just returns a \c DivMap class.
    958958  ///
    959959  /// For example, if \c m1 and \c m2 are both maps with \c double
    960960  /// values, then <tt>divMap(m1,m2)[x]</tt> will be equal to
     
    10381038    void set(const Key &k, const Value &v) { _m.set(k, v-_v); }
    10391039  };
    10401040
    1041   /// Returns a \ref ShiftMap class
     1041  /// Returns a \c ShiftMap class
    10421042
    1043   /// This function just returns a \ref ShiftMap class.
     1043  /// This function just returns a \c ShiftMap class.
    10441044  ///
    10451045  /// For example, if \c m is a map with \c double values and \c v is
    10461046  /// \c double, then <tt>shiftMap(m,v)[x]</tt> will be equal to
     
    10521052    return ShiftMap<M, C>(m,v);
    10531053  }
    10541054
    1055   /// Returns a \ref ShiftWriteMap class
     1055  /// Returns a \c ShiftWriteMap class
    10561056
    1057   /// This function just returns a \ref ShiftWriteMap class.
     1057  /// This function just returns a \c ShiftWriteMap class.
    10581058  ///
    10591059  /// For example, if \c m is a map with \c double values and \c v is
    10601060  /// \c double, then <tt>shiftWriteMap(m,v)[x]</tt> will be equal to
     
    11401140    void set(const Key &k, const Value &v) { _m.set(k, v/_v); }
    11411141  };
    11421142
    1143   /// Returns a \ref ScaleMap class
     1143  /// Returns a \c ScaleMap class
    11441144
    1145   /// This function just returns a \ref ScaleMap class.
     1145  /// This function just returns a \c ScaleMap class.
    11461146  ///
    11471147  /// For example, if \c m is a map with \c double values and \c v is
    11481148  /// \c double, then <tt>scaleMap(m,v)[x]</tt> will be equal to
     
    11541154    return ScaleMap<M, C>(m,v);
    11551155  }
    11561156
    1157   /// Returns a \ref ScaleWriteMap class
     1157  /// Returns a \c ScaleWriteMap class
    11581158
    1159   /// This function just returns a \ref ScaleWriteMap class.
     1159  /// This function just returns a \c ScaleWriteMap class.
    11601160  ///
    11611161  /// For example, if \c m is a map with \c double values and \c v is
    11621162  /// \c double, then <tt>scaleWriteMap(m,v)[x]</tt> will be equal to
     
    12401240    void set(const Key &k, const Value &v) { _m.set(k, -v); }
    12411241  };
    12421242
    1243   /// Returns a \ref NegMap class
     1243  /// Returns a \c NegMap class
    12441244
    1245   /// This function just returns a \ref NegMap class.
     1245  /// This function just returns a \c NegMap class.
    12461246  ///
    12471247  /// For example, if \c m is a map with \c double values, then
    12481248  /// <tt>negMap(m)[x]</tt> will be equal to <tt>-m[x]</tt>.
     
    12531253    return NegMap<M>(m);
    12541254  }
    12551255
    1256   /// Returns a \ref NegWriteMap class
     1256  /// Returns a \c NegWriteMap class
    12571257
    1258   /// This function just returns a \ref NegWriteMap class.
     1258  /// This function just returns a \c NegWriteMap class.
    12591259  ///
    12601260  /// For example, if \c m is a map with \c double values, then
    12611261  /// <tt>negWriteMap(m)[x]</tt> will be equal to <tt>-m[x]</tt>.
     
    12961296
    12971297  };
    12981298
    1299   /// Returns an \ref AbsMap class
     1299  /// Returns an \c AbsMap class
    13001300
    1301   /// This function just returns an \ref AbsMap class.
     1301  /// This function just returns an \c AbsMap class.
    13021302  ///
    13031303  /// For example, if \c m is a map with \c double values, then
    13041304  /// <tt>absMap(m)[x]</tt> will be equal to <tt>m[x]</tt> if
     
    13451345    Value operator[](const Key&) const { return true; }
    13461346  };
    13471347
    1348   /// Returns a \ref TrueMap class
     1348  /// Returns a \c TrueMap class
    13491349
    1350   /// This function just returns a \ref TrueMap class.
     1350  /// This function just returns a \c TrueMap class.
    13511351  /// \relates TrueMap
    13521352  template<typename K>
    13531353  inline TrueMap<K> trueMap() {
     
    13821382    Value operator[](const Key&) const { return false; }
    13831383  };
    13841384
    1385   /// Returns a \ref FalseMap class
     1385  /// Returns a \c FalseMap class
    13861386
    1387   /// This function just returns a \ref FalseMap class.
     1387  /// This function just returns a \c FalseMap class.
    13881388  /// \relates FalseMap
    13891389  template<typename K>
    13901390  inline FalseMap<K> falseMap() {
     
    14291429    Value operator[](const Key &k) const { return _m1[k]&&_m2[k]; }
    14301430  };
    14311431
    1432   /// Returns an \ref AndMap class
     1432  /// Returns an \c AndMap class
    14331433
    1434   /// This function just returns an \ref AndMap class.
     1434  /// This function just returns an \c AndMap class.
    14351435  ///
    14361436  /// For example, if \c m1 and \c m2 are both maps with \c bool values,
    14371437  /// then <tt>andMap(m1,m2)[x]</tt> will be equal to
     
    14771477    Value operator[](const Key &k) const { return _m1[k]||_m2[k]; }
    14781478  };
    14791479
    1480   /// Returns an \ref OrMap class
     1480  /// Returns an \c OrMap class
    14811481
    1482   /// This function just returns an \ref OrMap class.
     1482  /// This function just returns an \c OrMap class.
    14831483  ///
    14841484  /// For example, if \c m1 and \c m2 are both maps with \c bool values,
    14851485  /// then <tt>orMap(m1,m2)[x]</tt> will be equal to
     
    15441544    void set(const Key &k, bool v) { _m.set(k, !v); }
    15451545  };
    15461546
    1547   /// Returns a \ref NotMap class
     1547  /// Returns a \c NotMap class
    15481548
    1549   /// This function just returns a \ref NotMap class.
     1549  /// This function just returns a \c NotMap class.
    15501550  ///
    15511551  /// For example, if \c m is a map with \c bool values, then
    15521552  /// <tt>notMap(m)[x]</tt> will be equal to <tt>!m[x]</tt>.
     
    15571557    return NotMap<M>(m);
    15581558  }
    15591559
    1560   /// Returns a \ref NotWriteMap class
     1560  /// Returns a \c NotWriteMap class
    15611561
    1562   /// This function just returns a \ref NotWriteMap class.
     1562  /// This function just returns a \c NotWriteMap class.
    15631563  ///
    15641564  /// For example, if \c m is a map with \c bool values, then
    15651565  /// <tt>notWriteMap(m)[x]</tt> will be equal to <tt>!m[x]</tt>.
     
    16051605    Value operator[](const Key &k) const { return _m1[k]==_m2[k]; }
    16061606  };
    16071607
    1608   /// Returns an \ref EqualMap class
     1608  /// Returns an \c EqualMap class
    16091609
    1610   /// This function just returns an \ref EqualMap class.
     1610  /// This function just returns an \c EqualMap class.
    16111611  ///
    16121612  /// For example, if \c m1 and \c m2 are maps with keys and values of
    16131613  /// the same type, then <tt>equalMap(m1,m2)[x]</tt> will be equal to
     
    16531653    Value operator[](const Key &k) const { return _m1[k]<_m2[k]; }
    16541654  };
    16551655
    1656   /// Returns an \ref LessMap class
     1656  /// Returns an \c LessMap class
    16571657
    1658   /// This function just returns an \ref LessMap class.
     1658  /// This function just returns an \c LessMap class.
    16591659  ///
    16601660  /// For example, if \c m1 and \c m2 are maps with keys and values of
    16611661  /// the same type, then <tt>lessMap(m1,m2)[x]</tt> will be equal to
     
    17451745    Iterator _end;
    17461746  };
    17471747
    1748   /// Returns a \ref LoggerBoolMap class
     1748  /// Returns a \c LoggerBoolMap class
    17491749
    1750   /// This function just returns a \ref LoggerBoolMap class.
     1750  /// This function just returns a \c LoggerBoolMap class.
    17511751  ///
    17521752  /// The most important usage of it is storing certain nodes or arcs
    17531753  /// that were marked \c true by an algorithm.
     
    17671767  ///
    17681768  /// \note LoggerBoolMap is just \ref concepts::WriteMap "writable", so
    17691769  /// it cannot be used when a readable map is needed, for example as
    1770   /// \c ReachedMap for \ref Bfs, \ref Dfs and \ref Dijkstra algorithms.
     1770  /// \c ReachedMap for \c Bfs, \c Dfs and \c Dijkstra algorithms.
    17711771  ///
    17721772  /// \relates LoggerBoolMap
    17731773  template<typename Iterator>
     
    22822282    const Digraph& _digraph;
    22832283  };
    22842284
    2285   /// \brief Returns a \ref SourceMap class.
     2285  /// \brief Returns a \c SourceMap class.
    22862286  ///
    2287   /// This function just returns an \ref SourceMap class.
     2287  /// This function just returns an \c SourceMap class.
    22882288  /// \relates SourceMap
    22892289  template <typename Digraph>
    22902290  inline SourceMap<Digraph> sourceMap(const Digraph& digraph) {
     
    23212321    const Digraph& _digraph;
    23222322  };
    23232323
    2324   /// \brief Returns a \ref TargetMap class.
     2324  /// \brief Returns a \c TargetMap class.
    23252325  ///
    2326   /// This function just returns a \ref TargetMap class.
     2326  /// This function just returns a \c TargetMap class.
    23272327  /// \relates TargetMap
    23282328  template <typename Digraph>
    23292329  inline TargetMap<Digraph> targetMap(const Digraph& digraph) {
     
    23602360    const Graph& _graph;
    23612361  };
    23622362
    2363   /// \brief Returns a \ref ForwardMap class.
     2363  /// \brief Returns a \c ForwardMap class.
    23642364  ///
    2365   /// This function just returns an \ref ForwardMap class.
     2365  /// This function just returns an \c ForwardMap class.
    23662366  /// \relates ForwardMap
    23672367  template <typename Graph>
    23682368  inline ForwardMap<Graph> forwardMap(const Graph& graph) {
     
    23992399    const Graph& _graph;
    24002400  };
    24012401
    2402   /// \brief Returns a \ref BackwardMap class
     2402  /// \brief Returns a \c BackwardMap class
    24032403
    2404   /// This function just returns a \ref BackwardMap class.
     2404  /// This function just returns a \c BackwardMap class.
    24052405  /// \relates BackwardMap
    24062406  template <typename Graph>
    24072407  inline BackwardMap<Graph> backwardMap(const Graph& graph) {