64f8f7cc6168.patch on Ticket #119 – Attachment – LEMON

demo/graph_to_eps_demo.cc

# HG changeset patch
# User Peter Kovacs <kpeter@inf.elte.hu>
# Date 1223539784 -7200
# Node ID 64f8f7cc6168b86c88ad05e447aecb9b1428c61e
# Parent  e57e10a8ea1b3b89a3350af00e85ca51d7ad1dfc
Fix several doxygen warnings

diff --git a/demo/graph_to_eps_demo.cc b/demo/graph_to_eps_demo.cc

-                      a
 /// graphToEps(), and showing how to draw directed graphs,
 /// how to handle parallel egdes, how to change the properties (like
 /// color, shape, size, title etc.) of nodes and arcs individually
 /// using appropriate \ref maps-page "graph maps".
+/// using appropriate graph maps.
 ///
 /// \include graph_to_eps_demo.cc

doc/lgf.dox

diff --git a/doc/lgf.dox b/doc/lgf.dox

-                      a
    3   18
 \endcode
 The \c \@edges is just a synonym of \c \@arcs. The @arcs section can
+The \c \@edges is just a synonym of \c \@arcs. The \@arcs section can
 also store the edge set of an undirected graph. In such case there is
 a conventional method for store arc maps in the file, if two columns
 has the same caption with \c '+' and \c '-' prefix, then these columns

lemon/bits/alteration_notifier.h

diff --git a/lemon/bits/alteration_notifier.h b/lemon/bits/alteration_notifier.h

-                      a
   /// observeres will not be notified and the fulfilled additions will
   /// be rolled back by calling the \e erase() or \e clear()
   /// functions. Thence the \e erase() and \e clear() should not throw
+  /// exception. Actullay, it can be throw only
+  /// \ref AlterationObserver::ImmediateDetach ImmediateDetach
+  /// exception. Actullay, it can be throw only \ref ImmediateDetach
   /// exception which detach the observer from the notifier.
   ///
   /// There are some place when the alteration observing is not completly

lemon/bits/default_map.h

diff --git a/lemon/bits/default_map.h b/lemon/bits/default_map.h

-                      a
 // #endif
   /// \e
+  /// DefaultMap class
   template <typename _Graph, typename _Item, typename _Value>
   class DefaultMap
     : public DefaultMapSelector<_Graph, _Item, _Value>::Map {

lemon/color.h

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

-                      a
   /// Dark cyan color constant
   extern const Color DARK_CYAN;
   ///Map <tt>int</tt>s to different \ref Color "Color"s
+  ///Map <tt>int</tt>s to different <tt>Color</tt>s
   ///This map assigns one of the predefined \ref Color "Color"s to
   ///each <tt>int</tt>. It is possible to change the colors as well as

lemon/concepts/graph_components.h

diff --git a/lemon/concepts/graph_components.h b/lemon/concepts/graph_components.h

-                      a
     /// \brief Class describing the concept of graph maps
     ///
     /// This class describes the common interface of the graph maps
     /// (NodeMap, ArcMap), that is \ref maps-page "maps" which can be used to
+    /// (NodeMap, ArcMap), that is maps that can be used to
     /// associate data to graph descriptors (nodes or arcs).
     template <typename _Graph, typename _Item, typename _Value>
     class GraphMap : public ReadWriteMap<_Item, _Value> {

lemon/core.h

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

-                      a
     ///\note This is a dynamic data structure, therefore the data
     ///structure is updated after each graph alteration. Thus although
     ///this data structure is theoretically faster than \ref ArcLookUp
     ///and \ref AllArcLookup, it often provides worse performance than
+    ///and \ref AllArcLookUp, it often provides worse performance than
     ///them.
     Arc operator()(Node s, Node t, Arc p = INVALID) const  {
       if (p == INVALID) {
 …
     ///Find an arc between two nodes.
     ///Find an arc between two nodes in time <em>O</em>(log<em>d</em>), where
     ///<em>d</em> is the number of outgoing arcs of \c s.
+    ///Find an arc between two nodes in time <em>O</em>(log<em>d</em>),
+    ///where <em>d</em> is the number of outgoing arcs of \c s.
     ///\param s The source node.
     ///\param t The target node.
     ///\return An arc from \c s to \c t if there exists,
 …
     ///for(Arc a = ae(u,v); a != INVALID; a=ae(u,v,a)) n++;
     ///\endcode
     ///
     ///Finding the first arc take <em>O</em>(log<em>d</em>) time, where
     ///<em>d</em> is the number of outgoing arcs of \c s. Then, the
+    ///Finding the first arc take <em>O</em>(log<em>d</em>) time,
+    ///where <em>d</em> is the number of outgoing arcs of \c s. Then the
     ///consecutive arcs are found in constant time.
     ///
     ///\warning If you change the digraph, refresh() must be called before using

lemon/dfs.h

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

-                      a
     typedef lemon::Path<Digraph> Path;
   };
   /// Default traits class used by \ref DfsWizard
+  /// Default traits class used by DfsWizard
   /// To make it easier to use Dfs algorithm
   /// we have created a wizard class.

lemon/dijkstra.h

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

-                      a
     };
     /// \brief \ref named-templ-param "Named parameter" for setting
     ///\ref OperationTraits type
+    ///\c OperationTraits type
     ///
     ///\ref named-templ-param "Named parameter" for setting
     ///\ref OperationTraits type.
 …
     typedef lemon::Path<Digraph> Path;
   };
   /// Default traits class used by \ref DijkstraWizard
+  /// Default traits class used by DijkstraWizard
   /// To make it easier to use Dijkstra algorithm
   /// we have created a wizard class.

lemon/dim2.h

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

-                      a
   /// Bounding box of plain vectors (\ref Point points).
+  /// Bounding box of plain vectors (points).
   /// A class to calculate or store the bounding box of plain vectors
   /// (\ref Point points).
+  /// (\ref Point "points").
   template<typename T>
   class Box {
       Point<T> _bottom_left, _top_right;
 …
     return os;
+  }
   ///Map of x-coordinates of a \ref Point "Point"-map
+  ///Map of x-coordinates of a <tt>Point</tt>-map
+  ///Map of x-coordinates of a \ref Point "Point"-map.
   ///\ingroup maps
-  ///Map of x-coordinates of a \ref Point "Point"-map.
-  ///
   template<class M>
   class XMap
+  {
 …
     void set(Key k,Value v) {_map.set(k,typename M::Value(v,_map[k].y));}
   };
   ///Returns an \ref XMap class
+  ///Returns an XMap class
   ///This function just returns an \ref XMap class.
+  ///This function just returns an XMap class.
   ///
   ///\ingroup maps
   ///\relates XMap
 …
     return XMap<M>(m);
+  }
   ///Constant (read only) version of \ref XMap
+  ///Constant (read only) version of XMap
+  ///Constant (read only) version of XMap.
   ///\ingroup maps
-  ///Constant (read only) version of \ref XMap
-  ///
   template<class M>
   class ConstXMap
+  {
 …
     Value operator[](Key k) const {return _map[k].x;}
   };
   ///Returns a \ref ConstXMap class
+  ///Returns a ConstXMap class
   ///This function just returns a \ref ConstXMap class.
+  ///This function just returns a ConstXMap class.
   ///
   ///\ingroup maps
   ///\relates ConstXMap
 …
     return ConstXMap<M>(m);
+  }
   ///Map of y-coordinates of a \ref Point "Point"-map
+  ///Map of y-coordinates of a <tt>Point</tt>-map
+  ///Map of y-coordinates of a \ref Point "Point"-map.
   ///\ingroup maps
-  ///Map of y-coordinates of a \ref Point "Point"-map.
-  ///
   template<class M>
   class YMap
+  {
 …
     void set(Key k,Value v) {_map.set(k,typename M::Value(_map[k].x,v));}
   };
   ///Returns a \ref YMap class
+  ///Returns a YMap class
   ///This function just returns a \ref YMap class.
+  ///This function just returns a YMap class.
   ///
   ///\ingroup maps
   ///\relates YMap
 …
     return YMap<M>(m);
+  }
   ///Constant (read only) version of \ref YMap
+  ///Constant (read only) version of YMap
+  ///Constant (read only) version of YMap.
   ///\ingroup maps
-  ///Constant (read only) version of \ref YMap
-  ///
   template<class M>
   class ConstYMap
+  {
 …
     Value operator[](Key k) const {return _map[k].y;}
   };
   ///Returns a \ref ConstYMap class
+  ///Returns a ConstYMap class
   ///This function just returns a \ref ConstYMap class.
+  ///This function just returns a ConstYMap class.
   ///
   ///\ingroup maps
   ///\relates ConstYMap
 …
+  }
+  ///\brief Map of the \ref Point::normSquare() "normSquare()"
+  ///of a \ref Point "Point"-map
+  ///\brief Map of the normSquare() of a <tt>Point</tt>-map
   ///
   ///Map of the \ref Point::normSquare() "normSquare()"
   ///of a \ref Point "Point"-map.
 …
     Value operator[](Key k) const {return _map[k].normSquare();}
   };
   ///Returns a \ref NormSquareMap class
+  ///Returns a NormSquareMap class
   ///This function just returns a \ref NormSquareMap class.
+  ///This function just returns a NormSquareMap class.
   ///
   ///\ingroup maps
   ///\relates NormSquareMap

lemon/graph_to_eps.h

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

-                      a
     };
+  }
 ///Default traits class of \ref GraphToEps
+///Default traits class of GraphToEps
 ///Default traits class of \ref GraphToEps.
 ///

lemon/list_graph.h

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

-                      a
     /// Change the source of \c a to \c n
     ///
     ///\note The <tt>InArcIt</tt>s referencing the changed arc remain
     ///valid. However the <tt>ArcIt<tt>s and <tt>OutArcIt</tt>s are
+    ///valid. However the <tt>ArcIt</tt>s and <tt>OutArcIt</tt>s are
     ///invalidated.
     ///
     ///\warning This functionality cannot be used together with the Snapshot

lemon/maps.h

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

-                      a
   template<typename K, typename V>
   class MapBase {
   public:
     /// \biref The key type of the map.
+    /// \brief The key type of the map.
     typedef K Key;
     /// \brief The value type of the map.
     /// (The type of objects associated with the keys).
 …
     /// \brief Constructor
     ///
     /// Constructor
     /// \param _digraph The digraph that the map belongs to.
+    /// \param digraph The digraph that the map belongs to.
     explicit SourceMap(const Digraph& digraph) : _digraph(digraph) {}
     /// \brief The subscript operator.
 …
     /// \brief Constructor
     ///
     /// Constructor
     /// \param _digraph The digraph that the map belongs to.
+    /// \param digraph The digraph that the map belongs to.
     explicit TargetMap(const Digraph& digraph) : _digraph(digraph) {}
     /// \brief The subscript operator.
 …
     /// \brief Constructor
     ///
     /// Constructor
     /// \param _graph The graph that the map belongs to.
+    /// \param graph The graph that the map belongs to.
     explicit ForwardMap(const Graph& graph) : _graph(graph) {}
     /// \brief The subscript operator.
 …
     /// \brief Constructor
     ///
     /// Constructor
     /// \param _graph The graph that the map belongs to.
+    /// \param graph The graph that the map belongs to.
     explicit BackwardMap(const Graph& graph) : _graph(graph) {}
     /// \brief The subscript operator.

lemon/path.h

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

-                      a
     /// \brief Return true when the path is empty.
     int empty() const { return len == 0; }
     /// \break Erase all arcs in the digraph.
+    /// \brief Erase all arcs in the digraph.
     void clear() {
       len = 0;
       if (arcs) delete[] arcs;

lemon/smart_graph.h

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

-                      a
       ///Constructor that immediately makes a snapshot
       ///This constructor immediately makes a snapshot of the digraph.
       ///\param _g The digraph we make a snapshot of.
+      ///\param graph The digraph we make a snapshot of.
       Snapshot(SmartDigraph &graph) : _graph(&graph) {
         node_num=_graph->nodes.size();
         arc_num=_graph->arcs.size();
 …
       ///
       ///This function can be called more than once. In case of a repeated
       ///call, the previous snapshot gets lost.
       ///\param _g The digraph we make the snapshot of.
+      ///\param graph The digraph we make the snapshot of.
       void save(SmartDigraph &graph)
+      {
         _graph=&graph;
 …
       ///Constructor that immediately makes a snapshot
       ///This constructor immediately makes a snapshot of the digraph.
       ///\param g The digraph we make a snapshot of.
+      ///\param graph The digraph we make a snapshot of.
       Snapshot(SmartGraph &graph) {
         graph.saveSnapshot(*this);
+      }
 …
       ///
       ///This function can be called more than once. In case of a repeated
       ///call, the previous snapshot gets lost.
       ///\param g The digraph we make the snapshot of.
+      ///\param graph The digraph we make the snapshot of.
       void save(SmartGraph &graph)
+      {
         graph.saveSnapshot(*this);

lemon/time_measure.h

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

-                      a
     ///\name Control the state of the timer
     ///Basically a Timer can be either running or stopped,
     ///but it provides a bit finer control on the execution.
     ///The \ref Timer also counts the number of \ref start()
     ///executions, and is stops only after the same amount (or more)
     ///\ref stop() "stop()"s. This can be useful e.g. to compute
     ///the running time
+    ///The \ref lemon::Timer "Timer" also counts the number of
+    ///\ref lemon::Timer::start() "start()" executions, and it stops
+    ///only after the same amount (or more) \ref lemon::Timer::stop()
+    ///"stop()"s. This can be useful e.g. to compute the running time
     ///of recursive functions.
-    ///
     ///@{
 …
     ///@}
   };
   ///Same as \ref Timer but prints a report on destruction.
+  ///Same as Timer but prints a report on destruction.
   ///Same as \ref Timer but prints a report on destruction.
   ///This example shows its usage.
 …
     std::string _title;
     std::ostream &_os;
   public:
     ///\e
+    ///Constructor
+    ///Constructor.
     ///\param title This text will be printed before the ellapsed time.
     ///\param os The stream to print the report to.
     ///\param run Sets whether the timer should start immediately.
     TimeReport(std::string title,std::ostream &os=std::cerr,bool run=true)
       : Timer(run), _title(title), _os(os){}
     ///\e Prints the ellapsed time on destruction.
+    ///Destructor that prints the ellapsed time
     ~TimeReport()
+    {
       _os << _title << *this << std::endl;
+    }
   };
   ///'Do nothing' version of \ref TimeReport
+  ///'Do nothing' version of TimeReport
   ///\sa TimeReport
   ///

Context Navigation

Ticket #119: 64f8f7cc6168.patch

demo/graph_to_eps_demo.cc

doc/lgf.dox

lemon/bits/alteration_notifier.h

lemon/bits/default_map.h

lemon/color.h

lemon/concepts/graph_components.h

lemon/core.h

lemon/dfs.h

lemon/dijkstra.h

lemon/dim2.h

lemon/graph_to_eps.h

lemon/list_graph.h

lemon/maps.h

lemon/path.h

lemon/smart_graph.h

lemon/time_measure.h

Download in other formats: