LEMON/LEMON-official Changeset - r301:9db8964f0cf6

Repositories » LEMON » LEMON-official

Summary
Changelog
Files
Switch To
- loading...
Options
- Lightweight changelog
- Search
Pull Requests

Changeset - r301:9db8964f0cf6

« 299:907446

302:187177 »

r301:9db8964f0cf6

Wed, 08 Oct 2008 13:40:20

[Not Reviewed]

0 comments (0 inline)

kpeter (Peter Kovacs)
kpeter@inf.elte.hu

Fix several doxygen warings

0 4 0

default

4 files changed with 238 insertions and 238 deletions:

lemon/bfs.h

lemon/dfs.h

lemon/dijkstra.h

lemon/maps.h

115

↑ Collapse diff ↑

lemon/bfs.h

Show inline comments

@@ -40,78 +40,78 @@
 		  struct BfsDefaultTraits
+		  {
 		    ///The type of the digraph the algorithm runs on.
 		    typedef GR Digraph;
 		    ///\brief The type of the map that stores the predecessor
 		    ///arcs of the shortest paths.
 		    ///
 		    ///The type of the map that stores the predecessor
 		    ///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.
 		    ///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
 		    static ProcessedMap *createProcessedMap(const Digraph &)
 		#endif
+		    {
 		      return new ProcessedMap();
+		    }
 		    ///The type of the map that indicates which nodes are reached.
 		    ///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.
 		    ///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);
+		    }
 		  };
 		  ///%BFS algorithm class.
 		  ///\ingroup search
 		  ///This class provides an efficient implementation of the %BFS algorithm.
 		  ///
 		  ///There is also a \ref bfs() "function-type interface" for the BFS
@@ -218,103 +218,103 @@
 		    ///@{
 		    template <class T>
 		    struct SetPredMapTraits : public Traits {
 		      typedef T PredMap;
 		      static PredMap *createPredMap(const Digraph &)
+		      {
 		        LEMON_ASSERT(false, "PredMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\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;
 		    };
 		    template <class T>
 		    struct SetDistMapTraits : public Traits {
 		      typedef T DistMap;
 		      static DistMap *createDistMap(const Digraph &)
+		      {
 		        LEMON_ASSERT(false, "DistMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\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;
 		    };
 		    template <class T>
 		    struct SetReachedMapTraits : public Traits {
 		      typedef T ReachedMap;
 		      static ReachedMap *createReachedMap(const Digraph &)
+		      {
 		        LEMON_ASSERT(false, "ReachedMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\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;
 		    };
 		    template <class T>
 		    struct SetProcessedMapTraits : public Traits {
 		      typedef T ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &)
+		      {
 		        LEMON_ASSERT(false, "ProcessedMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\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;
 		    };
 		    struct SetStandardProcessedMapTraits : public Traits {
 		      typedef typename Digraph::template NodeMap<bool> ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &g)
+		      {
 		        return new ProcessedMap(g);
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\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 > {
 		      typedef Bfs< Digraph, SetStandardProcessedMapTraits > Create;
 		    };
 		    ///@}
 		  public:
 		    ///Constructor.
@@ -826,92 +826,92 @@
 		  struct BfsWizardDefaultTraits
+		  {
 		    ///The type of the digraph the algorithm runs on.
 		    typedef GR Digraph;
 		    ///\brief The type of the map that stores the predecessor
 		    ///arcs of the shortest paths.
 		    ///
 		    ///The type of the map that stores the predecessor
 		    ///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.
 		    ///The type of the map that indicates which nodes are processed.
 		    ///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
 		    static ProcessedMap *createProcessedMap(const Digraph &)
 		#endif
+		    {
 		      return new ProcessedMap();
+		    }
 		    ///The type of the map that indicates which nodes are reached.
 		    ///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.
 		    ///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);
+		    }
 		    ///The type of the shortest paths.
 		    ///The type of the shortest paths.
 		    ///It must meet the \ref concepts::Path "Path" concept.
 		    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.
 		  /// This \ref BfsWizard class needs default traits,
 		  /// as well as the \ref Bfs class.
 		  /// The \ref BfsWizardBase is a class to be the default traits of the
 		  /// \ref BfsWizard class.
 		  template<class GR>
 		  class BfsWizardBase : public BfsWizardDefaultTraits<GR>
+		  {
 		    typedef BfsWizardDefaultTraits<GR> Base;
@@ -1059,82 +1059,82 @@
 		    void run()
+		    {
 		      run(INVALID);
+		    }
 		    template<class T>
 		    struct SetPredMapBase : public Base {
 		      typedef T PredMap;
 		      static PredMap *createPredMap(const Digraph &) { return 0; };
 		      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)
+		    {
 		      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
 		      return BfsWizard<SetPredMapBase<T> >(*this);
+		    }
 		    template<class T>
 		    struct SetReachedMapBase : public Base {
 		      typedef T ReachedMap;
 		      static ReachedMap *createReachedMap(const Digraph &) { return 0; };
 		      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)
+		    {
 		      Base::_reached=reinterpret_cast<void*>(const_cast<T*>(&t));
 		      return BfsWizard<SetReachedMapBase<T> >(*this);
+		    }
 		    template<class T>
 		    struct SetDistMapBase : public Base {
 		      typedef T DistMap;
 		      static DistMap *createDistMap(const Digraph &) { return 0; };
 		      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)
+		    {
 		      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
 		      return BfsWizard<SetDistMapBase<T> >(*this);
+		    }
 		    template<class T>
 		    struct SetProcessedMapBase : public Base {
 		      typedef T ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &) { return 0; };
 		      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)
+		    {
 		      Base::_processed=reinterpret_cast<void*>(const_cast<T*>(&t));
 		      return BfsWizard<SetProcessedMapBase<T> >(*this);
+		    }
 		    template<class T>
 		    struct SetPathBase : public Base {
 		      typedef T Path;
 		      SetPathBase(const TR &b) : TR(b) {}
 		    };
@@ -1258,29 +1258,29 @@
 		  template<class _Digraph>
 		  struct BfsVisitDefaultTraits {
 		    /// \brief The type of the digraph the algorithm runs on.
 		    typedef _Digraph Digraph;
 		    /// \brief The type of the map that indicates which nodes are reached.
 		    ///
 		    /// 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;
-		    /// \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);
+		    }
 		  };
 		  /// \ingroup search
 		  ///
 		  /// \brief %BFS algorithm class with visitor interface.
 		  ///
 		  /// This class provides an efficient implementation of the %BFS algorithm
 		  /// with visitor interface.

lemon/dfs.h

Show inline comments

@@ -41,78 +41,78 @@
 		  struct DfsDefaultTraits
+		  {
 		    ///The type of the digraph the algorithm runs on.
 		    typedef GR Digraph;
 		    ///\brief The type of the map that stores the predecessor
 		    ///arcs of the %DFS paths.
 		    ///
 		    ///The type of the map that stores the predecessor
 		    ///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.
 		    ///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
 		    static ProcessedMap *createProcessedMap(const Digraph &)
 		#endif
+		    {
 		      return new ProcessedMap();
+		    }
 		    ///The type of the map that indicates which nodes are reached.
 		    ///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.
 		    ///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);
+		    }
 		  };
 		  ///%DFS algorithm class.
 		  ///\ingroup search
 		  ///This class provides an efficient implementation of the %DFS algorithm.
 		  ///
 		  ///There is also a \ref dfs() "function-type interface" for the DFS
@@ -218,102 +218,102 @@
 		    ///@{
 		    template <class T>
 		    struct SetPredMapTraits : public Traits {
 		      typedef T PredMap;
 		      static PredMap *createPredMap(const Digraph &)
+		      {
 		        LEMON_ASSERT(false, "PredMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\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;
 		    };
 		    template <class T>
 		    struct SetDistMapTraits : public Traits {
 		      typedef T DistMap;
 		      static DistMap *createDistMap(const Digraph &)
+		      {
 		        LEMON_ASSERT(false, "DistMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\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;
 		    };
 		    template <class T>
 		    struct SetReachedMapTraits : public Traits {
 		      typedef T ReachedMap;
 		      static ReachedMap *createReachedMap(const Digraph &)
+		      {
 		        LEMON_ASSERT(false, "ReachedMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\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;
 		    };
 		    template <class T>
 		    struct SetProcessedMapTraits : public Traits {
 		      typedef T ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &)
+		      {
 		        LEMON_ASSERT(false, "ProcessedMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\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;
 		    };
 		    struct SetStandardProcessedMapTraits : public Traits {
 		      typedef typename Digraph::template NodeMap<bool> ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &g)
+		      {
 		        return new ProcessedMap(g);
+		      }
 		    };
 		    ///\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 > {
 		      typedef Dfs< Digraph, SetStandardProcessedMapTraits > Create;
 		    };
 		    ///@}
 		  public:
 		    ///Constructor.
@@ -759,79 +759,79 @@
 		  struct DfsWizardDefaultTraits
+		  {
 		    ///The type of the digraph the algorithm runs on.
 		    typedef GR Digraph;
 		    ///\brief The type of the map that stores the predecessor
 		    ///arcs of the %DFS paths.
 		    ///
 		    ///The type of the map that stores the predecessor
 		    ///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.
 		    ///The type of the map that indicates which nodes are processed.
 		    ///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
 		    static ProcessedMap *createProcessedMap(const Digraph &)
 		#endif
+		    {
 		      return new ProcessedMap();
+		    }
 		    ///The type of the map that indicates which nodes are reached.
 		    ///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.
 		    ///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);
+		    }
 		    ///The type of the DFS paths.
 		    ///The type of the DFS paths.
 		    ///It must meet the \ref concepts::Path "Path" concept.
 		    typedef lemon::Path<Digraph> Path;
 		  };
@@ -992,82 +992,82 @@
 		    void run()
+		    {
 		      run(INVALID);
+		    }
 		    template<class T>
 		    struct SetPredMapBase : public Base {
 		      typedef T PredMap;
 		      static PredMap *createPredMap(const Digraph &) { return 0; };
 		      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)
+		    {
 		      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
 		      return DfsWizard<SetPredMapBase<T> >(*this);
+		    }
 		    template<class T>
 		    struct SetReachedMapBase : public Base {
 		      typedef T ReachedMap;
 		      static ReachedMap *createReachedMap(const Digraph &) { return 0; };
 		      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)
+		    {
 		      Base::_reached=reinterpret_cast<void*>(const_cast<T*>(&t));
 		      return DfsWizard<SetReachedMapBase<T> >(*this);
+		    }
 		    template<class T>
 		    struct SetDistMapBase : public Base {
 		      typedef T DistMap;
 		      static DistMap *createDistMap(const Digraph &) { return 0; };
 		      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)
+		    {
 		      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
 		      return DfsWizard<SetDistMapBase<T> >(*this);
+		    }
 		    template<class T>
 		    struct SetProcessedMapBase : public Base {
 		      typedef T ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &) { return 0; };
 		      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)
+		    {
 		      Base::_processed=reinterpret_cast<void*>(const_cast<T*>(&t));
 		      return DfsWizard<SetProcessedMapBase<T> >(*this);
+		    }
 		    template<class T>
 		    struct SetPathBase : public Base {
 		      typedef T Path;
 		      SetPathBase(const TR &b) : TR(b) {}
 		    };
@@ -1204,29 +1204,29 @@
 		  template<class _Digraph>
 		  struct DfsVisitDefaultTraits {
 		    /// \brief The type of the digraph the algorithm runs on.
 		    typedef _Digraph Digraph;
 		    /// \brief The type of the map that indicates which nodes are reached.
 		    ///
 		    /// 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;
-		    /// \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);
+		    }
 		  };
 		  /// \ingroup search
 		  ///
 		  /// \brief %DFS algorithm class with visitor interface.
 		  ///
 		  /// This class provides an efficient implementation of the %DFS algorithm
 		  /// with visitor interface.

lemon/dijkstra.h

Show inline comments

@@ -130,64 +130,64 @@
 		    static Heap *createHeap(HeapCrossRef& r)
+		    {
 		      return new Heap(r);
+		    }
 		    ///\brief The type of the map that stores the predecessor
 		    ///arcs of the shortest paths.
 		    ///
 		    ///The type of the map that stores the predecessor
 		    ///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.
 		    ///The type of the map that indicates which nodes are processed.
 		    ///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
 		    static ProcessedMap *createProcessedMap(const Digraph &)
 		#endif
+		    {
 		      return new ProcessedMap();
+		    }
 		    ///The type of the map that stores the distances of the nodes.
 		    ///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);
+		    }
 		  };
 		  ///%Dijkstra algorithm class.
 		  /// \ingroup shortest_path
 		  ///This class provides an efficient implementation of the %Dijkstra algorithm.
 		  ///
 		  ///The arc lengths are passed to the algorithm using a
@@ -318,86 +318,86 @@
 		    ///@{
 		    template <class T>
 		    struct SetPredMapTraits : public Traits {
 		      typedef T PredMap;
 		      static PredMap *createPredMap(const Digraph &)
+		      {
 		        LEMON_ASSERT(false, "PredMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\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> > {
 		      typedef Dijkstra< Digraph, LengthMap, SetPredMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct SetDistMapTraits : public Traits {
 		      typedef T DistMap;
 		      static DistMap *createDistMap(const Digraph &)
+		      {
 		        LEMON_ASSERT(false, "DistMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\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> > {
 		      typedef Dijkstra< Digraph, LengthMap, SetDistMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct SetProcessedMapTraits : public Traits {
 		      typedef T ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &)
+		      {
 		        LEMON_ASSERT(false, "ProcessedMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\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> > {
 		      typedef Dijkstra< Digraph, LengthMap, SetProcessedMapTraits<T> > Create;
 		    };
 		    struct SetStandardProcessedMapTraits : public Traits {
 		      typedef typename Digraph::template NodeMap<bool> ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &g)
+		      {
 		        return new ProcessedMap(g);
+		      }
 		    };
 		    ///\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 > {
 		      typedef Dijkstra< Digraph, LengthMap, SetStandardProcessedMapTraits >
 		      Create;
 		    };
 		    template <class H, class CR>
 		    struct SetHeapTraits : public Traits {
 		      typedef CR HeapCrossRef;
 		      typedef H Heap;
 		      static HeapCrossRef *createHeapCrossRef(const Digraph &) {
@@ -977,64 +977,64 @@
 		    static Heap *createHeap(HeapCrossRef& r)
+		    {
 		      return new Heap(r);
+		    }
 		    ///\brief The type of the map that stores the predecessor
 		    ///arcs of the shortest paths.
 		    ///
 		    ///The type of the map that stores the predecessor
 		    ///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.
 		    ///The type of the map that indicates which nodes are processed.
 		    ///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
 		    static ProcessedMap *createProcessedMap(const Digraph &)
 		#endif
+		    {
 		      return new ProcessedMap();
+		    }
 		    ///The type of the map that stores the distances of the nodes.
 		    ///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);
+		    }
 		    ///The type of the shortest paths.
 		    ///The type of the shortest paths.
 		    ///It must meet the \ref concepts::Path "Path" concept.
 		    typedef lemon::Path<Digraph> Path;
 		  };
@@ -1189,64 +1189,64 @@
 		      if (Base::_di)
 		        *reinterpret_cast<Value*>(Base::_di) = dijk.dist(t);
 		      return dijk.reached(t);
+		    }
 		    template<class T>
 		    struct SetPredMapBase : public Base {
 		      typedef T PredMap;
 		      static PredMap *createPredMap(const Digraph &) { return 0; };
 		      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)
+		    {
 		      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
 		      return DijkstraWizard<SetPredMapBase<T> >(*this);
+		    }
 		    template<class T>
 		    struct SetDistMapBase : public Base {
 		      typedef T DistMap;
 		      static DistMap *createDistMap(const Digraph &) { return 0; };
 		      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)
+		    {
 		      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
 		      return DijkstraWizard<SetDistMapBase<T> >(*this);
+		    }
 		    template<class T>
 		    struct SetProcessedMapBase : public Base {
 		      typedef T ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &) { return 0; };
 		      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)
+		    {
 		      Base::_processed=reinterpret_cast<void*>(const_cast<T*>(&t));
 		      return DijkstraWizard<SetProcessedMapBase<T> >(*this);
+		    }
 		    template<class T>
 		    struct SetPathBase : public Base {
 		      typedef T Path;
 		      SetPathBase(const TR &b) : TR(b) {}
 		    };

lemon/maps.h

Show inline comments

@@ -64,40 +64,40 @@
 		  class NullMap : public MapBase<K, V> {
 		  public:
 		    typedef MapBase<K, V> Parent;
 		    typedef typename Parent::Key Key;
 		    typedef typename Parent::Value Value;
 		    /// Gives back a default constructed element.
 		    Value operator[](const Key&) const { return Value(); }
 		    /// Absorbs the value.
 		    void set(const Key&, const Value&) {}
 		  };
 		  /// Returns a \ref NullMap class
-		  /// This function just returns a \ref NullMap class.
+		  /// Returns a \c NullMap class
 		  /// This function just returns a \c NullMap class.
 		  /// \relates NullMap
 		  template <typename K, typename V>
 		  NullMap<K, V> nullMap() {
 		    return NullMap<K, V>();
+		  }
 		  /// Constant map.
 		  /// 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.
 		  ///
 		  /// The simplest way of using this map is through the constMap()
 		  /// function.
 		  ///
 		  /// \sa NullMap
 		  /// \sa IdentityMap
 		  template<typename K, typename V>
 		  class ConstMap : public MapBase<K, V> {
 		  private:
 		    V _value;
@@ -124,48 +124,48 @@
 		    /// Absorbs the value.
 		    void set(const Key&, const Value&) {}
 		    /// Sets the value that is assigned to each key.
 		    void setAll(const Value &v) {
 		      _value = v;
+		    }
 		    template<typename V1>
 		    ConstMap(const ConstMap<K, V1> &, const Value &v) : _value(v) {}
 		  };
 		  /// Returns a \ref ConstMap class
-		  /// This function just returns a \ref ConstMap class.
+		  /// Returns a \c 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) {
 		    return ConstMap<K, V>(v);
+		  }
 		  template<typename K, typename V>
 		  inline ConstMap<K, V> constMap() {
 		    return ConstMap<K, V>();
+		  }
 		  template<typename T, T v>
 		  struct Const {};
 		  /// Constant map with inlined constant value.
 		  /// 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.
 		  ///
 		  /// The simplest way of using this map is through the constMap()
 		  /// function.
 		  ///
 		  /// \sa NullMap
 		  /// \sa IdentityMap
 		  template<typename K, typename V, V v>
 		  class ConstMap<K, Const<V, v> > : public MapBase<K, V> {
 		  public:
 		    typedef MapBase<K, V> Parent;
@@ -173,27 +173,27 @@
 		    typedef typename Parent::Value Value;
 		    /// Constructor.
 		    ConstMap() {}
 		    /// Gives back the specified value.
 		    Value operator[](const Key&) const { return v; }
 		    /// Absorbs the value.
 		    void set(const Key&, const Value&) {}
 		  };
 		  /// Returns a \ref ConstMap class with inlined constant value
-		  /// This function just returns a \ref ConstMap class with inlined
+		  /// Returns a \c ConstMap class with inlined constant value
 		  /// This function just returns a \c ConstMap class with inlined
 		  /// constant value.
 		  /// \relates ConstMap
 		  template<typename K, typename V, V v>
 		  inline ConstMap<K, Const<V, v> > constMap() {
 		    return ConstMap<K, Const<V, v> >();
+		  }
 		  /// Identity map.
 		  /// This \ref concepts::ReadMap "read-only map" gives back the given
 		  /// key as value without any modification.
@@ -203,41 +203,41 @@
 		  class IdentityMap : public MapBase<T, T> {
 		  public:
 		    typedef MapBase<T, T> Parent;
 		    typedef typename Parent::Key Key;
 		    typedef typename Parent::Value Value;
 		    /// Gives back the given value without any modification.
 		    Value operator[](const Key &k) const {
 		      return k;
+		    }
 		  };
 		  /// Returns an \ref IdentityMap class
-		  /// This function just returns an \ref IdentityMap class.
+		  /// Returns an \c IdentityMap class
 		  /// This function just returns an \c IdentityMap class.
 		  /// \relates IdentityMap
 		  template<typename T>
 		  inline IdentityMap<T> identityMap() {
 		    return IdentityMap<T>();
+		  }
 		  /// \brief Map for storing values for integer keys from the range
 		  /// <tt>[0..size-1]</tt>.
 		  ///
 		  /// 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.
 		  ///
 		  /// The simplest way of using this map is through the rangeMap()
 		  /// function.
 		  template <typename V>
 		  class RangeMap : public MapBase<int, V> {
 		    template <typename V1>
 		    friend class RangeMap;
 		  private:
 		    typedef std::vector<V> Vector;
@@ -259,25 +259,25 @@
 		  public:
 		    /// Constructor with specified default value.
 		    RangeMap(int size = 0, const Value &value = Value())
 		      : _vector(size, value) {}
 		    /// Constructs the map from an appropriate \c std::vector.
 		    template <typename V1>
 		    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 the size of the map.
 		    int size() {
 		      return _vector.size();
+		    }
 		    /// Resizes the map.
 		    /// Resizes the underlying \c std::vector container, so changes the
@@ -302,37 +302,37 @@
 		    ///\e
 		    ConstReference operator[](const Key &k) const {
 		      return _vector[k];
+		    }
 		    ///\e
 		    void set(const Key &k, const Value &v) {
 		      _vector[k] = v;
+		    }
 		  };
 		  /// Returns a \ref RangeMap class
-		  /// This function just returns a \ref RangeMap class.
+		  /// Returns a \c 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>
 		  inline RangeMap<V> rangeMap(const std::vector<V> &vector) {
 		    return RangeMap<V>(vector);
+		  }
 		  /// Map type based on \c std::map
 		  /// This map is essentially a wrapper for \c std::map with addition
 		  /// that you can specify a default value for the keys that are not
@@ -379,25 +379,25 @@
 		  public:
 		    /// \brief Constructor with specified default value.
 		    SparseMap(const Value &value = Value()) : _value(value) {}
 		    /// \brief Constructs the map from an appropriate \c std::map, and
 		    /// explicitly specifies a default value.
 		    template <typename V1, typename Comp1>
 		    SparseMap(const std::map<Key, V1, Comp1> &map,
 		              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) {}
 		  private:
 		    SparseMap& operator=(const SparseMap&);
 		  public:
 		    ///\e
 		    Reference operator[](const Key &k) {
@@ -424,43 +424,43 @@
 		        it->second = v;
 		      else
 		        _map.insert(it, std::make_pair(k, v));
+		    }
 		    ///\e
 		    void setAll(const Value &v) {
 		      _value = v;
 		      _map.clear();
+		    }
 		  };
 		  /// Returns a \ref SparseMap class
-		  /// This function just returns a \ref SparseMap class with specified
+		  /// Returns a \c SparseMap class
 		  /// This function just returns a \c SparseMap class with specified
 		  /// default value.
 		  /// \relates SparseMap
 		  template<typename K, typename V, typename Compare>
 		  inline SparseMap<K, V, Compare> sparseMap(const V& value = V()) {
 		    return SparseMap<K, V, Compare>(value);
+		  }
 		  template<typename K, typename V>
 		  inline SparseMap<K, V, std::less<K> > sparseMap(const V& value = V()) {
 		    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>
 		  inline SparseMap<K, V, Compare>
 		    sparseMap(const std::map<K, V, Compare> &map, const V& value = V())
+		  {
 		    return SparseMap<K, V, Compare>(map, value);
+		  }
 		  /// @}
 		  /// \addtogroup map_adaptors
@@ -492,27 +492,27 @@
 		    typedef MapBase<typename M2::Key, typename M1::Value> Parent;
 		    typedef typename Parent::Key Key;
 		    typedef typename Parent::Value Value;
 		    /// Constructor
 		    ComposeMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
 		    /// \e
 		    typename MapTraits<M1>::ConstReturnValue
 		    operator[](const Key &k) const { return _m1[_m2[k]]; }
 		  };
 		  /// Returns a \ref ComposeMap class
-		  /// This function just returns a \ref ComposeMap class.
+		  /// Returns a \c 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>
 		  /// will be equal to <tt>m1[m2[x]]</tt>.
 		  ///
 		  /// \relates ComposeMap
 		  template <typename M1, typename M2>
 		  inline ComposeMap<M1, M2> composeMap(const M1 &m1, const M2 &m2) {
 		    return ComposeMap<M1, M2>(m1, m2);
+		  }
@@ -547,27 +547,27 @@
 		  public:
 		    typedef MapBase<typename M1::Key, V> Parent;
 		    typedef typename Parent::Key Key;
 		    typedef typename Parent::Value Value;
 		    /// Constructor
 		    CombineMap(const M1 &m1, const M2 &m2, const F &f = F())
 		      : _m1(m1), _m2(m2), _f(f) {}
 		    /// \e
 		    Value operator[](const Key &k) const { return _f(_m1[k],_m2[k]); }
 		  };
 		  /// Returns a \ref CombineMap class
-		  /// This function just returns a \ref CombineMap class.
+		  /// Returns a \c 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
 		  /// \code
 		  ///   combineMap(m1,m2,std::plus<double>())
 		  /// \endcode
 		  /// is equivalent to
 		  /// \code
 		  ///   addMap(m1,m2)
 		  /// \endcode
 		  ///
 		  /// This function is specialized for adaptable binary function
@@ -616,27 +616,27 @@
 		    F _f;
 		  public:
 		    typedef MapBase<K, V> Parent;
 		    typedef typename Parent::Key Key;
 		    typedef typename Parent::Value Value;
 		    /// Constructor
 		    FunctorToMap(const F &f = F()) : _f(f) {}
 		    /// \e
 		    Value operator[](const Key &k) const { return _f(k); }
 		  };
 		  /// Returns a \ref FunctorToMap class
-		  /// This function just returns a \ref FunctorToMap class.
+		  /// Returns a \c FunctorToMap class
 		  /// This function just returns a \c FunctorToMap class.
 		  ///
 		  /// This function is specialized for adaptable binary function
 		  /// classes and C++ functions.
 		  ///
 		  /// \relates FunctorToMap
 		  template<typename K, typename V, typename F>
 		  inline FunctorToMap<F, K, V> functorToMap(const F &f) {
 		    return FunctorToMap<F, K, V>(f);
+		  }
 		  template <typename F>
 		  inline FunctorToMap<F, typename F::argument_type, typename F::result_type>
@@ -675,27 +675,27 @@
 		    typedef typename Parent::Key argument_type;
 		    typedef typename Parent::Value result_type;
 		    /// Constructor
 		    MapToFunctor(const M &m) : _m(m) {}
 		    /// \e
 		    Value operator()(const Key &k) const { return _m[k]; }
 		    /// \e
 		    Value operator[](const Key &k) const { return _m[k]; }
 		  };
 		  /// Returns a \ref MapToFunctor class
-		  /// This function just returns a \ref MapToFunctor class.
+		  /// Returns a \c MapToFunctor class
 		  /// This function just returns a \c MapToFunctor class.
 		  /// \relates MapToFunctor
 		  template<typename M>
 		  inline MapToFunctor<M> mapToFunctor(const M &m) {
 		    return MapToFunctor<M>(m);
+		  }
 		  /// \brief Map adaptor to convert the \c Value type of a map to
 		  /// another type using the default conversion.
 		  /// Map adaptor to convert the \c Value type of a \ref concepts::ReadMap
 		  /// "readable map" to another type using the default conversion.
@@ -714,27 +714,27 @@
 		    typedef typename Parent::Value Value;
 		    /// Constructor
 		    /// Constructor.
 		    /// \param m The underlying map.
 		    ConvertMap(const M &m) : _m(m) {}
 		    /// \e
 		    Value operator[](const Key &k) const { return _m[k]; }
 		  };
 		  /// Returns a \ref ConvertMap class
-		  /// This function just returns a \ref ConvertMap class.
+		  /// Returns a \c 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) {
 		    return ConvertMap<M, V>(map);
+		  }
 		  /// Applies all map setting operations to two maps
 		  /// This map has two \ref concepts::WriteMap "writable map" parameters
 		  /// and each write request will be passed to both of them.
 		  /// If \c M1 is also \ref concepts::ReadMap "readable", then the read
@@ -754,27 +754,27 @@
 		    typedef MapBase<typename M1::Key, typename M1::Value> Parent;
 		    typedef typename Parent::Key Key;
 		    typedef typename Parent::Value Value;
 		    /// Constructor
 		    ForkMap(M1 &m1, M2 &m2) : _m1(m1), _m2(m2) {}
 		    /// Returns the value associated with the given key in the first map.
 		    Value operator[](const Key &k) const { return _m1[k]; }
 		    /// Sets the value associated with the given key in both maps.
 		    void set(const Key &k, const Value &v) { _m1.set(k,v); _m2.set(k,v); }
 		  };
 		  /// Returns a \ref ForkMap class
-		  /// This function just returns a \ref ForkMap class.
+		  /// Returns a \c 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) {
 		    return ForkMap<M1,M2>(m1,m2);
+		  }
 		  /// Sum of two maps
 		  /// This \ref concepts::ReadMap "read-only map" returns the sum
 		  /// of the values of the two given maps.
 		  /// Its \c Key and \c Value types are inherited from \c M1.
@@ -798,27 +798,27 @@
 		    const M2 &_m2;
 		  public:
 		    typedef MapBase<typename M1::Key, typename M1::Value> Parent;
 		    typedef typename Parent::Key Key;
 		    typedef typename Parent::Value Value;
 		    /// Constructor
 		    AddMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
 		    /// \e
 		    Value operator[](const Key &k) const { return _m1[k]+_m2[k]; }
 		  };
 		  /// Returns an \ref AddMap class
-		  /// This function just returns an \ref AddMap class.
+		  /// Returns an \c 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
 		  /// <tt>m1[x]+m2[x]</tt>.
 		  ///
 		  /// \relates AddMap
 		  template<typename M1, typename M2>
 		  inline AddMap<M1, M2> addMap(const M1 &m1, const M2 &m2) {
 		    return AddMap<M1, M2>(m1,m2);
+		  }
@@ -846,27 +846,27 @@
 		    const M2 &_m2;
 		  public:
 		    typedef MapBase<typename M1::Key, typename M1::Value> Parent;
 		    typedef typename Parent::Key Key;
 		    typedef typename Parent::Value Value;
 		    /// Constructor
 		    SubMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
 		    /// \e
 		    Value operator[](const Key &k) const { return _m1[k]-_m2[k]; }
 		  };
 		  /// Returns a \ref SubMap class
-		  /// This function just returns a \ref SubMap class.
+		  /// Returns a \c 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
 		  /// <tt>m1[x]-m2[x]</tt>.
 		  ///
 		  /// \relates SubMap
 		  template<typename M1, typename M2>
 		  inline SubMap<M1, M2> subMap(const M1 &m1, const M2 &m2) {
 		    return SubMap<M1, M2>(m1,m2);
+		  }
@@ -895,27 +895,27 @@
 		    const M2 &_m2;
 		  public:
 		    typedef MapBase<typename M1::Key, typename M1::Value> Parent;
 		    typedef typename Parent::Key Key;
 		    typedef typename Parent::Value Value;
 		    /// Constructor
 		    MulMap(const M1 &m1,const M2 &m2) : _m1(m1), _m2(m2) {}
 		    /// \e
 		    Value operator[](const Key &k) const { return _m1[k]*_m2[k]; }
 		  };
 		  /// Returns a \ref MulMap class
-		  /// This function just returns a \ref MulMap class.
+		  /// Returns a \c 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
 		  /// <tt>m1[x]*m2[x]</tt>.
 		  ///
 		  /// \relates MulMap
 		  template<typename M1, typename M2>
 		  inline MulMap<M1, M2> mulMap(const M1 &m1,const M2 &m2) {
 		    return MulMap<M1, M2>(m1,m2);
+		  }
@@ -943,27 +943,27 @@
 		    const M2 &_m2;
 		  public:
 		    typedef MapBase<typename M1::Key, typename M1::Value> Parent;
 		    typedef typename Parent::Key Key;
 		    typedef typename Parent::Value Value;
 		    /// Constructor
 		    DivMap(const M1 &m1,const M2 &m2) : _m1(m1), _m2(m2) {}
 		    /// \e
 		    Value operator[](const Key &k) const { return _m1[k]/_m2[k]; }
 		  };
 		  /// Returns a \ref DivMap class
-		  /// This function just returns a \ref DivMap class.
+		  /// Returns a \c 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
 		  /// <tt>m1[x]/m2[x]</tt>.
 		  ///
 		  /// \relates DivMap
 		  template<typename M1, typename M2>
 		  inline DivMap<M1, M2> divMap(const M1 &m1,const M2 &m2) {
 		    return DivMap<M1, M2>(m1,m2);
+		  }
@@ -1029,41 +1029,41 @@
 		    /// Constructor
 		    /// Constructor.
 		    /// \param m The undelying map.
 		    /// \param v The constant value.
 		    ShiftWriteMap(M &m, const C &v) : _m(m), _v(v) {}
 		    /// \e
 		    Value operator[](const Key &k) const { return _m[k]+_v; }
 		    /// \e
 		    void set(const Key &k, const Value &v) { _m.set(k, v-_v); }
 		  };
 		  /// Returns a \ref ShiftMap class
-		  /// This function just returns a \ref ShiftMap class.
+		  /// Returns a \c 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
 		  /// <tt>m[x]+v</tt>.
 		  ///
 		  /// \relates ShiftMap
 		  template<typename M, typename C>
 		  inline ShiftMap<M, C> shiftMap(const M &m, const C &v) {
 		    return ShiftMap<M, C>(m,v);
+		  }
 		  /// Returns a \ref ShiftWriteMap class
-		  /// This function just returns a \ref ShiftWriteMap class.
+		  /// Returns a \c 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
 		  /// <tt>m[x]+v</tt>.
 		  /// Moreover it makes also possible to write the map.
 		  ///
 		  /// \relates ShiftWriteMap
 		  template<typename M, typename C>
 		  inline ShiftWriteMap<M, C> shiftWriteMap(M &m, const C &v) {
 		    return ShiftWriteMap<M, C>(m,v);
+		  }
@@ -1131,41 +1131,41 @@
 		    /// Constructor
 		    /// Constructor.
 		    /// \param m The undelying map.
 		    /// \param v The constant value.
 		    ScaleWriteMap(M &m, const C &v) : _m(m), _v(v) {}
 		    /// \e
 		    Value operator[](const Key &k) const { return _v*_m[k]; }
 		    /// \e
 		    void set(const Key &k, const Value &v) { _m.set(k, v/_v); }
 		  };
 		  /// Returns a \ref ScaleMap class
-		  /// This function just returns a \ref ScaleMap class.
+		  /// Returns a \c 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
 		  /// <tt>v*m[x]</tt>.
 		  ///
 		  /// \relates ScaleMap
 		  template<typename M, typename C>
 		  inline ScaleMap<M, C> scaleMap(const M &m, const C &v) {
 		    return ScaleMap<M, C>(m,v);
+		  }
 		  /// Returns a \ref ScaleWriteMap class
-		  /// This function just returns a \ref ScaleWriteMap class.
+		  /// Returns a \c 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
 		  /// <tt>v*m[x]</tt>.
 		  /// Moreover it makes also possible to write the map.
 		  ///
 		  /// \relates ScaleWriteMap
 		  template<typename M, typename C>
 		  inline ScaleWriteMap<M, C> scaleWriteMap(M &m, const C &v) {
 		    return ScaleWriteMap<M, C>(m,v);
+		  }
@@ -1231,40 +1231,40 @@
 		    typedef MapBase<typename M::Key, typename M::Value> Parent;
 		    typedef typename Parent::Key Key;
 		    typedef typename Parent::Value Value;
 		    /// Constructor
 		    NegWriteMap(M &m) : _m(m) {}
 		    /// \e
 		    Value operator[](const Key &k) const { return -_m[k]; }
 		    /// \e
 		    void set(const Key &k, const Value &v) { _m.set(k, -v); }
 		  };
 		  /// Returns a \ref NegMap class
-		  /// This function just returns a \ref NegMap class.
+		  /// Returns a \c 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>.
 		  ///
 		  /// \relates NegMap
 		  template <typename M>
 		  inline NegMap<M> negMap(const M &m) {
 		    return NegMap<M>(m);
+		  }
 		  /// Returns a \ref NegWriteMap class
-		  /// This function just returns a \ref NegWriteMap class.
+		  /// Returns a \c 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>.
 		  /// Moreover it makes also possible to write the map.
 		  ///
 		  /// \relates NegWriteMap
 		  template <typename M>
 		  inline NegWriteMap<M> negWriteMap(M &m) {
 		    return NegWriteMap<M>(m);
+		  }
@@ -1287,27 +1287,27 @@
 		    typedef typename Parent::Value Value;
 		    /// Constructor
 		    AbsMap(const M &m) : _m(m) {}
 		    /// \e
 		    Value operator[](const Key &k) const {
 		      Value tmp = _m[k];
 		      return tmp >= 0 ? tmp : -tmp;
+		    }
 		  };
 		  /// Returns an \ref AbsMap class
-		  /// This function just returns an \ref AbsMap class.
+		  /// Returns an \c 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
 		  /// it is positive or zero and <tt>-m[x]</tt> if <tt>m[x]</tt> is
 		  /// negative.
 		  ///
 		  /// \relates AbsMap
 		  template<typename M>
 		  inline AbsMap<M> absMap(const M &m) {
 		    return AbsMap<M>(m);
+		  }
@@ -1336,27 +1336,27 @@
 		  /// \sa ConstMap
 		  template <typename K>
 		  class TrueMap : public MapBase<K, bool> {
 		  public:
 		    typedef MapBase<K, bool> Parent;
 		    typedef typename Parent::Key Key;
 		    typedef typename Parent::Value Value;
 		    /// Gives back \c true.
 		    Value operator[](const Key&) const { return true; }
 		  };
 		  /// Returns a \ref TrueMap class
-		  /// This function just returns a \ref TrueMap class.
+		  /// Returns a \c TrueMap class
 		  /// This function just returns a \c TrueMap class.
 		  /// \relates TrueMap
 		  template<typename K>
 		  inline TrueMap<K> trueMap() {
 		    return TrueMap<K>();
+		  }
 		  /// Constant \c false map.
 		  /// This \ref concepts::ReadMap "read-only map" assigns \c false to
 		  /// each key.
 		  ///
@@ -1373,27 +1373,27 @@
 		  /// \sa ConstMap
 		  template <typename K>
 		  class FalseMap : public MapBase<K, bool> {
 		  public:
 		    typedef MapBase<K, bool> Parent;
 		    typedef typename Parent::Key Key;
 		    typedef typename Parent::Value Value;
 		    /// Gives back \c false.
 		    Value operator[](const Key&) const { return false; }
 		  };
 		  /// Returns a \ref FalseMap class
-		  /// This function just returns a \ref FalseMap class.
+		  /// Returns a \c FalseMap class
 		  /// This function just returns a \c FalseMap class.
 		  /// \relates FalseMap
 		  template<typename K>
 		  inline FalseMap<K> falseMap() {
 		    return FalseMap<K>();
+		  }
 		  /// @}
 		  /// \addtogroup map_adaptors
 		  /// @{
 		  /// Logical 'and' of two maps
@@ -1420,27 +1420,27 @@
 		    const M2 &_m2;
 		  public:
 		    typedef MapBase<typename M1::Key, bool> Parent;
 		    typedef typename Parent::Key Key;
 		    typedef typename Parent::Value Value;
 		    /// Constructor
 		    AndMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
 		    /// \e
 		    Value operator[](const Key &k) const { return _m1[k]&&_m2[k]; }
 		  };
 		  /// Returns an \ref AndMap class
-		  /// This function just returns an \ref AndMap class.
+		  /// Returns an \c 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
 		  /// <tt>m1[x]&&m2[x]</tt>.
 		  ///
 		  /// \relates AndMap
 		  template<typename M1, typename M2>
 		  inline AndMap<M1, M2> andMap(const M1 &m1, const M2 &m2) {
 		    return AndMap<M1, M2>(m1,m2);
+		  }
@@ -1468,27 +1468,27 @@
 		    const M2 &_m2;
 		  public:
 		    typedef MapBase<typename M1::Key, bool> Parent;
 		    typedef typename Parent::Key Key;
 		    typedef typename Parent::Value Value;
 		    /// Constructor
 		    OrMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
 		    /// \e
 		    Value operator[](const Key &k) const { return _m1[k]||_m2[k]; }
 		  };
 		  /// Returns an \ref OrMap class
-		  /// This function just returns an \ref OrMap class.
+		  /// Returns an \c 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
 		  /// <tt>m1[x]||m2[x]</tt>.
 		  ///
 		  /// \relates OrMap
 		  template<typename M1, typename M2>
 		  inline OrMap<M1, M2> orMap(const M1 &m1, const M2 &m2) {
 		    return OrMap<M1, M2>(m1,m2);
+		  }
@@ -1535,40 +1535,40 @@
 		    typedef MapBase<typename M::Key, bool> Parent;
 		    typedef typename Parent::Key Key;
 		    typedef typename Parent::Value Value;
 		    /// Constructor
 		    NotWriteMap(M &m) : _m(m) {}
 		    /// \e
 		    Value operator[](const Key &k) const { return !_m[k]; }
 		    /// \e
 		    void set(const Key &k, bool v) { _m.set(k, !v); }
 		  };
 		  /// Returns a \ref NotMap class
-		  /// This function just returns a \ref NotMap class.
+		  /// Returns a \c 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>.
 		  ///
 		  /// \relates NotMap
 		  template <typename M>
 		  inline NotMap<M> notMap(const M &m) {
 		    return NotMap<M>(m);
+		  }
 		  /// Returns a \ref NotWriteMap class
-		  /// This function just returns a \ref NotWriteMap class.
+		  /// Returns a \c 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>.
 		  /// Moreover it makes also possible to write the map.
 		  ///
 		  /// \relates NotWriteMap
 		  template <typename M>
 		  inline NotWriteMap<M> notWriteMap(M &m) {
 		    return NotWriteMap<M>(m);
+		  }
@@ -1596,27 +1596,27 @@
 		    const M2 &_m2;
 		  public:
 		    typedef MapBase<typename M1::Key, bool> Parent;
 		    typedef typename Parent::Key Key;
 		    typedef typename Parent::Value Value;
 		    /// Constructor
 		    EqualMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
 		    /// \e
 		    Value operator[](const Key &k) const { return _m1[k]==_m2[k]; }
 		  };
 		  /// Returns an \ref EqualMap class
-		  /// This function just returns an \ref EqualMap class.
+		  /// Returns an \c 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
 		  /// <tt>m1[x]==m2[x]</tt>.
 		  ///
 		  /// \relates EqualMap
 		  template<typename M1, typename M2>
 		  inline EqualMap<M1, M2> equalMap(const M1 &m1, const M2 &m2) {
 		    return EqualMap<M1, M2>(m1,m2);
+		  }
@@ -1644,27 +1644,27 @@
 		    const M2 &_m2;
 		  public:
 		    typedef MapBase<typename M1::Key, bool> Parent;
 		    typedef typename Parent::Key Key;
 		    typedef typename Parent::Value Value;
 		    /// Constructor
 		    LessMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
 		    /// \e
 		    Value operator[](const Key &k) const { return _m1[k]<_m2[k]; }
 		  };
 		  /// Returns an \ref LessMap class
-		  /// This function just returns an \ref LessMap class.
+		  /// Returns an \c 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
 		  /// <tt>m1[x]<m2[x]</tt>.
 		  ///
 		  /// \relates LessMap
 		  template<typename M1, typename M2>
 		  inline LessMap<M1, M2> lessMap(const M1 &m1, const M2 &m2) {
 		    return LessMap<M1, M2>(m1,m2);
+		  }
 		  namespace _maps_bits {
@@ -1736,47 +1736,47 @@
 		    /// The set function of the map
 		    void set(const Key& key, Value value) {
 		      if (value) {
 		        *_end++ = key;
+		      }
+		    }
 		  private:
 		    Iterator _begin;
 		    Iterator _end;
 		  };
 		  /// Returns a \ref LoggerBoolMap class
-		  /// This function just returns a \ref LoggerBoolMap class.
+		  /// Returns a \c 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.
 		  /// For example it makes easier to store the nodes in the processing
 		  /// order of Dfs algorithm, as the following examples show.
 		  /// \code
 		  ///   std::vector<Node> v;
 		  ///   dfs(g,s).processedMap(loggerBoolMap(std::back_inserter(v))).run();
 		  /// \endcode
 		  /// \code
 		  ///   std::vector<Node> v(countNodes(g));
 		  ///   dfs(g,s).processedMap(loggerBoolMap(v.begin())).run();
 		  /// \endcode
 		  ///
 		  /// \note The container of the iterator must contain enough space
 		  /// for the elements or the iterator should be an inserter iterator.
 		  ///
 		  /// \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>
 		  inline LoggerBoolMap<Iterator> loggerBoolMap(Iterator it) {
 		    return LoggerBoolMap<Iterator>(it);
+		  }
 		  /// Provides an immutable and unique id for each item in the graph.
 		  /// The IdMap class provides a unique and immutable id for each item of the
 		  /// same type (e.g. node) in the graph. This id is <ul><li>\b unique:
 		  /// different items (nodes) get different ids <li>\b immutable: the id of an
@@ -2273,27 +2273,27 @@
 		    ///
 		    /// The subscript operator.
 		    /// \param arc The arc
 		    /// \return The source of the arc
 		    Value operator[](const Key& arc) const {
 		      return _digraph.source(arc);
+		    }
 		  private:
 		    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) {
 		    return SourceMap<Digraph>(digraph);
+		  }
 		  /// \brief Returns the target of the given arc.
 		  ///
 		  /// The TargetMap gives back the target Node of the given arc.
 		  /// \see SourceMap
 		  template <typename Digraph>
 		  class TargetMap {
@@ -2312,27 +2312,27 @@
 		    ///
 		    /// The subscript operator.
 		    /// \param e The arc
 		    /// \return The target of the arc
 		    Value operator[](const Key& e) const {
 		      return _digraph.target(e);
+		    }
 		  private:
 		    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) {
 		    return TargetMap<Digraph>(digraph);
+		  }
 		  /// \brief Returns the "forward" directed arc view of an edge.
 		  ///
 		  /// Returns the "forward" directed arc view of an edge.
 		  /// \see BackwardMap
 		  template <typename Graph>
 		  class ForwardMap {
@@ -2351,27 +2351,27 @@
 		    ///
 		    /// The subscript operator.
 		    /// \param key An edge
 		    /// \return The "forward" directed arc view of edge
 		    Value operator[](const Key& key) const {
 		      return _graph.direct(key, true);
+		    }
 		  private:
 		    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) {
 		    return ForwardMap<Graph>(graph);
+		  }
 		  /// \brief Returns the "backward" directed arc view of an edge.
 		  ///
 		  /// Returns the "backward" directed arc view of an edge.
 		  /// \see ForwardMap
 		  template <typename Graph>
 		  class BackwardMap {
@@ -2390,27 +2390,27 @@
 		    ///
 		    /// The subscript operator.
 		    /// \param key An edge
 		    /// \return The "backward" directed arc view of edge
 		    Value operator[](const Key& key) const {
 		      return _graph.direct(key, false);
+		    }
 		  private:
 		    const Graph& _graph;
 		  };
 		  /// \brief Returns a \ref BackwardMap class
-		  /// This function just returns a \ref BackwardMap class.
+		  /// \brief Returns a \c BackwardMap class
 		  /// This function just returns a \c BackwardMap class.
 		  /// \relates BackwardMap
 		  template <typename Graph>
 		  inline BackwardMap<Graph> backwardMap(const Graph& graph) {
 		    return BackwardMap<Graph>(graph);
+		  }
 		  /// \brief Potential difference map
 		  ///
 		  /// If there is an potential map on the nodes then we
 		  /// can get an arc map as we get the substraction of the
 		  /// values of the target and source.
 		  template <typename Digraph, typename NodeMap>

0 comments (0 inline)

RhodeCode

Login to your account