9db8964f0cf6.patch on Ticket #119 – Attachment – LEMON

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
     ///arcs of the shortest paths.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a \ref PredMap.
+    ///Instantiates a PredMap.
     ///This function instantiates a \ref PredMap.
+    ///This function instantiates a PredMap.
     ///\param g is the digraph, to which we would like to define the
     ///\ref PredMap.
+    ///PredMap.
     static PredMap *createPredMap(const Digraph &g)
+    {
       return new PredMap(g);
 …
     ///The type of the map that indicates which nodes are processed.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a \ref ProcessedMap.
+    ///Instantiates a ProcessedMap.
     ///This function instantiates a \ref ProcessedMap.
+    ///This function instantiates a ProcessedMap.
     ///\param g is the digraph, to which
     ///we would like to define the \ref ProcessedMap
+    ///we would like to define the ProcessedMap
 #ifdef DOXYGEN
     static ProcessedMap *createProcessedMap(const Digraph &g)
 #else
 …
     ///The type of the map that indicates which nodes are reached.
     ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a \ref ReachedMap.
+    ///Instantiates a ReachedMap.
     ///This function instantiates a \ref ReachedMap.
+    ///This function instantiates a ReachedMap.
     ///\param g is the digraph, to which
     ///we would like to define the \ref ReachedMap.
+    ///we would like to define the ReachedMap.
     static ReachedMap *createReachedMap(const Digraph &g)
+    {
       return new ReachedMap(g);
 …
     ///The type of the map that stores the distances of the nodes.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<int> DistMap;
     ///Instantiates a \ref DistMap.
+    ///Instantiates a DistMap.
     ///This function instantiates a \ref DistMap.
+    ///This function instantiates a DistMap.
     ///\param g is the digraph, to which we would like to define the
     ///\ref DistMap.
+    ///DistMap.
     static DistMap *createDistMap(const Digraph &g)
+    {
       return new DistMap(g);
 …
+      }
     };
     ///\brief \ref named-templ-param "Named parameter" for setting
     ///\ref PredMap type.
+    ///PredMap type.
     ///
     ///\ref named-templ-param "Named parameter" for setting
     ///\ref PredMap type.
+    ///PredMap type.
     template <class T>
     struct SetPredMap : public Bfs< Digraph, SetPredMapTraits<T> > {
       typedef Bfs< Digraph, SetPredMapTraits<T> > Create;
 …
+      }
     };
     ///\brief \ref named-templ-param "Named parameter" for setting
     ///\ref DistMap type.
+    ///DistMap type.
     ///
     ///\ref named-templ-param "Named parameter" for setting
     ///\ref DistMap type.
+    ///DistMap type.
     template <class T>
     struct SetDistMap : public Bfs< Digraph, SetDistMapTraits<T> > {
       typedef Bfs< Digraph, SetDistMapTraits<T> > Create;
 …
+      }
     };
     ///\brief \ref named-templ-param "Named parameter" for setting
     ///\ref ReachedMap type.
+    ///ReachedMap type.
     ///
     ///\ref named-templ-param "Named parameter" for setting
     ///\ref ReachedMap type.
+    ///ReachedMap type.
     template <class T>
     struct SetReachedMap : public Bfs< Digraph, SetReachedMapTraits<T> > {
       typedef Bfs< Digraph, SetReachedMapTraits<T> > Create;
 …
+      }
     };
     ///\brief \ref named-templ-param "Named parameter" for setting
     ///\ref ProcessedMap type.
+    ///ProcessedMap type.
     ///
     ///\ref named-templ-param "Named parameter" for setting
     ///\ref ProcessedMap type.
+    ///ProcessedMap type.
     template <class T>
     struct SetProcessedMap : public Bfs< Digraph, SetProcessedMapTraits<T> > {
       typedef Bfs< Digraph, SetProcessedMapTraits<T> > Create;
 …
+      }
     };
     ///\brief \ref named-templ-param "Named parameter" for setting
     ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
+    ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     ///
     ///\ref named-templ-param "Named parameter" for setting
     ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
+    ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     ///If you don't set it explicitly, it will be automatically allocated.
     struct SetStandardProcessedMap :
       public Bfs< Digraph, SetStandardProcessedMapTraits > {
 …
     ///arcs of the shortest paths.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a \ref PredMap.
+    ///Instantiates a PredMap.
     ///This function instantiates a \ref PredMap.
+    ///This function instantiates a PredMap.
     ///\param g is the digraph, to which we would like to define the
     ///\ref PredMap.
+    ///PredMap.
     static PredMap *createPredMap(const Digraph &g)
+    {
       return new PredMap(g);
 …
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///By default it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a \ref ProcessedMap.
+    ///Instantiates a ProcessedMap.
     ///This function instantiates a \ref ProcessedMap.
+    ///This function instantiates a ProcessedMap.
     ///\param g is the digraph, to which
     ///we would like to define the \ref ProcessedMap.
+    ///we would like to define the ProcessedMap.
 #ifdef DOXYGEN
     static ProcessedMap *createProcessedMap(const Digraph &g)
 #else
 …
     ///The type of the map that indicates which nodes are reached.
     ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a \ref ReachedMap.
+    ///Instantiates a ReachedMap.
     ///This function instantiates a \ref ReachedMap.
+    ///This function instantiates a ReachedMap.
     ///\param g is the digraph, to which
     ///we would like to define the \ref ReachedMap.
+    ///we would like to define the ReachedMap.
     static ReachedMap *createReachedMap(const Digraph &g)
+    {
       return new ReachedMap(g);
 …
     ///The type of the map that stores the distances of the nodes.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<int> DistMap;
     ///Instantiates a \ref DistMap.
+    ///Instantiates a DistMap.
     ///This function instantiates a \ref DistMap.
+    ///This function instantiates a DistMap.
     ///\param g is the digraph, to which we would like to define
     ///the \ref DistMap
+    ///the DistMap
     static DistMap *createDistMap(const Digraph &g)
+    {
       return new DistMap(g);
 …
     typedef lemon::Path<Digraph> Path;
   };
   /// Default traits class used by \ref BfsWizard
+  /// Default traits class used by BfsWizard
   /// To make it easier to use Bfs algorithm
   /// we have created a wizard class.
 …
       SetPredMapBase(const TR &b) : TR(b) {}
     };
     ///\brief \ref named-func-param "Named parameter"
     ///for setting \ref PredMap object.
+    ///for setting PredMap object.
     ///
     ///\ref named-func-param "Named parameter"
     ///for setting \ref PredMap object.
+    ///for setting PredMap object.
     template<class T>
     BfsWizard<SetPredMapBase<T> > predMap(const T &t)
+    {
 …
       SetReachedMapBase(const TR &b) : TR(b) {}
     };
     ///\brief \ref named-func-param "Named parameter"
     ///for setting \ref ReachedMap object.
+    ///for setting ReachedMap object.
     ///
     /// \ref named-func-param "Named parameter"
     ///for setting \ref ReachedMap object.
+    ///for setting ReachedMap object.
     template<class T>
     BfsWizard<SetReachedMapBase<T> > reachedMap(const T &t)
+    {
 …
       SetDistMapBase(const TR &b) : TR(b) {}
     };
     ///\brief \ref named-func-param "Named parameter"
     ///for setting \ref DistMap object.
+    ///for setting DistMap object.
     ///
     /// \ref named-func-param "Named parameter"
     ///for setting \ref DistMap object.
+    ///for setting DistMap object.
     template<class T>
     BfsWizard<SetDistMapBase<T> > distMap(const T &t)
+    {
 …
       SetProcessedMapBase(const TR &b) : TR(b) {}
     };
     ///\brief \ref named-func-param "Named parameter"
     ///for setting \ref ProcessedMap object.
+    ///for setting ProcessedMap object.
     ///
     /// \ref named-func-param "Named parameter"
     ///for setting \ref ProcessedMap object.
+    ///for setting ProcessedMap object.
     template<class T>
     BfsWizard<SetProcessedMapBase<T> > processedMap(const T &t)
+    {
 …
     /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     /// \brief Instantiates a \ref ReachedMap.
+    /// \brief Instantiates a ReachedMap.
     ///
     /// This function instantiates a \ref ReachedMap.
+    /// This function instantiates a ReachedMap.
     /// \param digraph is the digraph, to which
     /// we would like to define the \ref ReachedMap.
+    /// we would like to define the ReachedMap.
     static ReachedMap *createReachedMap(const Digraph &digraph) {
       return new ReachedMap(digraph);
+    }

lemon/dfs.h

diff --git a/lemon/dfs.h b/lemon/dfs.h

-                      a
     ///arcs of the %DFS paths.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a \ref PredMap.
+    ///Instantiates a PredMap.
     ///This function instantiates a \ref PredMap.
+    ///This function instantiates a PredMap.
     ///\param g is the digraph, to which we would like to define the
     ///\ref PredMap.
+    ///PredMap.
     static PredMap *createPredMap(const Digraph &g)
+    {
       return new PredMap(g);
 …
     ///The type of the map that indicates which nodes are processed.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a \ref ProcessedMap.
+    ///Instantiates a ProcessedMap.
     ///This function instantiates a \ref ProcessedMap.
+    ///This function instantiates a ProcessedMap.
     ///\param g is the digraph, to which
     ///we would like to define the \ref ProcessedMap
+    ///we would like to define the ProcessedMap
 #ifdef DOXYGEN
     static ProcessedMap *createProcessedMap(const Digraph &g)
 #else
 …
     ///The type of the map that indicates which nodes are reached.
     ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a \ref ReachedMap.
+    ///Instantiates a ReachedMap.
     ///This function instantiates a \ref ReachedMap.
+    ///This function instantiates a ReachedMap.
     ///\param g is the digraph, to which
     ///we would like to define the \ref ReachedMap.
+    ///we would like to define the ReachedMap.
     static ReachedMap *createReachedMap(const Digraph &g)
+    {
       return new ReachedMap(g);
 …
     ///The type of the map that stores the distances of the nodes.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<int> DistMap;
     ///Instantiates a \ref DistMap.
+    ///Instantiates a DistMap.
     ///This function instantiates a \ref DistMap.
+    ///This function instantiates a DistMap.
     ///\param g is the digraph, to which we would like to define the
     ///\ref DistMap.
+    ///DistMap.
     static DistMap *createDistMap(const Digraph &g)
+    {
       return new DistMap(g);
 …
+      }
     };
     ///\brief \ref named-templ-param "Named parameter" for setting
     ///\ref PredMap type.
+    ///PredMap type.
     ///
     ///\ref named-templ-param "Named parameter" for setting
     ///\ref PredMap type.
+    ///PredMap type.
     template <class T>
     struct SetPredMap : public Dfs<Digraph, SetPredMapTraits<T> > {
       typedef Dfs<Digraph, SetPredMapTraits<T> > Create;
 …
+      }
     };
     ///\brief \ref named-templ-param "Named parameter" for setting
     ///\ref DistMap type.
+    ///DistMap type.
     ///
     ///\ref named-templ-param "Named parameter" for setting
     ///\ref DistMap type.
+    ///DistMap type.
     template <class T>
     struct SetDistMap : public Dfs< Digraph, SetDistMapTraits<T> > {
       typedef Dfs<Digraph, SetDistMapTraits<T> > Create;
 …
+      }
     };
     ///\brief \ref named-templ-param "Named parameter" for setting
     ///\ref ReachedMap type.
+    ///ReachedMap type.
     ///
     ///\ref named-templ-param "Named parameter" for setting
     ///\ref ReachedMap type.
+    ///ReachedMap type.
     template <class T>
     struct SetReachedMap : public Dfs< Digraph, SetReachedMapTraits<T> > {
       typedef Dfs< Digraph, SetReachedMapTraits<T> > Create;
 …
+      }
     };
     ///\brief \ref named-templ-param "Named parameter" for setting
     ///\ref ProcessedMap type.
+    ///ProcessedMap type.
     ///
     ///\ref named-templ-param "Named parameter" for setting
     ///\ref ProcessedMap type.
+    ///ProcessedMap type.
     template <class T>
     struct SetProcessedMap : public Dfs< Digraph, SetProcessedMapTraits<T> > {
       typedef Dfs< Digraph, SetProcessedMapTraits<T> > Create;
 …
+      }
     };
     ///\brief \ref named-templ-param "Named parameter" for setting
     ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
+    ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     ///
     ///\ref named-templ-param "Named parameter" for setting
     ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
+    ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     ///If you don't set it explicitly, it will be automatically allocated.
     struct SetStandardProcessedMap :
       public Dfs< Digraph, SetStandardProcessedMapTraits > {
 …
     ///arcs of the %DFS paths.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a \ref PredMap.
+    ///Instantiates a PredMap.
     ///This function instantiates a \ref PredMap.
+    ///This function instantiates a PredMap.
     ///\param g is the digraph, to which we would like to define the
     ///\ref PredMap.
+    ///PredMap.
     static PredMap *createPredMap(const Digraph &g)
+    {
       return new PredMap(g);
 …
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///By default it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a \ref ProcessedMap.
+    ///Instantiates a ProcessedMap.
     ///This function instantiates a \ref ProcessedMap.
+    ///This function instantiates a ProcessedMap.
     ///\param g is the digraph, to which
     ///we would like to define the \ref ProcessedMap.
+    ///we would like to define the ProcessedMap.
 #ifdef DOXYGEN
     static ProcessedMap *createProcessedMap(const Digraph &g)
 #else
 …
     ///The type of the map that indicates which nodes are reached.
     ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a \ref ReachedMap.
+    ///Instantiates a ReachedMap.
     ///This function instantiates a \ref ReachedMap.
+    ///This function instantiates a ReachedMap.
     ///\param g is the digraph, to which
     ///we would like to define the \ref ReachedMap.
+    ///we would like to define the ReachedMap.
     static ReachedMap *createReachedMap(const Digraph &g)
+    {
       return new ReachedMap(g);
 …
     ///The type of the map that stores the distances of the nodes.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<int> DistMap;
     ///Instantiates a \ref DistMap.
+    ///Instantiates a DistMap.
     ///This function instantiates a \ref DistMap.
+    ///This function instantiates a DistMap.
     ///\param g is the digraph, to which we would like to define
     ///the \ref DistMap
+    ///the DistMap
     static DistMap *createDistMap(const Digraph &g)
+    {
       return new DistMap(g);
 …
       SetPredMapBase(const TR &b) : TR(b) {}
     };
     ///\brief \ref named-func-param "Named parameter"
     ///for setting \ref PredMap object.
+    ///for setting PredMap object.
     ///
     ///\ref named-func-param "Named parameter"
     ///for setting \ref PredMap object.
+    ///for setting PredMap object.
     template<class T>
     DfsWizard<SetPredMapBase<T> > predMap(const T &t)
+    {
 …
       SetReachedMapBase(const TR &b) : TR(b) {}
     };
     ///\brief \ref named-func-param "Named parameter"
     ///for setting \ref ReachedMap object.
+    ///for setting ReachedMap object.
     ///
     /// \ref named-func-param "Named parameter"
     ///for setting \ref ReachedMap object.
+    ///for setting ReachedMap object.
     template<class T>
     DfsWizard<SetReachedMapBase<T> > reachedMap(const T &t)
+    {
 …
       SetDistMapBase(const TR &b) : TR(b) {}
     };
     ///\brief \ref named-func-param "Named parameter"
     ///for setting \ref DistMap object.
+    ///for setting DistMap object.
     ///
     /// \ref named-func-param "Named parameter"
     ///for setting \ref DistMap object.
+    ///for setting DistMap object.
     template<class T>
     DfsWizard<SetDistMapBase<T> > distMap(const T &t)
+    {
 …
       SetProcessedMapBase(const TR &b) : TR(b) {}
     };
     ///\brief \ref named-func-param "Named parameter"
     ///for setting \ref ProcessedMap object.
+    ///for setting ProcessedMap object.
     ///
     /// \ref named-func-param "Named parameter"
     ///for setting \ref ProcessedMap object.
+    ///for setting ProcessedMap object.
     template<class T>
     DfsWizard<SetProcessedMapBase<T> > processedMap(const T &t)
+    {
 …
     /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     /// \brief Instantiates a \ref ReachedMap.
+    /// \brief Instantiates a ReachedMap.
     ///
     /// This function instantiates a \ref ReachedMap.
+    /// This function instantiates a ReachedMap.
     /// \param digraph is the digraph, to which
     /// we would like to define the \ref ReachedMap.
+    /// we would like to define the ReachedMap.
     static ReachedMap *createReachedMap(const Digraph &digraph) {
       return new ReachedMap(digraph);
+    }

lemon/dijkstra.h

diff --git a/lemon/dijkstra.h b/lemon/dijkstra.h

-                      a
     ///arcs of the shortest paths.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a \ref PredMap.
+    ///Instantiates a PredMap.
     ///This function instantiates a \ref PredMap.
+    ///This function instantiates a PredMap.
     ///\param g is the digraph, to which we would like to define the
     ///\ref PredMap.
+    ///PredMap.
     static PredMap *createPredMap(const Digraph &g)
+    {
       return new PredMap(g);
 …
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///By default it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a \ref ProcessedMap.
+    ///Instantiates a ProcessedMap.
     ///This function instantiates a \ref ProcessedMap.
+    ///This function instantiates a ProcessedMap.
     ///\param g is the digraph, to which
     ///we would like to define the \ref ProcessedMap
+    ///we would like to define the ProcessedMap
 #ifdef DOXYGEN
     static ProcessedMap *createProcessedMap(const Digraph &g)
 #else
 …
     ///The type of the map that stores the distances of the nodes.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename LM::Value> DistMap;
     ///Instantiates a \ref DistMap.
+    ///Instantiates a DistMap.
     ///This function instantiates a \ref DistMap.
+    ///This function instantiates a DistMap.
     ///\param g is the digraph, to which we would like to define
     ///the \ref DistMap
+    ///the DistMap
     static DistMap *createDistMap(const Digraph &g)
+    {
       return new DistMap(g);
 …
+      }
     };
     ///\brief \ref named-templ-param "Named parameter" for setting
     ///\ref PredMap type.
+    ///PredMap type.
     ///
     ///\ref named-templ-param "Named parameter" for setting
     ///\ref PredMap type.
+    ///PredMap type.
     template <class T>
     struct SetPredMap
       : public Dijkstra< Digraph, LengthMap, SetPredMapTraits<T> > {
 …
+      }
     };
     ///\brief \ref named-templ-param "Named parameter" for setting
     ///\ref DistMap type.
+    ///DistMap type.
     ///
     ///\ref named-templ-param "Named parameter" for setting
     ///\ref DistMap type.
+    ///DistMap type.
     template <class T>
     struct SetDistMap
       : public Dijkstra< Digraph, LengthMap, SetDistMapTraits<T> > {
 …
+      }
     };
     ///\brief \ref named-templ-param "Named parameter" for setting
     ///\ref ProcessedMap type.
+    ///ProcessedMap type.
     ///
     ///\ref named-templ-param "Named parameter" for setting
     ///\ref ProcessedMap type.
+    ///ProcessedMap type.
     template <class T>
     struct SetProcessedMap
       : public Dijkstra< Digraph, LengthMap, SetProcessedMapTraits<T> > {
 …
+      }
     };
     ///\brief \ref named-templ-param "Named parameter" for setting
     ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
+    ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     ///
     ///\ref named-templ-param "Named parameter" for setting
     ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
+    ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     ///If you don't set it explicitly, it will be automatically allocated.
     struct SetStandardProcessedMap
       : public Dijkstra< Digraph, LengthMap, SetStandardProcessedMapTraits > {
 …
     ///arcs of the shortest paths.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a \ref PredMap.
+    ///Instantiates a PredMap.
     ///This function instantiates a \ref PredMap.
+    ///This function instantiates a PredMap.
     ///\param g is the digraph, to which we would like to define the
     ///\ref PredMap.
+    ///PredMap.
     static PredMap *createPredMap(const Digraph &g)
+    {
       return new PredMap(g);
 …
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///By default it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a \ref ProcessedMap.
+    ///Instantiates a ProcessedMap.
     ///This function instantiates a \ref ProcessedMap.
+    ///This function instantiates a ProcessedMap.
     ///\param g is the digraph, to which
     ///we would like to define the \ref ProcessedMap.
+    ///we would like to define the ProcessedMap.
 #ifdef DOXYGEN
     static ProcessedMap *createProcessedMap(const Digraph &g)
 #else
 …
     ///The type of the map that stores the distances of the nodes.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename LM::Value> DistMap;
     ///Instantiates a \ref DistMap.
+    ///Instantiates a DistMap.
     ///This function instantiates a \ref DistMap.
+    ///This function instantiates a DistMap.
     ///\param g is the digraph, to which we would like to define
     ///the \ref DistMap
+    ///the DistMap
     static DistMap *createDistMap(const Digraph &g)
+    {
       return new DistMap(g);
 …
       SetPredMapBase(const TR &b) : TR(b) {}
     };
     ///\brief \ref named-func-param "Named parameter"
     ///for setting \ref PredMap object.
+    ///for setting PredMap object.
     ///
     ///\ref named-func-param "Named parameter"
     ///for setting \ref PredMap object.
+    ///for setting PredMap object.
     template<class T>
     DijkstraWizard<SetPredMapBase<T> > predMap(const T &t)
+    {
 …
       SetDistMapBase(const TR &b) : TR(b) {}
     };
     ///\brief \ref named-func-param "Named parameter"
     ///for setting \ref DistMap object.
+    ///for setting DistMap object.
     ///
     ///\ref named-func-param "Named parameter"
     ///for setting \ref DistMap object.
+    ///for setting DistMap object.
     template<class T>
     DijkstraWizard<SetDistMapBase<T> > distMap(const T &t)
+    {
 …
       SetProcessedMapBase(const TR &b) : TR(b) {}
     };
     ///\brief \ref named-func-param "Named parameter"
     ///for setting \ref ProcessedMap object.
+    ///for setting ProcessedMap object.
     ///
     /// \ref named-func-param "Named parameter"
     ///for setting \ref ProcessedMap object.
+    ///for setting ProcessedMap object.
     template<class T>
     DijkstraWizard<SetProcessedMapBase<T> > processedMap(const T &t)
+    {

lemon/maps.h

diff --git a/lemon/maps.h b/lemon/maps.h

-                      a
     void set(const Key&, const Value&) {}
   };
   /// Returns a \ref NullMap class
+  /// Returns a \c NullMap class
   /// This function just returns a \ref NullMap class.
+  /// This function just returns a \c NullMap class.
   /// \relates NullMap
   template <typename K, typename V>
   NullMap<K, V> nullMap() {
 …
   /// This \ref concepts::ReadMap "readable map" assigns a specified
   /// value to each key.
   ///
   /// In other aspects it is equivalent to \ref NullMap.
+  /// In other aspects it is equivalent to \c NullMap.
   /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap"
   /// concept, but it absorbs the data written to it.
   ///
 …
     ConstMap(const ConstMap<K, V1> &, const Value &v) : _value(v) {}
   };
   /// Returns a \ref ConstMap class
+  /// Returns a \c ConstMap class
   /// This function just returns a \ref ConstMap class.
+  /// This function just returns a \c ConstMap class.
   /// \relates ConstMap
   template<typename K, typename V>
   inline ConstMap<K, V> constMap(const V &v) {
 …
   /// This \ref concepts::ReadMap "readable map" assigns a specified
   /// value to each key.
   ///
   /// In other aspects it is equivalent to \ref NullMap.
+  /// In other aspects it is equivalent to \c NullMap.
   /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap"
   /// concept, but it absorbs the data written to it.
   ///
 …
     void set(const Key&, const Value&) {}
   };
   /// Returns a \ref ConstMap class with inlined constant value
+  /// Returns a \c ConstMap class with inlined constant value
   /// This function just returns a \ref ConstMap class with inlined
+  /// This function just returns a \c ConstMap class with inlined
   /// constant value.
   /// \relates ConstMap
   template<typename K, typename V, V v>
 …
+    }
   };
   /// Returns an \ref IdentityMap class
+  /// Returns an \c IdentityMap class
   /// This function just returns an \ref IdentityMap class.
+  /// This function just returns an \c IdentityMap class.
   /// \relates IdentityMap
   template<typename T>
   inline IdentityMap<T> identityMap() {
 …
   /// This map is essentially a wrapper for \c std::vector. It assigns
   /// values to integer keys from the range <tt>[0..size-1]</tt>.
   /// It can be used with some data structures, for example
   /// \ref UnionFind, \ref BinHeap, when the used items are small
+  /// \c UnionFind, \c BinHeap, when the used items are small
   /// integers. This map conforms the \ref concepts::ReferenceMap
   /// "ReferenceMap" concept.
   ///
 …
     RangeMap(const std::vector<V1>& vector)
       : _vector(vector.begin(), vector.end()) {}
     /// Constructs the map from another \ref RangeMap.
+    /// Constructs the map from another \c RangeMap.
     template <typename V1>
     RangeMap(const RangeMap<V1> &c)
       : _vector(c._vector.begin(), c._vector.end()) {}
 …
+    }
   };
   /// Returns a \ref RangeMap class
+  /// Returns a \c RangeMap class
   /// This function just returns a \ref RangeMap class.
+  /// This function just returns a \c RangeMap class.
   /// \relates RangeMap
   template<typename V>
   inline RangeMap<V> rangeMap(int size = 0, const V &value = V()) {
     return RangeMap<V>(size, value);
+  }
   /// \brief Returns a \ref RangeMap class created from an appropriate
+  /// \brief Returns a \c RangeMap class created from an appropriate
   /// \c std::vector
   /// This function just returns a \ref RangeMap class created from an
+  /// This function just returns a \c RangeMap class created from an
   /// appropriate \c std::vector.
   /// \relates RangeMap
   template<typename V>
 …
               const Value &value = Value())
       : _map(map.begin(), map.end()), _value(value) {}
     /// \brief Constructs the map from another \ref SparseMap.
+    /// \brief Constructs the map from another \c SparseMap.
     template<typename V1, typename Comp1>
     SparseMap(const SparseMap<Key, V1, Comp1> &c)
       : _map(c._map.begin(), c._map.end()), _value(c._value) {}
 …
+    }
   };
   /// Returns a \ref SparseMap class
+  /// Returns a \c SparseMap class
   /// This function just returns a \ref SparseMap class with specified
+  /// This function just returns a \c SparseMap class with specified
   /// default value.
   /// \relates SparseMap
   template<typename K, typename V, typename Compare>
 …
     return SparseMap<K, V, std::less<K> >(value);
+  }
   /// \brief Returns a \ref SparseMap class created from an appropriate
+  /// \brief Returns a \c SparseMap class created from an appropriate
   /// \c std::map
   /// This function just returns a \ref SparseMap class created from an
+  /// This function just returns a \c SparseMap class created from an
   /// appropriate \c std::map.
   /// \relates SparseMap
   template<typename K, typename V, typename Compare>
 …
     operator[](const Key &k) const { return _m1[_m2[k]]; }
   };
   /// Returns a \ref ComposeMap class
+  /// Returns a \c ComposeMap class
   /// This function just returns a \ref ComposeMap class.
+  /// This function just returns a \c ComposeMap class.
   ///
   /// If \c m1 and \c m2 are maps and the \c Value type of \c m2 is
   /// convertible to the \c Key of \c m1, then <tt>composeMap(m1,m2)[x]</tt>
 …
     Value operator[](const Key &k) const { return _f(_m1[k],_m2[k]); }
   };
   /// Returns a \ref CombineMap class
+  /// Returns a \c CombineMap class
   /// This function just returns a \ref CombineMap class.
+  /// This function just returns a \c CombineMap class.
   ///
   /// For example, if \c m1 and \c m2 are both maps with \c double
   /// values, then
 …
     Value operator[](const Key &k) const { return _f(k); }
   };
   /// Returns a \ref FunctorToMap class
+  /// Returns a \c FunctorToMap class
   /// This function just returns a \ref FunctorToMap class.
+  /// This function just returns a \c FunctorToMap class.
   ///
   /// This function is specialized for adaptable binary function
   /// classes and C++ functions.
 …
     Value operator[](const Key &k) const { return _m[k]; }
   };
   /// Returns a \ref MapToFunctor class
+  /// Returns a \c MapToFunctor class
   /// This function just returns a \ref MapToFunctor class.
+  /// This function just returns a \c MapToFunctor class.
   /// \relates MapToFunctor
   template<typename M>
   inline MapToFunctor<M> mapToFunctor(const M &m) {
 …
     Value operator[](const Key &k) const { return _m[k]; }
   };
   /// Returns a \ref ConvertMap class
+  /// Returns a \c ConvertMap class
   /// This function just returns a \ref ConvertMap class.
+  /// This function just returns a \c ConvertMap class.
   /// \relates ConvertMap
   template<typename V, typename M>
   inline ConvertMap<M, V> convertMap(const M &map) {
 …
     void set(const Key &k, const Value &v) { _m1.set(k,v); _m2.set(k,v); }
   };
   /// Returns a \ref ForkMap class
+  /// Returns a \c ForkMap class
   /// This function just returns a \ref ForkMap class.
+  /// This function just returns a \c ForkMap class.
   /// \relates ForkMap
   template <typename M1, typename M2>
   inline ForkMap<M1,M2> forkMap(M1 &m1, M2 &m2) {
 …
     Value operator[](const Key &k) const { return _m1[k]+_m2[k]; }
   };
   /// Returns an \ref AddMap class
+  /// Returns an \c AddMap class
   /// This function just returns an \ref AddMap class.
+  /// This function just returns an \c AddMap class.
   ///
   /// For example, if \c m1 and \c m2 are both maps with \c double
   /// values, then <tt>addMap(m1,m2)[x]</tt> will be equal to
 …
     Value operator[](const Key &k) const { return _m1[k]-_m2[k]; }
   };
   /// Returns a \ref SubMap class
+  /// Returns a \c SubMap class
   /// This function just returns a \ref SubMap class.
+  /// This function just returns a \c SubMap class.
   ///
   /// For example, if \c m1 and \c m2 are both maps with \c double
   /// values, then <tt>subMap(m1,m2)[x]</tt> will be equal to
 …
     Value operator[](const Key &k) const { return _m1[k]*_m2[k]; }
   };
   /// Returns a \ref MulMap class
+  /// Returns a \c MulMap class
   /// This function just returns a \ref MulMap class.
+  /// This function just returns a \c MulMap class.
   ///
   /// For example, if \c m1 and \c m2 are both maps with \c double
   /// values, then <tt>mulMap(m1,m2)[x]</tt> will be equal to
 …
     Value operator[](const Key &k) const { return _m1[k]/_m2[k]; }
   };
   /// Returns a \ref DivMap class
+  /// Returns a \c DivMap class
   /// This function just returns a \ref DivMap class.
+  /// This function just returns a \c DivMap class.
   ///
   /// For example, if \c m1 and \c m2 are both maps with \c double
   /// values, then <tt>divMap(m1,m2)[x]</tt> will be equal to
 …
     void set(const Key &k, const Value &v) { _m.set(k, v-_v); }
   };
   /// Returns a \ref ShiftMap class
+  /// Returns a \c ShiftMap class
   /// This function just returns a \ref ShiftMap class.
+  /// This function just returns a \c ShiftMap class.
   ///
   /// For example, if \c m is a map with \c double values and \c v is
   /// \c double, then <tt>shiftMap(m,v)[x]</tt> will be equal to
 …
     return ShiftMap<M, C>(m,v);
+  }
   /// Returns a \ref ShiftWriteMap class
+  /// Returns a \c ShiftWriteMap class
   /// This function just returns a \ref ShiftWriteMap class.
+  /// This function just returns a \c ShiftWriteMap class.
   ///
   /// For example, if \c m is a map with \c double values and \c v is
   /// \c double, then <tt>shiftWriteMap(m,v)[x]</tt> will be equal to
 …
     void set(const Key &k, const Value &v) { _m.set(k, v/_v); }
   };
   /// Returns a \ref ScaleMap class
+  /// Returns a \c ScaleMap class
   /// This function just returns a \ref ScaleMap class.
+  /// This function just returns a \c ScaleMap class.
   ///
   /// For example, if \c m is a map with \c double values and \c v is
   /// \c double, then <tt>scaleMap(m,v)[x]</tt> will be equal to
 …
     return ScaleMap<M, C>(m,v);
+  }
   /// Returns a \ref ScaleWriteMap class
+  /// Returns a \c ScaleWriteMap class
   /// This function just returns a \ref ScaleWriteMap class.
+  /// This function just returns a \c ScaleWriteMap class.
   ///
   /// For example, if \c m is a map with \c double values and \c v is
   /// \c double, then <tt>scaleWriteMap(m,v)[x]</tt> will be equal to
 …
     void set(const Key &k, const Value &v) { _m.set(k, -v); }
   };
   /// Returns a \ref NegMap class
+  /// Returns a \c NegMap class
   /// This function just returns a \ref NegMap class.
+  /// This function just returns a \c NegMap class.
   ///
   /// For example, if \c m is a map with \c double values, then
   /// <tt>negMap(m)[x]</tt> will be equal to <tt>-m[x]</tt>.
 …
     return NegMap<M>(m);
+  }
   /// Returns a \ref NegWriteMap class
+  /// Returns a \c NegWriteMap class
   /// This function just returns a \ref NegWriteMap class.
+  /// This function just returns a \c NegWriteMap class.
   ///
   /// For example, if \c m is a map with \c double values, then
   /// <tt>negWriteMap(m)[x]</tt> will be equal to <tt>-m[x]</tt>.
 …
   };
   /// Returns an \ref AbsMap class
+  /// Returns an \c AbsMap class
   /// This function just returns an \ref AbsMap class.
+  /// This function just returns an \c AbsMap class.
   ///
   /// For example, if \c m is a map with \c double values, then
   /// <tt>absMap(m)[x]</tt> will be equal to <tt>m[x]</tt> if
 …
     Value operator[](const Key&) const { return true; }
   };
   /// Returns a \ref TrueMap class
+  /// Returns a \c TrueMap class
   /// This function just returns a \ref TrueMap class.
+  /// This function just returns a \c TrueMap class.
   /// \relates TrueMap
   template<typename K>
   inline TrueMap<K> trueMap() {
 …
     Value operator[](const Key&) const { return false; }
   };
   /// Returns a \ref FalseMap class
+  /// Returns a \c FalseMap class
   /// This function just returns a \ref FalseMap class.
+  /// This function just returns a \c FalseMap class.
   /// \relates FalseMap
   template<typename K>
   inline FalseMap<K> falseMap() {
 …
     Value operator[](const Key &k) const { return _m1[k]&&_m2[k]; }
   };
   /// Returns an \ref AndMap class
+  /// Returns an \c AndMap class
   /// This function just returns an \ref AndMap class.
+  /// This function just returns an \c AndMap class.
   ///
   /// For example, if \c m1 and \c m2 are both maps with \c bool values,
   /// then <tt>andMap(m1,m2)[x]</tt> will be equal to
 …
     Value operator[](const Key &k) const { return _m1[k]||_m2[k]; }
   };
   /// Returns an \ref OrMap class
+  /// Returns an \c OrMap class
   /// This function just returns an \ref OrMap class.
+  /// This function just returns an \c OrMap class.
   ///
   /// For example, if \c m1 and \c m2 are both maps with \c bool values,
   /// then <tt>orMap(m1,m2)[x]</tt> will be equal to
 …
     void set(const Key &k, bool v) { _m.set(k, !v); }
   };
   /// Returns a \ref NotMap class
+  /// Returns a \c NotMap class
   /// This function just returns a \ref NotMap class.
+  /// This function just returns a \c NotMap class.
   ///
   /// For example, if \c m is a map with \c bool values, then
   /// <tt>notMap(m)[x]</tt> will be equal to <tt>!m[x]</tt>.
 …
     return NotMap<M>(m);
+  }
   /// Returns a \ref NotWriteMap class
+  /// Returns a \c NotWriteMap class
   /// This function just returns a \ref NotWriteMap class.
+  /// This function just returns a \c NotWriteMap class.
   ///
   /// For example, if \c m is a map with \c bool values, then
   /// <tt>notWriteMap(m)[x]</tt> will be equal to <tt>!m[x]</tt>.
 …
     Value operator[](const Key &k) const { return _m1[k]==_m2[k]; }
   };
   /// Returns an \ref EqualMap class
+  /// Returns an \c EqualMap class
   /// This function just returns an \ref EqualMap class.
+  /// This function just returns an \c EqualMap class.
   ///
   /// For example, if \c m1 and \c m2 are maps with keys and values of
   /// the same type, then <tt>equalMap(m1,m2)[x]</tt> will be equal to
 …
     Value operator[](const Key &k) const { return _m1[k]<_m2[k]; }
   };
   /// Returns an \ref LessMap class
+  /// Returns an \c LessMap class
   /// This function just returns an \ref LessMap class.
+  /// This function just returns an \c LessMap class.
   ///
   /// For example, if \c m1 and \c m2 are maps with keys and values of
   /// the same type, then <tt>lessMap(m1,m2)[x]</tt> will be equal to
 …
     Iterator _end;
   };
   /// Returns a \ref LoggerBoolMap class
+  /// Returns a \c LoggerBoolMap class
   /// This function just returns a \ref LoggerBoolMap class.
+  /// This function just returns a \c LoggerBoolMap class.
   ///
   /// The most important usage of it is storing certain nodes or arcs
   /// that were marked \c true by an algorithm.
 …
   ///
   /// \note LoggerBoolMap is just \ref concepts::WriteMap "writable", so
   /// it cannot be used when a readable map is needed, for example as
   /// \c ReachedMap for \ref Bfs, \ref Dfs and \ref Dijkstra algorithms.
+  /// \c ReachedMap for \c Bfs, \c Dfs and \c Dijkstra algorithms.
   ///
   /// \relates LoggerBoolMap
   template<typename Iterator>
 …
     const Digraph& _digraph;
   };
   /// \brief Returns a \ref SourceMap class.
+  /// \brief Returns a \c SourceMap class.
   ///
   /// This function just returns an \ref SourceMap class.
+  /// This function just returns an \c SourceMap class.
   /// \relates SourceMap
   template <typename Digraph>
   inline SourceMap<Digraph> sourceMap(const Digraph& digraph) {
 …
     const Digraph& _digraph;
   };
   /// \brief Returns a \ref TargetMap class.
+  /// \brief Returns a \c TargetMap class.
   ///
   /// This function just returns a \ref TargetMap class.
+  /// This function just returns a \c TargetMap class.
   /// \relates TargetMap
   template <typename Digraph>
   inline TargetMap<Digraph> targetMap(const Digraph& digraph) {
 …
     const Graph& _graph;
   };
   /// \brief Returns a \ref ForwardMap class.
+  /// \brief Returns a \c ForwardMap class.
   ///
   /// This function just returns an \ref ForwardMap class.
+  /// This function just returns an \c ForwardMap class.
   /// \relates ForwardMap
   template <typename Graph>
   inline ForwardMap<Graph> forwardMap(const Graph& graph) {
 …
     const Graph& _graph;
   };
   /// \brief Returns a \ref BackwardMap class
+  /// \brief Returns a \c BackwardMap class
   /// This function just returns a \ref BackwardMap class.
+  /// This function just returns a \c BackwardMap class.
   /// \relates BackwardMap
   template <typename Graph>
   inline BackwardMap<Graph> backwardMap(const Graph& graph) {

Context Navigation

Ticket #119: 9db8964f0cf6.patch

lemon/bfs.h

lemon/dfs.h

lemon/dijkstra.h

lemon/maps.h

Download in other formats: