LEMON/LEMON-official Changeset - r313:64f8f7cc6168

Repositories » LEMON » LEMON-official

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

Changeset - r313:64f8f7cc6168

« 309:e57e10

314:2cc608 »

r313:64f8f7cc6168

Thu, 09 Oct 2008 10:09:44

[Not Reviewed]

0 comments (0 inline)

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

Fix several doxygen warnings

0 16 0

default

16 files changed with 56 insertions and 63 deletions:

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

↑ Collapse diff ↑

demo/graph_to_eps_demo.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		/// \ingroup demos
 		/// \file
 		/// \brief Demo of the graph drawing function \ref graphToEps()
 		///
 		/// This demo program shows examples how to use the function \ref
 		/// graphToEps(). It takes no input but simply creates seven
 		/// <tt>.eps</tt> files demonstrating the capability of \ref
 		/// 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
 		#include<lemon/list_graph.h>
 		#include<lemon/graph_to_eps.h>
 		#include<lemon/math.h>
 		using namespace std;
 		using namespace lemon;
 		int main()
+		{
 		  Palette palette;
 		  Palette paletteW(true);
 		  // Create a small digraph
 		  ListDigraph g;
 		  typedef ListDigraph::Node Node;
 		  typedef ListDigraph::NodeIt NodeIt;
 		  typedef ListDigraph::Arc Arc;
 		  typedef dim2::Point<int> Point;
 		  Node n1=g.addNode();
 		  Node n2=g.addNode();
 		  Node n3=g.addNode();
 		  Node n4=g.addNode();
 		  Node n5=g.addNode();
 		  ListDigraph::NodeMap<Point> coords(g);
 		  ListDigraph::NodeMap<double> sizes(g);
 		  ListDigraph::NodeMap<int> colors(g);
 		  ListDigraph::NodeMap<int> shapes(g);
 		  ListDigraph::ArcMap<int> acolors(g);
 		  ListDigraph::ArcMap<int> widths(g);
 		  coords[n1]=Point(50,50);  sizes[n1]=1; colors[n1]=1; shapes[n1]=0;
 		  coords[n2]=Point(50,70);  sizes[n2]=2; colors[n2]=2; shapes[n2]=2;
 		  coords[n3]=Point(70,70);  sizes[n3]=1; colors[n3]=3; shapes[n3]=0;
 		  coords[n4]=Point(70,50);  sizes[n4]=2; colors[n4]=4; shapes[n4]=1;
 		  coords[n5]=Point(85,60);  sizes[n5]=3; colors[n5]=5; shapes[n5]=2;
 		  Arc a;
 		  a=g.addArc(n1,n2); acolors[a]=0; widths[a]=1;
 		  a=g.addArc(n2,n3); acolors[a]=0; widths[a]=1;
 		  a=g.addArc(n3,n5); acolors[a]=0; widths[a]=3;
 		  a=g.addArc(n5,n4); acolors[a]=0; widths[a]=1;
 		  a=g.addArc(n4,n1); acolors[a]=0; widths[a]=1;
 		  a=g.addArc(n2,n4); acolors[a]=1; widths[a]=2;
 		  a=g.addArc(n3,n4); acolors[a]=2; widths[a]=1;
 		  IdMap<ListDigraph,Node> id(g);
 		  // Create .eps files showing the digraph with different options
 		  cout << "Create 'graph_to_eps_demo_out_1_pure.eps'" << endl;
 		  graphToEps(g,"graph_to_eps_demo_out_1_pure.eps").
 		    coords(coords).
 		    title("Sample .eps figure").
 		    copyright("(C) 2003-2008 LEMON Project").
 		    run();
 		  cout << "Create 'graph_to_eps_demo_out_2.eps'" << endl;
 		  graphToEps(g,"graph_to_eps_demo_out_2.eps").
 		    coords(coords).

doc/lgf.dox

Show inline comments

@@ -17,91 +17,91 @@
 		 */
 		namespace lemon {
 		/*!
 		\page lgf-format LEMON Graph Format (LGF)
 		The \e LGF is a <em>column oriented</em>
 		file format for storing graphs and associated data like
 		node and edge maps.
 		Each line with \c '#' first non-whitespace
 		character is considered as a comment line.
 		Otherwise the file consists of sections starting with
 		a header line. The header lines starts with an \c '@' character followed by the
 		type of section. The standard section types are \c \@nodes, \c
 		\@arcs and \c \@edges
 		and \@attributes. Each header line may also have an optional
 		\e name, which can be use to distinguish the sections of the same
 		type.
 		The standard sections are column oriented, each line consists of
 		<em>token</em>s separated by whitespaces. A token can be \e plain or
 		\e quoted. A plain token is just a sequence of non-whitespace characters,
 		while a quoted token is a
 		character sequence surrounded by double quotes, and it can also
 		contain whitespaces and escape sequences.
 		The \c \@nodes section describes a set of nodes and associated
 		maps. The first is a header line, its columns are the names of the
 		maps appearing in the following lines.
 		One of the maps must be called \c
 		"label", which plays special role in the file.
 		The following
 		non-empty lines until the next section describes nodes of the
 		graph. Each line contains the values of the node maps
 		associated to the current node.
 		\code
 		 @nodes
 		 label  coordinates  size    title
 (10,20)      10      "First node"
 (80,80)      8       "Second node"
 (40,10)      10      "Third node"
 		\endcode
 		The \c \@arcs section is very similar to the \c \@nodes section,
 		it again starts with a header line describing the names of the maps,
 		but the \c "label" map is not obligatory here. The following lines
 		describe the arcs. The first two tokens of each line are
 		the source and the target node of the arc, respectively, then come the map
 		values. The source and target tokens must be node labels.
 		\code
 		 @arcs
 		         capacity
 2   16
 3   12
 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
 		can be regarded as the values of an arc map.
 		The \c \@attributes section contains key-value pairs, each line
 		consists of two tokens, an attribute name, and then an attribute
 		value. The value of the attribute could be also a label value of a
 		node or an edge, or even an edge label prefixed with \c '+' or \c '-',
 		which regards to the forward or backward directed arc of the
 		corresponding edge.
 		\code
 		 @attributes
 		 source 1
 		 target 3
 		 caption "LEMON test digraph"
 		\endcode
 		The \e LGF can contain extra sections, but there is no restriction on
 		the format of such sections.
 		*/
+		}
 		//  LocalWords:  whitespace whitespaces

lemon/bits/alteration_notifier.h

Show inline comments

@@ -18,130 +18,129 @@
 		#ifndef LEMON_BITS_ALTERATION_NOTIFIER_H
 		#define LEMON_BITS_ALTERATION_NOTIFIER_H
 		#include <vector>
 		#include <list>
 		#include <lemon/core.h>
 		///\ingroup graphbits
 		///\file
 		///\brief Observer notifier for graph alteration observers.
 		namespace lemon {
 		  /// \ingroup graphbits
 		  ///
 		  /// \brief Notifier class to notify observes about alterations in
 		  /// a container.
 		  ///
 		  /// The simple graph's can be refered as two containers, one node container
 		  /// and one edge container. But they are not standard containers they
 		  /// does not store values directly they are just key continars for more
 		  /// value containers which are the node and edge maps.
 		  ///
 		  /// The graph's node and edge sets can be changed as we add or erase
 		  /// nodes and edges in the graph. LEMON would like to handle easily
 		  /// that the node and edge maps should contain values for all nodes or
 		  /// edges. If we want to check on every indicing if the map contains
 		  /// the current indicing key that cause a drawback in the performance
 		  /// in the library. We use another solution we notify all maps about
 		  /// an alteration in the graph, which cause only drawback on the
 		  /// alteration of the graph.
 		  ///
 		  /// This class provides an interface to the container. The \e first() and \e
 		  /// next() member functions make possible to iterate on the keys of the
 		  /// container. The \e id() function returns an integer id for each key.
 		  /// The \e maxId() function gives back an upper bound of the ids.
 		  ///
 		  /// For the proper functonality of this class, we should notify it
 		  /// about each alteration in the container. The alterations have four type
 		  /// as \e add(), \e erase(), \e build() and \e clear(). The \e add() and
 		  /// \e erase() signals that only one or few items added or erased to or
 		  /// from the graph. If all items are erased from the graph or from an empty
 		  /// graph a new graph is builded then it can be signaled with the
 		  /// clear() and build() members. Important rule that if we erase items
 		  /// from graph we should first signal the alteration and after that erase
 		  /// them from the container, on the other way on item addition we should
 		  /// first extend the container and just after that signal the alteration.
 		  ///
 		  /// The alteration can be observed with a class inherited from the
 		  /// \e ObserverBase nested class. The signals can be handled with
 		  /// overriding the virtual functions defined in the base class.  The
 		  /// observer base can be attached to the notifier with the
 		  /// \e attach() member and can be detached with detach() function. The
 		  /// alteration handlers should not call any function which signals
 		  /// an other alteration in the same notifier and should not
 		  /// detach any observer from the notifier.
 		  ///
 		  /// Alteration observers try to be exception safe. If an \e add() or
 		  /// a \e clear() function throws an exception then the remaining
 		  /// 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
 		  /// reliable. If we want to carry out the node degree in the graph
 		  /// as in the \ref InDegMap and we use the reverseEdge that cause
 		  /// unreliable functionality. Because the alteration observing signals
 		  /// only erasing and adding but not the reversing it will stores bad
 		  /// degrees. The sub graph adaptors cannot signal the alterations because
 		  /// just a setting in the filter map can modify the graph and this cannot
 		  /// be watched in any way.
 		  ///
 		  /// \param _Container The container which is observed.
 		  /// \param _Item The item type which is obserbved.
 		  template <typename _Container, typename _Item>
 		  class AlterationNotifier {
 		  public:
 		    typedef True Notifier;
 		    typedef _Container Container;
 		    typedef _Item Item;
 		    /// \brief Exception which can be called from \e clear() and
 		    /// \e erase().
 		    ///
 		    /// From the \e clear() and \e erase() function only this
 		    /// exception is allowed to throw. The exception immediatly
 		    /// detaches the current observer from the notifier. Because the
 		    /// \e clear() and \e erase() should not throw other exceptions
 		    /// it can be used to invalidate the observer.
 		    struct ImmediateDetach {};
 		    /// \brief ObserverBase is the base class for the observers.
 		    ///
 		    /// ObserverBase is the abstract base class for the observers.
 		    /// It will be notified about an item was inserted into or
 		    /// erased from the graph.
 		    ///
 		    /// The observer interface contains some pure virtual functions
 		    /// to override. The add() and erase() functions are
 		    /// to notify the oberver when one item is added or
 		    /// erased.
 		    ///
 		    /// The build() and clear() members are to notify the observer
 		    /// about the container is built from an empty container or
 		    /// is cleared to an empty container.
 		    class ObserverBase {
 		    protected:
 		      typedef AlterationNotifier Notifier;
 		      friend class AlterationNotifier;
 		      /// \brief Default constructor.
 		      ///
 		      /// Default constructor for ObserverBase.
 		      ///
 		      ObserverBase() : _notifier(0) {}
 		      /// \brief Constructor which attach the observer into notifier.
 		      ///
 		      /// Constructor which attach the observer into notifier.
 		      ObserverBase(AlterationNotifier& nf) {

lemon/bits/default_map.h

Show inline comments

@@ -88,94 +88,94 @@
 		  // long
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, signed long> {
 		    typedef VectorMap<_Graph, _Item, signed long> Map;
 		  };
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, unsigned long> {
 		    typedef VectorMap<_Graph, _Item, unsigned long> Map;
 		  };
 		#if defined __GNUC__ && !defined __STRICT_ANSI__
 		  // long long
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, signed long long> {
 		    typedef VectorMap<_Graph, _Item, signed long long> Map;
 		  };
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, unsigned long long> {
 		    typedef VectorMap<_Graph, _Item, unsigned long long> Map;
 		  };
 		#endif
 		  // float
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, float> {
 		    typedef VectorMap<_Graph, _Item, float> Map;
 		  };
 		  // double
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, double> {
 		    typedef VectorMap<_Graph, _Item,  double> Map;
 		  };
 		  // long double
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, long double> {
 		    typedef VectorMap<_Graph, _Item, long double> Map;
 		  };
 		  // pointer
 		  template <typename _Graph, typename _Item, typename _Ptr>
 		  struct DefaultMapSelector<_Graph, _Item, _Ptr*> {
 		    typedef VectorMap<_Graph, _Item, _Ptr*> Map;
 		  };
 		// #else
 		//   template <typename _Graph, typename _Item, typename _Value>
 		//   struct DefaultMapSelector {
 		//     typedef DebugMap<_Graph, _Item, _Value> Map;
 		//   };
 		// #endif
-		  /// \e
+		  /// DefaultMap class
 		  template <typename _Graph, typename _Item, typename _Value>
 		  class DefaultMap
 		    : public DefaultMapSelector<_Graph, _Item, _Value>::Map {
 		  public:
 		    typedef typename DefaultMapSelector<_Graph, _Item, _Value>::Map Parent;
 		    typedef DefaultMap<_Graph, _Item, _Value> Map;
 		    typedef typename Parent::Graph Graph;
 		    typedef typename Parent::Value Value;
 		    explicit DefaultMap(const Graph& graph) : Parent(graph) {}
 		    DefaultMap(const Graph& graph, const Value& value)
 		      : Parent(graph, value) {}
 		    DefaultMap& operator=(const DefaultMap& cmap) {
 		      return operator=<DefaultMap>(cmap);
+		    }
 		    template <typename CMap>
 		    DefaultMap& operator=(const CMap& cmap) {
 		      Parent::operator=(cmap);
 		      return *this;
+		    }
 		  };
+		}
 		#endif

lemon/color.h

Show inline comments

@@ -31,129 +31,129 @@
 		namespace lemon {
 		  /// \addtogroup misc
 		  /// @{
 		  ///Data structure representing RGB colors.
 		  ///Data structure representing RGB colors.
 		  class Color
+		  {
 		    double _r,_g,_b;
 		  public:
 		    ///Default constructor
 		    Color() {}
 		    ///Constructor
 		    Color(double r,double g,double b) :_r(r),_g(g),_b(b) {};
 		    ///Set the red component
 		    double & red() {return _r;}
 		    ///Return the red component
 		    const double & red() const {return _r;}
 		    ///Set the green component
 		    double & green() {return _g;}
 		    ///Return the green component
 		    const double & green() const {return _g;}
 		    ///Set the blue component
 		    double & blue() {return _b;}
 		    ///Return the blue component
 		    const double & blue() const {return _b;}
 		    ///Set the color components
 		    void set(double r,double g,double b) { _r=r;_g=g;_b=b; };
 		  };
 		  /// White color constant
 		  extern const Color WHITE;
 		  /// Black color constant
 		  extern const Color BLACK;
 		  /// Red color constant
 		  extern const Color RED;
 		  /// Green color constant
 		  extern const Color GREEN;
 		  /// Blue color constant
 		  extern const Color BLUE;
 		  /// Yellow color constant
 		  extern const Color YELLOW;
 		  /// Magenta color constant
 		  extern const Color MAGENTA;
 		  /// Cyan color constant
 		  extern const Color CYAN;
 		  /// Grey color constant
 		  extern const Color GREY;
 		  /// Dark red color constant
 		  extern const Color DARK_RED;
 		  /// Dark green color constant
 		  extern const Color DARK_GREEN;
 		  /// Drak blue color constant
 		  extern const Color DARK_BLUE;
 		  /// Dark yellow color constant
 		  extern const Color DARK_YELLOW;
 		  /// Dark magenta color constant
 		  extern const Color DARK_MAGENTA;
 		  /// 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
 		  ///their number. The integer range is cyclically mapped to the
 		  ///provided set of colors.
 		  ///
 		  ///This is a true \ref concepts::ReferenceMap "reference map", so
 		  ///you can also change the actual colors.
 		  class Palette : public MapBase<int,Color>
+		  {
 		    std::vector<Color> colors;
 		  public:
 		    ///Constructor
 		    ///Constructor.
 		    ///\param have_white Indicates whether white is among the
 		    ///provided initial colors (\c true) or not (\c false). If it is true,
 		    ///white will be assigned to \c 0.
 		    ///\param num The number of the allocated colors. If it is \c -1,
 		    ///the default color configuration is set up (26 color plus optionaly the
 		    ///white).  If \c num is less then 26/27 then the default color
 		    ///list is cut. Otherwise the color list is filled repeatedly with
 		    ///the default color list.  (The colors can be changed later on.)
 		    Palette(bool have_white=false,int num=-1)
+		    {
 		      if (num==0) return;
 		      do {
 		        if(have_white) colors.push_back(Color(1,1,1));
 		        colors.push_back(Color(0,0,0));
 		        colors.push_back(Color(1,0,0));
 		        colors.push_back(Color(0,1,0));
 		        colors.push_back(Color(0,0,1));
 		        colors.push_back(Color(1,1,0));
 		        colors.push_back(Color(1,0,1));
 		        colors.push_back(Color(0,1,1));
 		        colors.push_back(Color(.5,0,0));
 		        colors.push_back(Color(0,.5,0));
 		        colors.push_back(Color(0,0,.5));
 		        colors.push_back(Color(.5,.5,0));
 		        colors.push_back(Color(.5,0,.5));
 		        colors.push_back(Color(0,.5,.5));
 		        colors.push_back(Color(.5,.5,.5));
 		        colors.push_back(Color(1,.5,.5));
 		        colors.push_back(Color(.5,1,.5));
 		        colors.push_back(Color(.5,.5,1));
 		        colors.push_back(Color(1,1,.5));
 		        colors.push_back(Color(1,.5,1));
 		        colors.push_back(Color(.5,1,1));
 		        colors.push_back(Color(1,.5,0));
 		        colors.push_back(Color(.5,1,0));
 		        colors.push_back(Color(1,0,.5));
 		        colors.push_back(Color(0,1,.5));
 		        colors.push_back(Color(0,.5,1));
 		        colors.push_back(Color(.5,0,1));
 		      } while(int(colors.size())<num);
 		      if(num>=0) colors.resize(num);
+		    }
 		    ///\e
 		    Color &operator[](int i)

lemon/concepts/graph_components.h

Show inline comments

@@ -921,129 +921,129 @@
 		      struct Constraints {
 		        void constraints() {
 		          checkConcept<Base, _Digraph>();
 		          typename _Digraph::NodeNotifier& nn
 		            = digraph.notifier(typename _Digraph::Node());
 		          typename _Digraph::ArcNotifier& en
 		            = digraph.notifier(typename _Digraph::Arc());
 		          ignore_unused_variable_warning(nn);
 		          ignore_unused_variable_warning(en);
+		        }
 		        const _Digraph& digraph;
 		      };
 		    };
 		    /// \brief An empty alteration notifier undirected graph class.
 		    ///
 		    /// This class provides beside the core graph features alteration
 		    /// notifier interface for the graph structure.  This implements
 		    /// an observer-notifier pattern for each graph item. More
 		    /// obsevers can be registered into the notifier and whenever an
 		    /// alteration occured in the graph all the observers will
 		    /// notified about it.
 		    template <typename _Base = BaseGraphComponent>
 		    class AlterableGraphComponent : public AlterableDigraphComponent<_Base> {
 		    public:
 		      typedef _Base Base;
 		      typedef typename Base::Edge Edge;
 		      /// The arc observer registry.
 		      typedef AlterationNotifier<AlterableGraphComponent, Edge>
 		      EdgeNotifier;
 		      /// \brief Gives back the arc alteration notifier.
 		      ///
 		      /// Gives back the arc alteration notifier.
 		      EdgeNotifier& notifier(Edge) const {
 		        return EdgeNotifier();
+		      }
 		      template <typename _Graph>
 		      struct Constraints {
 		        void constraints() {
 		          checkConcept<AlterableGraphComponent<Base>, _Graph>();
 		          typename _Graph::EdgeNotifier& uen
 		            = graph.notifier(typename _Graph::Edge());
 		          ignore_unused_variable_warning(uen);
+		        }
 		        const _Graph& graph;
 		      };
 		    };
 		    /// \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> {
 		    public:
 		      typedef ReadWriteMap<_Item, _Value> Parent;
 		      /// The graph type of the map.
 		      typedef _Graph Graph;
 		      /// The key type of the map.
 		      typedef _Item Key;
 		      /// The value type of the map.
 		      typedef _Value Value;
 		      /// \brief Construct a new map.
 		      ///
 		      /// Construct a new map for the graph.
 		      explicit GraphMap(const Graph&) {}
 		      /// \brief Construct a new map with default value.
 		      ///
 		      /// Construct a new map for the graph and initalise the values.
 		      GraphMap(const Graph&, const Value&) {}
 		    private:
 		      /// \brief Copy constructor.
 		      ///
 		      /// Copy Constructor.
 		      GraphMap(const GraphMap&) : Parent() {}
 		      /// \brief Assign operator.
 		      ///
 		      /// Assign operator. It does not mofify the underlying graph,
 		      /// it just iterates on the current item set and set the  map
 		      /// with the value returned by the assigned map.
 		      template <typename CMap>
 		      GraphMap& operator=(const CMap&) {
 		        checkConcept<ReadMap<Key, Value>, CMap>();
 		        return *this;
+		      }
 		    public:
 		      template<typename _Map>
 		      struct Constraints {
 		        void constraints() {
 		          checkConcept<ReadWriteMap<Key, Value>, _Map >();
 		          // Construction with a graph parameter
 		          _Map a(g);
 		          // Constructor with a graph and a default value parameter
 		          _Map a2(g,t);
 		          // Copy constructor.
 		          // _Map b(c);
 		          // ReadMap<Key, Value> cmap;
 		          // b = cmap;
 		          ignore_unused_variable_warning(a);
 		          ignore_unused_variable_warning(a2);
 		          // ignore_unused_variable_warning(b);
+		        }
 		        const _Map &c;
 		        const Graph &g;
 		        const typename GraphMap::Value &t;
 		      };

lemon/core.h

Show inline comments

@@ -1493,129 +1493,129 @@
+		      }
+		    }
 		    void splay(Arc v) {
 		      while (_parent[v] != INVALID) {
 		        if (v == _left[_parent[v]]) {
 		          if (_parent[_parent[v]] == INVALID) {
 		            zig(v);
 		          } else {
 		            if (_parent[v] == _left[_parent[_parent[v]]]) {
 		              zig(_parent[v]);
 		              zig(v);
 		            } else {
 		              zig(v);
 		              zag(v);
+		            }
+		          }
 		        } else {
 		          if (_parent[_parent[v]] == INVALID) {
 		            zag(v);
 		          } else {
 		            if (_parent[v] == _left[_parent[_parent[v]]]) {
 		              zag(v);
 		              zig(v);
 		            } else {
 		              zag(_parent[v]);
 		              zag(v);
+		            }
+		          }
+		        }
+		      }
 		      _head[_g.source(v)] = v;
+		    }
 		  public:
 		    ///Find an arc between two nodes.
 		    ///Find an arc between two nodes.
 		    ///\param s The source node.
 		    ///\param t The target node.
 		    ///\param p The previous arc between \c s and \c t. It it is INVALID or
 		    ///not given, the operator finds the first appropriate arc.
 		    ///\return An arc from \c s to \c t after \c p or
 		    ///\ref INVALID if there is no more.
 		    ///
 		    ///For example, you can count the number of arcs from \c u to \c v in the
 		    ///following way.
 		    ///\code
 		    ///DynArcLookUp<ListDigraph> ae(g);
 		    ///...
 		    ///int n = 0;
 		    ///for(Arc a = ae(u,v); a != INVALID; a = ae(u,v,a)) n++;
 		    ///\endcode
 		    ///
 		    ///Finding the arcs take at most <em>O</em>(log<em>d</em>)
 		    ///amortized time, specifically, the time complexity of the lookups
 		    ///is equal to the optimal search tree implementation for the
 		    ///current query distribution in a constant factor.
 		    ///
 		    ///\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) {
 		        Arc a = _head[s];
 		        if (a == INVALID) return INVALID;
 		        Arc r = INVALID;
 		        while (true) {
 		          if (_g.target(a) < t) {
 		            if (_right[a] == INVALID) {
 		              const_cast<DynArcLookUp&>(*this).splay(a);
 		              return r;
 		            } else {
 		              a = _right[a];
+		            }
 		          } else {
 		            if (_g.target(a) == t) {
 		              r = a;
+		            }
 		            if (_left[a] == INVALID) {
 		              const_cast<DynArcLookUp&>(*this).splay(a);
 		              return r;
 		            } else {
 		              a = _left[a];
+		            }
+		          }
+		        }
 		      } else {
 		        Arc a = p;
 		        if (_right[a] != INVALID) {
 		          a = _right[a];
 		          while (_left[a] != INVALID) {
 		            a = _left[a];
+		          }
 		          const_cast<DynArcLookUp&>(*this).splay(a);
 		        } else {
 		          while (_parent[a] != INVALID && _right[_parent[a]] ==  a) {
 		            a = _parent[a];
+		          }
 		          if (_parent[a] == INVALID) {
 		            return INVALID;
 		          } else {
 		            a = _parent[a];
 		            const_cast<DynArcLookUp&>(*this).splay(a);
+		          }
+		        }
 		        if (_g.target(a) == t) return a;
 		        else return INVALID;
+		      }
+		    }
 		  };
 		  ///Fast arc look-up between given endpoints.
 		  ///Using this class, you can find an arc in a digraph from a given
 		  ///source to a given target in time <em>O</em>(log<em>d</em>),
 		  ///where <em>d</em> is the out-degree of the source node.
 		  ///
 		  ///It is not possible to find \e all parallel arcs between two nodes.
 		  ///Use \ref AllArcLookUp for this purpose.
 		  ///
 		  ///\warning This class is static, so you should call refresh() (or at
 		  ///least refresh(Node)) to refresh this data structure whenever the
 		  ///digraph changes. This is a time consuming (superlinearly proportional
@@ -1638,207 +1638,207 @@
 		    typename Digraph::template ArcMap<Arc> _left;
 		    typename Digraph::template ArcMap<Arc> _right;
 		    class ArcLess {
 		      const Digraph &g;
 		    public:
 		      ArcLess(const Digraph &_g) : g(_g) {}
 		      bool operator()(Arc a,Arc b) const
+		      {
 		        return g.target(a)<g.target(b);
+		      }
 		    };
 		  public:
 		    ///Constructor
 		    ///Constructor.
 		    ///
 		    ///It builds up the search database, which remains valid until the digraph
 		    ///changes.
 		    ArcLookUp(const Digraph &g) :_g(g),_head(g),_left(g),_right(g) {refresh();}
 		  private:
 		    Arc refreshRec(std::vector<Arc> &v,int a,int b)
+		    {
 		      int m=(a+b)/2;
 		      Arc me=v[m];
 		      _left[me] = a<m?refreshRec(v,a,m-1):INVALID;
 		      _right[me] = m<b?refreshRec(v,m+1,b):INVALID;
 		      return me;
+		    }
 		  public:
 		    ///Refresh the search data structure at a node.
 		    ///Build up the search database of node \c n.
 		    ///
 		    ///It runs in time <em>O</em>(<em>d</em> log<em>d</em>), where <em>d</em>
 		    ///is the number of the outgoing arcs of \c n.
 		    void refresh(Node n)
+		    {
 		      std::vector<Arc> v;
 		      for(OutArcIt e(_g,n);e!=INVALID;++e) v.push_back(e);
 		      if(v.size()) {
 		        std::sort(v.begin(),v.end(),ArcLess(_g));
 		        _head[n]=refreshRec(v,0,v.size()-1);
+		      }
 		      else _head[n]=INVALID;
+		    }
 		    ///Refresh the full data structure.
 		    ///Build up the full search database. In fact, it simply calls
 		    ///\ref refresh(Node) "refresh(n)" for each node \c n.
 		    ///
 		    ///It runs in time <em>O</em>(<em>m</em> log<em>D</em>), where <em>m</em> is
 		    ///the number of the arcs in the digraph and <em>D</em> is the maximum
 		    ///out-degree of the digraph.
 		    void refresh()
+		    {
 		      for(NodeIt n(_g);n!=INVALID;++n) refresh(n);
+		    }
 		    ///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,
 		    ///\ref INVALID otherwise.
 		    ///
 		    ///\warning If you change the digraph, refresh() must be called before using
 		    ///this operator. If you change the outgoing arcs of
 		    ///a single node \c n, then \ref refresh(Node) "refresh(n)" is enough.
 		    Arc operator()(Node s, Node t) const
+		    {
 		      Arc e;
 		      for(e=_head[s];
 		          e!=INVALID&&_g.target(e)!=t;
 		          e = t < _g.target(e)?_left[e]:_right[e]) ;
 		      return e;
+		    }
 		  };
 		  ///Fast look-up of all arcs between given endpoints.
 		  ///This class is the same as \ref ArcLookUp, with the addition
 		  ///that it makes it possible to find all parallel arcs between given
 		  ///endpoints.
 		  ///
 		  ///\warning This class is static, so you should call refresh() (or at
 		  ///least refresh(Node)) to refresh this data structure whenever the
 		  ///digraph changes. This is a time consuming (superlinearly proportional
 		  ///(<em>O</em>(<em>m</em> log<em>m</em>)) to the number of arcs).
 		  ///
 		  ///\tparam G The type of the underlying digraph.
 		  ///
 		  ///\sa DynArcLookUp
 		  ///\sa ArcLookUp
 		  template<class G>
 		  class AllArcLookUp : public ArcLookUp<G>
+		  {
 		    using ArcLookUp<G>::_g;
 		    using ArcLookUp<G>::_right;
 		    using ArcLookUp<G>::_left;
 		    using ArcLookUp<G>::_head;
 		    TEMPLATE_DIGRAPH_TYPEDEFS(G);
 		    typedef G Digraph;
 		    typename Digraph::template ArcMap<Arc> _next;
 		    Arc refreshNext(Arc head,Arc next=INVALID)
+		    {
 		      if(head==INVALID) return next;
 		      else {
 		        next=refreshNext(_right[head],next);
 		        _next[head]=( next!=INVALID && _g.target(next)==_g.target(head))
 		          ? next : INVALID;
 		        return refreshNext(_left[head],head);
+		      }
+		    }
 		    void refreshNext()
+		    {
 		      for(NodeIt n(_g);n!=INVALID;++n) refreshNext(_head[n]);
+		    }
 		  public:
 		    ///Constructor
 		    ///Constructor.
 		    ///
 		    ///It builds up the search database, which remains valid until the digraph
 		    ///changes.
 		    AllArcLookUp(const Digraph &g) : ArcLookUp<G>(g), _next(g) {refreshNext();}
 		    ///Refresh the data structure at a node.
 		    ///Build up the search database of node \c n.
 		    ///
 		    ///It runs in time <em>O</em>(<em>d</em> log<em>d</em>), where <em>d</em> is
 		    ///the number of the outgoing arcs of \c n.
 		    void refresh(Node n)
+		    {
 		      ArcLookUp<G>::refresh(n);
 		      refreshNext(_head[n]);
+		    }
 		    ///Refresh the full data structure.
 		    ///Build up the full search database. In fact, it simply calls
 		    ///\ref refresh(Node) "refresh(n)" for each node \c n.
 		    ///
 		    ///It runs in time <em>O</em>(<em>m</em> log<em>D</em>), where <em>m</em> is
 		    ///the number of the arcs in the digraph and <em>D</em> is the maximum
 		    ///out-degree of the digraph.
 		    void refresh()
+		    {
 		      for(NodeIt n(_g);n!=INVALID;++n) refresh(_head[n]);
+		    }
 		    ///Find an arc between two nodes.
 		    ///Find an arc between two nodes.
 		    ///\param s The source node.
 		    ///\param t The target node.
 		    ///\param prev The previous arc between \c s and \c t. It it is INVALID or
 		    ///not given, the operator finds the first appropriate arc.
 		    ///\return An arc from \c s to \c t after \c prev or
 		    ///\ref INVALID if there is no more.
 		    ///
 		    ///For example, you can count the number of arcs from \c u to \c v in the
 		    ///following way.
 		    ///\code
 		    ///AllArcLookUp<ListDigraph> ae(g);
 		    ///...
 		    ///int n = 0;
 		    ///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
 		    ///this operator. If you change the outgoing arcs of
 		    ///a single node \c n, then \ref refresh(Node) "refresh(n)" is enough.
 		    ///
 		#ifdef DOXYGEN
 		    Arc operator()(Node s, Node t, Arc prev=INVALID) const {}
 		#else
 		    using ArcLookUp<G>::operator() ;
 		    Arc operator()(Node s, Node t, Arc prev) const
+		    {
 		      return prev==INVALID?(*this)(s,t):_next[prev];
+		    }
 		#endif
 		  };
 		  /// @}
 		} //namespace lemon
 		#endif

lemon/dfs.h

Show inline comments

@@ -774,129 +774,129 @@
 		    ///\param g is the digraph, to which we would like to define the
 		    ///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 ProcessedMap.
 		    ///This function instantiates a ProcessedMap.
 		    ///\param g is the digraph, to which
 		    ///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 ReachedMap.
 		    ///This function instantiates a ReachedMap.
 		    ///\param g is the digraph, to which
 		    ///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 DistMap.
 		    ///This function instantiates a DistMap.
 		    ///\param g is the digraph, to which we would like to define
 		    ///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;
 		  };
-		  /// 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.
 		  /// This \ref DfsWizard class needs default traits,
 		  /// as well as the \ref Dfs class.
 		  /// The \ref DfsWizardBase is a class to be the default traits of the
 		  /// \ref DfsWizard class.
 		  template<class GR>
 		  class DfsWizardBase : public DfsWizardDefaultTraits<GR>
+		  {
 		    typedef DfsWizardDefaultTraits<GR> Base;
 		  protected:
 		    //The type of the nodes in the digraph.
 		    typedef typename Base::Digraph::Node Node;
 		    //Pointer to the digraph the algorithm runs on.
 		    void *_g;
 		    //Pointer to the map of reached nodes.
 		    void *_reached;
 		    //Pointer to the map of processed nodes.
 		    void *_processed;
 		    //Pointer to the map of predecessors arcs.
 		    void *_pred;
 		    //Pointer to the map of distances.
 		    void *_dist;
 		    //Pointer to the DFS path to the target node.
 		    void *_path;
 		    //Pointer to the distance of the target node.
 		    int *_di;
 		    public:
 		    /// Constructor.
 		    /// This constructor does not require parameters, therefore it initiates
 		    /// all of the attributes to \c 0.
 		    DfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0),
 		                      _dist(0), _path(0), _di(0) {}
 		    /// Constructor.
 		    /// This constructor requires one parameter,
 		    /// others are initiated to \c 0.
 		    /// \param g The digraph the algorithm runs on.
 		    DfsWizardBase(const GR &g) :
 		      _g(reinterpret_cast<void*>(const_cast<GR*>(&g))),
 		      _reached(0), _processed(0), _pred(0), _dist(0),  _path(0), _di(0) {}
 		  };
 		  /// Auxiliary class for the function-type interface of DFS algorithm.
 		  /// This auxiliary class is created to implement the
 		  /// \ref dfs() "function-type interface" of \ref Dfs algorithm.
 		  /// It does not have own \ref run() method, it uses the functions
 		  /// and features of the plain \ref Dfs.
 		  ///
 		  /// This class should only be used through the \ref dfs() function,
 		  /// which makes it easier to use the algorithm.
 		  template<class TR>
 		  class DfsWizard : public TR
+		  {
 		    typedef TR Base;

lemon/dijkstra.h

Show inline comments

@@ -392,129 +392,129 @@
 		    ///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 &) {
 		        LEMON_ASSERT(false, "HeapCrossRef is not initialized");
 		        return 0; // ignore warnings
+		      }
 		      static Heap *createHeap(HeapCrossRef &)
+		      {
 		        LEMON_ASSERT(false, "Heap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///heap and cross reference type
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting heap and cross
 		    ///reference type.
 		    template <class H, class CR = typename Digraph::template NodeMap<int> >
 		    struct SetHeap
 		      : public Dijkstra< Digraph, LengthMap, SetHeapTraits<H, CR> > {
 		      typedef Dijkstra< Digraph, LengthMap, SetHeapTraits<H, CR> > Create;
 		    };
 		    template <class H, class CR>
 		    struct SetStandardHeapTraits : public Traits {
 		      typedef CR HeapCrossRef;
 		      typedef H Heap;
 		      static HeapCrossRef *createHeapCrossRef(const Digraph &G) {
 		        return new HeapCrossRef(G);
+		      }
 		      static Heap *createHeap(HeapCrossRef &R)
+		      {
 		        return new Heap(R);
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///heap and cross reference type with automatic allocation
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting heap and cross
 		    ///reference type. It can allocate the heap and the cross reference
 		    ///object if the cross reference's constructor waits for the digraph as
 		    ///parameter and the heap's constructor waits for the cross reference.
 		    template <class H, class CR = typename Digraph::template NodeMap<int> >
 		    struct SetStandardHeap
 		      : public Dijkstra< Digraph, LengthMap, SetStandardHeapTraits<H, CR> > {
 		      typedef Dijkstra< Digraph, LengthMap, SetStandardHeapTraits<H, CR> >
 		      Create;
 		    };
 		    template <class T>
 		    struct SetOperationTraitsTraits : public Traits {
 		      typedef T OperationTraits;
 		    };
 		    /// \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.
 		    template <class T>
 		    struct SetOperationTraits
 		      : public Dijkstra<Digraph, LengthMap, SetOperationTraitsTraits<T> > {
 		      typedef Dijkstra<Digraph, LengthMap, SetOperationTraitsTraits<T> >
 		      Create;
 		    };
 		    ///@}
 		  protected:
 		    Dijkstra() {}
 		  public:
 		    ///Constructor.
 		    ///Constructor.
 		    ///\param _g The digraph the algorithm runs on.
 		    ///\param _length The length map used by the algorithm.
 		    Dijkstra(const Digraph& _g, const LengthMap& _length) :
 		      G(&_g), length(&_length),
 		      _pred(NULL), local_pred(false),
 		      _dist(NULL), local_dist(false),
 		      _processed(NULL), local_processed(false),
 		      _heap_cross_ref(NULL), local_heap_cross_ref(false),
 		      _heap(NULL), local_heap(false)
 		    { }
 		    ///Destructor.
 		    ~Dijkstra()
+		    {
 		      if(local_pred) delete _pred;
 		      if(local_dist) delete _dist;
 		      if(local_processed) delete _processed;
 		      if(local_heap_cross_ref) delete _heap_cross_ref;
 		      if(local_heap) delete _heap;
+		    }
 		    ///Sets the length map.
 		    ///Sets the length map.
 		    ///\return <tt> (*this) </tt>
 		    Dijkstra &lengthMap(const LengthMap &m)
+		    {
 		      length = &m;
 		      return *this;
+		    }
 		    ///Sets the map that stores the predecessor arcs.
 		    ///Sets the map that stores the predecessor arcs.
 		    ///If you don't use this function before calling \ref run(),
 		    ///it will allocate one. The destructor deallocates this
 		    ///automatically allocated map, of course.
 		    ///\return <tt> (*this) </tt>
 		    Dijkstra &predMap(PredMap &m)
+		    {
 		      if(local_pred) {
 		        delete _pred;
 		        local_pred=false;
@@ -977,129 +977,129 @@
 		    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 PredMap.
 		    ///This function instantiates a PredMap.
 		    ///\param g is the digraph, to which we would like to define the
 		    ///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 ProcessedMap.
 		    ///This function instantiates a ProcessedMap.
 		    ///\param g is the digraph, to which
 		    ///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 DistMap.
 		    ///This function instantiates a DistMap.
 		    ///\param g is the digraph, to which we would like to define
 		    ///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 DijkstraWizard
 		  /// Default traits class used by DijkstraWizard
 		  /// To make it easier to use Dijkstra algorithm
 		  /// we have created a wizard class.
 		  /// This \ref DijkstraWizard class needs default traits,
 		  /// as well as the \ref Dijkstra class.
 		  /// The \ref DijkstraWizardBase is a class to be the default traits of the
 		  /// \ref DijkstraWizard class.
 		  template<class GR,class LM>
 		  class DijkstraWizardBase : public DijkstraWizardDefaultTraits<GR,LM>
+		  {
 		    typedef DijkstraWizardDefaultTraits<GR,LM> Base;
 		  protected:
 		    //The type of the nodes in the digraph.
 		    typedef typename Base::Digraph::Node Node;
 		    //Pointer to the digraph the algorithm runs on.
 		    void *_g;
 		    //Pointer to the length map.
 		    void *_length;
 		    //Pointer to the map of processed nodes.
 		    void *_processed;
 		    //Pointer to the map of predecessors arcs.
 		    void *_pred;
 		    //Pointer to the map of distances.
 		    void *_dist;
 		    //Pointer to the shortest path to the target node.
 		    void *_path;
 		    //Pointer to the distance of the target node.
 		    void *_di;
 		  public:
 		    /// Constructor.
 		    /// This constructor does not require parameters, therefore it initiates
 		    /// all of the attributes to \c 0.
 		    DijkstraWizardBase() : _g(0), _length(0), _processed(0), _pred(0),
 		                           _dist(0), _path(0), _di(0) {}
 		    /// Constructor.
 		    /// This constructor requires two parameters,
 		    /// others are initiated to \c 0.
 		    /// \param g The digraph the algorithm runs on.
 		    /// \param l The length map.
 		    DijkstraWizardBase(const GR &g,const LM &l) :
 		      _g(reinterpret_cast<void*>(const_cast<GR*>(&g))),
 		      _length(reinterpret_cast<void*>(const_cast<LM*>(&l))),
 		      _processed(0), _pred(0), _dist(0), _path(0), _di(0) {}
 		  };
 		  /// Auxiliary class for the function-type interface of Dijkstra algorithm.
 		  /// This auxiliary class is created to implement the
 		  /// \ref dijkstra() "function-type interface" of \ref Dijkstra algorithm.
 		  /// It does not have own \ref run() method, it uses the functions
 		  /// and features of the plain \ref Dijkstra.
 		  ///
 		  /// This class should only be used through the \ref dijkstra() function,
 		  /// which makes it easier to use the algorithm.
 		  template<class TR>
 		  class DijkstraWizard : public TR
+		  {
 		    typedef TR Base;

lemon/dim2.h

Show inline comments

@@ -198,132 +198,132 @@
 		      is.clear();
+		    }
 		    if (!(is >> z.x)) return is;
 		    if (is >> c) {
 		      if (c != ',') is.putback(c);
 		    } else {
 		      is.clear();
+		    }
 		    if (!(is >> z.y)) return is;
 		    if (is >> c) {
 		      if (c != ')') is.putback(c);
 		    } else {
 		      is.clear();
+		    }
 		    return is;
+		  }
 		  ///Write a plain vector to a stream
 		  ///Write a plain vector to a stream.
 		  ///\relates Point
 		  ///
 		  template<typename T>
 		  inline std::ostream& operator<<(std::ostream &os, const Point<T>& z)
+		  {
 		    os << "(" << z.x << "," << z.y << ")";
 		    return os;
+		  }
 		  ///Rotate by 90 degrees
 		  ///Returns the parameter rotated by 90 degrees in positive direction.
 		  ///\relates Point
 		  ///
 		  template<typename T>
 		  inline Point<T> rot90(const Point<T> &z)
+		  {
 		    return Point<T>(-z.y,z.x);
+		  }
 		  ///Rotate by 180 degrees
 		  ///Returns the parameter rotated by 180 degrees.
 		  ///\relates Point
 		  ///
 		  template<typename T>
 		  inline Point<T> rot180(const Point<T> &z)
+		  {
 		    return Point<T>(-z.x,-z.y);
+		  }
 		  ///Rotate by 270 degrees
 		  ///Returns the parameter rotated by 90 degrees in negative direction.
 		  ///\relates Point
 		  ///
 		  template<typename T>
 		  inline Point<T> rot270(const Point<T> &z)
+		  {
 		    return Point<T>(z.y,-z.x);
+		  }
-		  /// 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;
 		      bool _empty;
 		    public:
 		      ///Default constructor: creates an empty box
 		      Box() { _empty = true; }
 		      ///Construct a box from one point
 		      Box(Point<T> a) {
 		        _bottom_left = _top_right = a;
 		        _empty = false;
+		      }
 		      ///Construct a box from two points
 		      ///Construct a box from two points.
 		      ///\param a The bottom left corner.
 		      ///\param b The top right corner.
 		      ///\warning The coordinates of the bottom left corner must be no more
 		      ///than those of the top right one.
 		      Box(Point<T> a,Point<T> b)
+		      {
 		        _bottom_left = a;
 		        _top_right = b;
 		        _empty = false;
+		      }
 		      ///Construct a box from four numbers
 		      ///Construct a box from four numbers.
 		      ///\param l The left side of the box.
 		      ///\param b The bottom of the box.
 		      ///\param r The right side of the box.
 		      ///\param t The top of the box.
 		      ///\warning The left side must be no more than the right side and
 		      ///bottom must be no more than the top.
 		      Box(T l,T b,T r,T t)
+		      {
 		        _bottom_left=Point<T>(l,b);
 		        _top_right=Point<T>(r,t);
 		        _empty = false;
+		      }
 		      ///Return \c true if the box is empty.
 		      ///Return \c true if the box is empty (i.e. return \c false
 		      ///if at least one point was added to the box or the coordinates of
 		      ///the box were set).
 		      ///
 		      ///The coordinates of an empty box are not defined.
 		      bool empty() const {
 		        return _empty;
+		      }
 		      ///Make the box empty
 		      void clear() {
 		        _empty = true;
+		      }
 		      ///Give back the bottom left corner of the box
 		      ///Give back the bottom left corner of the box.
@@ -512,237 +512,232 @@
 		      ///Intersection of two boxes
 		      ///Intersection of two boxes.
 		      ///
 		      Box operator&(const Box& u) const {
 		        Box b;
 		        if (_empty || u._empty) {
 		          b._empty = true;
 		        } else {
 		          b._bottom_left.x = std::max(_bottom_left.x, u._bottom_left.x);
 		          b._bottom_left.y = std::max(_bottom_left.y, u._bottom_left.y);
 		          b._top_right.x = std::min(_top_right.x, u._top_right.x);
 		          b._top_right.y = std::min(_top_right.y, u._top_right.y);
 		          b._empty = b._bottom_left.x > b._top_right.x ||
 		                     b._bottom_left.y > b._top_right.y;
+		        }
 		        return b;
+		      }
 		  };//class Box
 		  ///Read a box from a stream
 		  ///Read a box from a stream.
 		  ///\relates Box
 		  template<typename T>
 		  inline std::istream& operator>>(std::istream &is, Box<T>& b) {
 		    char c;
 		    Point<T> p;
 		    if (is >> c) {
 		      if (c != '(') is.putback(c);
 		    } else {
 		      is.clear();
+		    }
 		    if (!(is >> p)) return is;
 		    b.bottomLeft(p);
 		    if (is >> c) {
 		      if (c != ',') is.putback(c);
 		    } else {
 		      is.clear();
+		    }
 		    if (!(is >> p)) return is;
 		    b.topRight(p);
 		    if (is >> c) {
 		      if (c != ')') is.putback(c);
 		    } else {
 		      is.clear();
+		    }
 		    return is;
+		  }
 		  ///Write a box to a stream
 		  ///Write a box to a stream.
 		  ///\relates Box
 		  template<typename T>
 		  inline std::ostream& operator<<(std::ostream &os, const Box<T>& b)
+		  {
 		    os << "(" << b.bottomLeft() << "," << b.topRight() << ")";
 		    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
+		  {
 		    M& _map;
 		  public:
 		    typedef typename M::Value::Value Value;
 		    typedef typename M::Key Key;
 		    ///\e
 		    XMap(M& map) : _map(map) {}
 		    Value operator[](Key k) const {return _map[k].x;}
 		    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
 		  template<class M>
 		  inline XMap<M> xMap(M &m)
+		  {
 		    return XMap<M>(m);
+		  }
 		  template<class M>
 		  inline XMap<M> xMap(const M &m)
+		  {
 		    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
+		  {
 		    const M& _map;
 		  public:
 		    typedef typename M::Value::Value Value;
 		    typedef typename M::Key Key;
 		    ///\e
 		    ConstXMap(const M &map) : _map(map) {}
 		    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
 		  template<class M>
 		  inline ConstXMap<M> xMap(const M &m)
+		  {
 		    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
+		  {
 		    M& _map;
 		  public:
 		    typedef typename M::Value::Value Value;
 		    typedef typename M::Key Key;
 		    ///\e
 		    YMap(M& map) : _map(map) {}
 		    Value operator[](Key k) const {return _map[k].y;}
 		    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
 		  template<class M>
 		  inline YMap<M> yMap(M &m)
+		  {
 		    return YMap<M>(m);
+		  }
 		  template<class M>
 		  inline YMap<M> yMap(const M &m)
+		  {
 		    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
+		  {
 		    const M& _map;
 		  public:
 		    typedef typename M::Value::Value Value;
 		    typedef typename M::Key Key;
 		    ///\e
 		    ConstYMap(const M &map) : _map(map) {}
 		    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
 		  template<class M>
 		  inline ConstYMap<M> yMap(const M &m)
+		  {
 		    return ConstYMap<M>(m);
+		  }
 		  ///\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.
 		  ///\ingroup maps
 		  template<class M>
 		  class NormSquareMap
+		  {
 		    const M& _map;
 		  public:
 		    typedef typename M::Value::Value Value;
 		    typedef typename M::Key Key;
 		    ///\e
 		    NormSquareMap(const M &map) : _map(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
 		  template<class M>
 		  inline NormSquareMap<M> normSquareMap(const M &m)
+		  {
 		    return NormSquareMap<M>(m);
+		  }
 		  /// @}
 		  } //namespce dim2
 		} //namespace lemon
 		#endif //LEMON_DIM2_H

lemon/graph_to_eps.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_GRAPH_TO_EPS_H
 		#define LEMON_GRAPH_TO_EPS_H
 		#include<iostream>
 		#include<fstream>
 		#include<sstream>
 		#include<algorithm>
 		#include<vector>
 		#ifndef WIN32
 		#include<sys/time.h>
 		#include<ctime>
 		#else
 		#define WIN32_LEAN_AND_MEAN
 		#define NOMINMAX
 		#include<windows.h>
 		#endif
 		#include<lemon/math.h>
 		#include<lemon/core.h>
 		#include<lemon/dim2.h>
 		#include<lemon/maps.h>
 		#include<lemon/color.h>
 		#include<lemon/bits/bezier.h>
 		#include<lemon/error.h>
 		///\ingroup eps_io
 		///\file
 		///\brief A well configurable tool for visualizing graphs
 		namespace lemon {
 		  namespace _graph_to_eps_bits {
 		    template<class MT>
 		    class _NegY {
 		    public:
 		      typedef typename MT::Key Key;
 		      typedef typename MT::Value Value;
 		      const MT &map;
 		      int yscale;
 		      _NegY(const MT &m,bool b) : map(m), yscale(1-b*2) {}
 		      Value operator[](Key n) { return Value(map[n].x,map[n].y*yscale);}
 		    };
+		  }
-		///Default traits class of \ref GraphToEps
 		///Default traits class of GraphToEps
 		///Default traits class of \ref GraphToEps.
 		///
 		///\c G is the type of the underlying graph.
 		template<class G>
 		struct DefaultGraphToEpsTraits
+		{
 		  typedef G Graph;
 		  typedef typename Graph::Node Node;
 		  typedef typename Graph::NodeIt NodeIt;
 		  typedef typename Graph::Arc Arc;
 		  typedef typename Graph::ArcIt ArcIt;
 		  typedef typename Graph::InArcIt InArcIt;
 		  typedef typename Graph::OutArcIt OutArcIt;
 		  const Graph &g;
 		  std::ostream& os;
 		  typedef ConstMap<typename Graph::Node,dim2::Point<double> > CoordsMapType;
 		  CoordsMapType _coords;
 		  ConstMap<typename Graph::Node,double > _nodeSizes;
 		  ConstMap<typename Graph::Node,int > _nodeShapes;
 		  ConstMap<typename Graph::Node,Color > _nodeColors;
 		  ConstMap<typename Graph::Arc,Color > _arcColors;
 		  ConstMap<typename Graph::Arc,double > _arcWidths;
 		  double _arcWidthScale;
 		  double _nodeScale;
 		  double _xBorder, _yBorder;
 		  double _scale;
 		  double _nodeBorderQuotient;
 		  bool _drawArrows;
 		  double _arrowLength, _arrowWidth;
 		  bool _showNodes, _showArcs;
 		  bool _enableParallel;
 		  double _parArcDist;
 		  bool _showNodeText;
 		  ConstMap<typename Graph::Node,bool > _nodeTexts;
 		  double _nodeTextSize;
 		  bool _showNodePsText;
 		  ConstMap<typename Graph::Node,bool > _nodePsTexts;
 		  char *_nodePsTextsPreamble;
 		  bool _undirected;
 		  bool _pleaseRemoveOsStream;
 		  bool _scaleToA4;
 		  std::string _title;
 		  std::string _copyright;
 		  enum NodeTextColorType
 		    { DIST_COL=0, DIST_BW=1, CUST_COL=2, SAME_COL=3 } _nodeTextColorType;

lemon/list_graph.h

Show inline comments

@@ -352,129 +352,129 @@
 		    ///Add a new node to the digraph.
 		    ///\return the new node.
 		    Node addNode() { return Parent::addNode(); }
 		    ///Add a new arc to the digraph.
 		    ///Add a new arc to the digraph with source node \c s
 		    ///and target node \c t.
 		    ///\return the new arc.
 		    Arc addArc(const Node& s, const Node& t) {
 		      return Parent::addArc(s, t);
+		    }
 		    ///\brief Erase a node from the digraph.
 		    ///
 		    ///Erase a node from the digraph.
 		    ///
 		    void erase(const Node& n) { Parent::erase(n); }
 		    ///\brief Erase an arc from the digraph.
 		    ///
 		    ///Erase an arc from the digraph.
 		    ///
 		    void erase(const Arc& a) { Parent::erase(a); }
 		    /// Node validity check
 		    /// This function gives back true if the given node is valid,
 		    /// ie. it is a real node of the graph.
 		    ///
 		    /// \warning A Node pointing to a removed item
 		    /// could become valid again later if new nodes are
 		    /// added to the graph.
 		    bool valid(Node n) const { return Parent::valid(n); }
 		    /// Arc validity check
 		    /// This function gives back true if the given arc is valid,
 		    /// ie. it is a real arc of the graph.
 		    ///
 		    /// \warning An Arc pointing to a removed item
 		    /// could become valid again later if new nodes are
 		    /// added to the graph.
 		    bool valid(Arc a) const { return Parent::valid(a); }
 		    /// Change the target of \c a to \c n
 		    /// Change the target of \c a to \c n
 		    ///
 		    ///\note The <tt>ArcIt</tt>s and <tt>OutArcIt</tt>s referencing
 		    ///the changed arc remain valid. However <tt>InArcIt</tt>s are
 		    ///invalidated.
 		    ///
 		    ///\warning This functionality cannot be used together with the Snapshot
 		    ///feature.
 		    void changeTarget(Arc a, Node n) {
 		      Parent::changeTarget(a,n);
+		    }
 		    /// Change the source of \c a to \c n
 		    /// 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
 		    ///feature.
 		    void changeSource(Arc a, Node n) {
 		      Parent::changeSource(a,n);
+		    }
 		    /// Invert the direction of an arc.
 		    ///\note The <tt>ArcIt</tt>s referencing the changed arc remain
 		    ///valid. However <tt>OutArcIt</tt>s and <tt>InArcIt</tt>s are
 		    ///invalidated.
 		    ///
 		    ///\warning This functionality cannot be used together with the Snapshot
 		    ///feature.
 		    void reverseArc(Arc e) {
 		      Node t=target(e);
 		      changeTarget(e,source(e));
 		      changeSource(e,t);
+		    }
 		    /// Reserve memory for nodes.
 		    /// Using this function it is possible to avoid the superfluous memory
 		    /// allocation: if you know that the digraph you want to build will
 		    /// be very large (e.g. it will contain millions of nodes and/or arcs)
 		    /// then it is worth reserving space for this amount before starting
 		    /// to build the digraph.
 		    /// \sa reserveArc
 		    void reserveNode(int n) { nodes.reserve(n); };
 		    /// Reserve memory for arcs.
 		    /// Using this function it is possible to avoid the superfluous memory
 		    /// allocation: if you know that the digraph you want to build will
 		    /// be very large (e.g. it will contain millions of nodes and/or arcs)
 		    /// then it is worth reserving space for this amount before starting
 		    /// to build the digraph.
 		    /// \sa reserveNode
 		    void reserveArc(int m) { arcs.reserve(m); };
 		    ///Contract two nodes.
 		    ///This function contracts two nodes.
 		    ///Node \p b will be removed but instead of deleting
 		    ///incident arcs, they will be joined to \p a.
 		    ///The last parameter \p r controls whether to remove loops. \c true
 		    ///means that loops will be removed.
 		    ///
 		    ///\note The <tt>ArcIt</tt>s referencing a moved arc remain
 		    ///valid. However <tt>InArcIt</tt>s and <tt>OutArcIt</tt>s
 		    ///may be invalidated.
 		    ///
 		    ///\warning This functionality cannot be used together with the Snapshot
 		    ///feature.
 		    void contract(Node a, Node b, bool r = true)
+		    {
 		      for(OutArcIt e(*this,b);e!=INVALID;) {
 		        OutArcIt f=e;
 		        ++f;
 		        if(r && target(e)==a) erase(e);
 		        else changeSource(e,a);
 		        e=f;

lemon/maps.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_MAPS_H
 		#define LEMON_MAPS_H
 		#include <iterator>
 		#include <functional>
 		#include <vector>
 		#include <lemon/core.h>
 		///\file
 		///\ingroup maps
 		///\brief Miscellaneous property maps
 		#include <map>
 		namespace lemon {
 		  /// \addtogroup maps
 		  /// @{
 		  /// Base class of maps.
 		  /// Base class of maps. It provides the necessary type definitions
 		  /// required by the map %concepts.
 		  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).
 		    typedef V Value;
 		  };
 		  /// Null map. (a.k.a. DoNothingMap)
 		  /// This map can be used if you have to provide a map only for
 		  /// its type definitions, or if you have to provide a writable map,
 		  /// but data written to it is not required (i.e. it will be sent to
 		  /// <tt>/dev/null</tt>).
 		  /// It conforms the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
 		  ///
 		  /// \sa ConstMap
 		  template<typename K, typename V>
 		  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 \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 \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;
 		  public:
 		    typedef MapBase<K, V> Parent;
 		    typedef typename Parent::Key Key;
 		    typedef typename Parent::Value Value;
 		    /// Default constructor
@@ -2205,246 +2205,246 @@
 		  private:
 		    typedef std::vector<Item> Container;
 		    Container _inv_map;
 		  public:
 		    /// \brief The inverse map type of DescriptorMap.
 		    ///
 		    /// The inverse map type of DescriptorMap.
 		    class InverseMap {
 		    public:
 		      /// \brief Constructor of the InverseMap.
 		      ///
 		      /// Constructor of the InverseMap.
 		      explicit InverseMap(const DescriptorMap& inverted)
 		        : _inverted(inverted) {}
 		      /// The value type of the InverseMap.
 		      typedef typename DescriptorMap::Key Value;
 		      /// The key type of the InverseMap.
 		      typedef typename DescriptorMap::Value Key;
 		      /// \brief Subscript operator.
 		      ///
 		      /// Subscript operator. It gives back the item
 		      /// that the descriptor belongs to currently.
 		      Value operator[](const Key& key) const {
 		        return _inverted(key);
+		      }
 		      /// \brief Size of the map.
 		      ///
 		      /// Returns the size of the map.
 		      unsigned int size() const {
 		        return _inverted.size();
+		      }
 		    private:
 		      const DescriptorMap& _inverted;
 		    };
 		    /// \brief Gives back the inverse of the map.
 		    ///
 		    /// Gives back the inverse of the map.
 		    const InverseMap inverse() const {
 		      return InverseMap(*this);
+		    }
 		  };
 		  /// \brief Returns the source of the given arc.
 		  ///
 		  /// The SourceMap gives back the source Node of the given arc.
 		  /// \see TargetMap
 		  template <typename Digraph>
 		  class SourceMap {
 		  public:
 		    typedef typename Digraph::Node Value;
 		    typedef typename Digraph::Arc Key;
 		    /// \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.
 		    ///
 		    /// 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 \c 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 {
 		  public:
 		    typedef typename Digraph::Node Value;
 		    typedef typename Digraph::Arc Key;
 		    /// \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.
 		    ///
 		    /// 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 \c 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 {
 		  public:
 		    typedef typename Graph::Arc Value;
 		    typedef typename Graph::Edge Key;
 		    /// \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.
 		    ///
 		    /// 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 \c 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 {
 		  public:
 		    typedef typename Graph::Arc Value;
 		    typedef typename Graph::Edge Key;
 		    /// \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.
 		    ///
 		    /// 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 \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>
 		  class PotentialDifferenceMap {
 		  public:
 		    typedef typename Digraph::Arc Key;
 		    typedef typename NodeMap::Value Value;
 		    /// \brief Constructor
 		    ///
 		    /// Contructor of the map
 		    explicit PotentialDifferenceMap(const Digraph& digraph,
 		                                    const NodeMap& potential)
 		      : _digraph(digraph), _potential(potential) {}
 		    /// \brief Const subscription operator
 		    ///
 		    /// Const subscription operator
 		    Value operator[](const Key& arc) const {
 		      return _potential[_digraph.target(arc)] -
 		        _potential[_digraph.source(arc)];
+		    }
 		  private:
 		    const Digraph& _digraph;
 		    const NodeMap& _potential;
 		  };
 		  /// \brief Returns a PotentialDifferenceMap.
 		  ///
 		  /// This function just returns a PotentialDifferenceMap.
 		  /// \relates PotentialDifferenceMap
 		  template <typename Digraph, typename NodeMap>
 		  PotentialDifferenceMap<Digraph, NodeMap>
 		  potentialDifferenceMap(const Digraph& digraph, const NodeMap& potential) {
 		    return PotentialDifferenceMap<Digraph, NodeMap>(digraph, potential);
+		  }

lemon/path.h

Show inline comments

@@ -788,129 +788,129 @@
 		    /// This class is used to iterate on the arcs of the paths
 		    ///
 		    /// Of course it converts to Digraph::Arc
 		    class ArcIt {
 		      friend class StaticPath;
 		    public:
 		      /// Default constructor
 		      ArcIt() {}
 		      /// Invalid constructor
 		      ArcIt(Invalid) : path(0), idx(-1) {}
 		      /// Initializate the constructor to the first arc of path
 		      ArcIt(const StaticPath &_path)
 		        : path(&_path), idx(_path.empty() ? -1 : 0) {}
 		    private:
 		      /// Constructor with starting point
 		      ArcIt(const StaticPath &_path, int _idx)
 		        : idx(_idx), path(&_path) {}
 		    public:
 		      ///Conversion to Digraph::Arc
 		      operator const Arc&() const {
 		        return path->nth(idx);
+		      }
 		      /// Next arc
 		      ArcIt& operator++() {
 		        ++idx;
 		        if (idx >= path->length()) idx = -1;
 		        return *this;
+		      }
 		      /// Comparison operator
 		      bool operator==(const ArcIt& e) const { return idx==e.idx; }
 		      /// Comparison operator
 		      bool operator!=(const ArcIt& e) const { return idx!=e.idx; }
 		      /// Comparison operator
 		      bool operator<(const ArcIt& e) const { return idx<e.idx; }
 		    private:
 		      const StaticPath *path;
 		      int idx;
 		    };
 		    /// \brief The nth arc.
 		    ///
 		    /// \pre n is in the [0..length() - 1] range
 		    const Arc& nth(int n) const {
 		      return arcs[n];
+		    }
 		    /// \brief The arc iterator pointing to the nth arc.
 		    ArcIt nthIt(int n) const {
 		      return ArcIt(*this, n);
+		    }
 		    /// \brief The length of the path.
 		    int length() const { return len; }
 		    /// \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;
 		      arcs = 0;
+		    }
 		    /// \brief The first arc of the path.
 		    const Arc& front() const {
 		      return arcs[0];
+		    }
 		    /// \brief The last arc of the path.
 		    const Arc& back() const {
 		      return arcs[len - 1];
+		    }
 		    typedef True BuildTag;
 		    template <typename CPath>
 		    void build(const CPath& path) {
 		      len = path.length();
 		      arcs = new Arc[len];
 		      int index = 0;
 		      for (typename CPath::ArcIt it(path); it != INVALID; ++it) {
 		        arcs[index] = it;
 		        ++index;
+		      }
+		    }
 		    template <typename CPath>
 		    void buildRev(const CPath& path) {
 		      len = path.length();
 		      arcs = new Arc[len];
 		      int index = len;
 		      for (typename CPath::RevArcIt it(path); it != INVALID; ++it) {
 		        --index;
 		        arcs[index] = it;
+		      }
+		    }
 		  private:
 		    int len;
 		    Arc* arcs;
 		  };
 		  ///////////////////////////////////////////////////////////////////////
 		  // Additional utilities
 		  ///////////////////////////////////////////////////////////////////////
 		  namespace _path_bits {
 		    template <typename Path, typename Enable = void>
 		    struct RevPathTagIndicator {
 		      static const bool value = false;
 		    };
 		    template <typename Path>
 		    struct RevPathTagIndicator<
 		      Path,
 		      typename enable_if<typename Path::RevPathTag, void>::type
 		      > {
 		      static const bool value = true;
 		    };

lemon/smart_graph.h

Show inline comments

@@ -304,141 +304,141 @@
+		    {
 		      Node b = addNode();
 		      nodes[b._id].first_out=nodes[n._id].first_out;
 		      nodes[n._id].first_out=-1;
 		      for(int i=nodes[b._id].first_out;i!=-1;i++) arcs[i].source=b._id;
 		      if(connect) addArc(n,b);
 		      return b;
+		    }
 		  public:
 		    class Snapshot;
 		  protected:
 		    void restoreSnapshot(const Snapshot &s)
+		    {
 		      while(s.arc_num<arcs.size()) {
 		        Arc arc = arcFromId(arcs.size()-1);
 		        Parent::notifier(Arc()).erase(arc);
 		        nodes[arcs.back().source].first_out=arcs.back().next_out;
 		        nodes[arcs.back().target].first_in=arcs.back().next_in;
 		        arcs.pop_back();
+		      }
 		      while(s.node_num<nodes.size()) {
 		        Node node = nodeFromId(nodes.size()-1);
 		        Parent::notifier(Node()).erase(node);
 		        nodes.pop_back();
+		      }
+		    }
 		  public:
 		    ///Class to make a snapshot of the digraph and to restrore to it later.
 		    ///Class to make a snapshot of the digraph and to restrore to it later.
 		    ///
 		    ///The newly added nodes and arcs can be removed using the
 		    ///restore() function.
 		    ///\note After you restore a state, you cannot restore
 		    ///a later state, in other word you cannot add again the arcs deleted
 		    ///by restore() using another one Snapshot instance.
 		    ///
 		    ///\warning If you do not use correctly the snapshot that can cause
 		    ///either broken program, invalid state of the digraph, valid but
 		    ///not the restored digraph or no change. Because the runtime performance
 		    ///the validity of the snapshot is not stored.
 		    class Snapshot
+		    {
 		      SmartDigraph *_graph;
 		    protected:
 		      friend class SmartDigraph;
 		      unsigned int node_num;
 		      unsigned int arc_num;
 		    public:
 		      ///Default constructor.
 		      ///Default constructor.
 		      ///To actually make a snapshot you must call save().
 		      ///
 		      Snapshot() : _graph(0) {}
 		      ///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();
+		      }
 		      ///Make a snapshot.
 		      ///Make a snapshot of the digraph.
 		      ///
 		      ///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;
 		        node_num=_graph->nodes.size();
 		        arc_num=_graph->arcs.size();
+		      }
 		      ///Undo the changes until a snapshot.
 		      ///Undo the changes until a snapshot created by save().
 		      ///
 		      ///\note After you restored a state, you cannot restore
 		      ///a later state, in other word you cannot add again the arcs deleted
 		      ///by restore().
 		      void restore()
+		      {
 		        _graph->restoreSnapshot(*this);
+		      }
 		    };
 		  };
 		  class SmartGraphBase {
 		  protected:
 		    struct NodeT {
 		      int first_out;
 		    };
 		    struct ArcT {
 		      int target;
 		      int next_out;
 		    };
 		    std::vector<NodeT> nodes;
 		    std::vector<ArcT> arcs;
 		    int first_free_arc;
 		  public:
 		    typedef SmartGraphBase Digraph;
 		    class Node;
 		    class Arc;
 		    class Edge;
 		    class Node {
 		      friend class SmartGraphBase;
 		    protected:
 		      int _id;
 		      explicit Node(int id) { _id = id;}
 		    public:
 		      Node() {}
 		      Node (Invalid) { _id = -1; }
 		      bool operator==(const Node& node) const {return _id == node._id;}
 		      bool operator!=(const Node& node) const {return _id != node._id;}
 		      bool operator<(const Node& node) const {return _id < node._id;}
 		    };
 		    class Edge {
@@ -714,99 +714,99 @@
 		    void saveSnapshot(Snapshot &s)
+		    {
 		      s._graph = this;
 		      s.node_num = nodes.size();
 		      s.arc_num = arcs.size();
+		    }
 		    void restoreSnapshot(const Snapshot &s)
+		    {
 		      while(s.arc_num<arcs.size()) {
 		        int n=arcs.size()-1;
 		        Edge arc=edgeFromId(n/2);
 		        Parent::notifier(Edge()).erase(arc);
 		        std::vector<Arc> dir;
 		        dir.push_back(arcFromId(n));
 		        dir.push_back(arcFromId(n-1));
 		        Parent::notifier(Arc()).erase(dir);
 		        nodes[arcs[n].target].first_out=arcs[n].next_out;
 		        nodes[arcs[n-1].target].first_out=arcs[n-1].next_out;
 		        arcs.pop_back();
 		        arcs.pop_back();
+		      }
 		      while(s.node_num<nodes.size()) {
 		        int n=nodes.size()-1;
 		        Node node = nodeFromId(n);
 		        Parent::notifier(Node()).erase(node);
 		        nodes.pop_back();
+		      }
+		    }
 		  public:
 		    ///Class to make a snapshot of the digraph and to restrore to it later.
 		    ///Class to make a snapshot of the digraph and to restrore to it later.
 		    ///
 		    ///The newly added nodes and arcs can be removed using the
 		    ///restore() function.
 		    ///
 		    ///\note After you restore a state, you cannot restore
 		    ///a later state, in other word you cannot add again the arcs deleted
 		    ///by restore() using another one Snapshot instance.
 		    ///
 		    ///\warning If you do not use correctly the snapshot that can cause
 		    ///either broken program, invalid state of the digraph, valid but
 		    ///not the restored digraph or no change. Because the runtime performance
 		    ///the validity of the snapshot is not stored.
 		    class Snapshot
+		    {
 		      SmartGraph *_graph;
 		    protected:
 		      friend class SmartGraph;
 		      unsigned int node_num;
 		      unsigned int arc_num;
 		    public:
 		      ///Default constructor.
 		      ///Default constructor.
 		      ///To actually make a snapshot you must call save().
 		      ///
 		      Snapshot() : _graph(0) {}
 		      ///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);
+		      }
 		      ///Make a snapshot.
 		      ///Make a snapshot of the graph.
 		      ///
 		      ///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);
+		      }
 		      ///Undo the changes until a snapshot.
 		      ///Undo the changes until a snapshot created by save().
 		      ///
 		      ///\note After you restored a state, you cannot restore
 		      ///a later state, in other word you cannot add again the arcs deleted
 		      ///by restore().
 		      void restore()
+		      {
 		        _graph->restoreSnapshot(*this);
+		      }
 		    };
 		  };
 		} //namespace lemon
 		#endif //LEMON_SMART_GRAPH_H

lemon/time_measure.h

Show inline comments

@@ -250,134 +250,133 @@
 		      "s, cu: " << t.cUserTime() <<
 		      "s, cs: " << t.cSystemTime() <<
 		      "s, real: " << t.realTime() << "s";
 		    return os;
+		  }
 		  ///Class for measuring the cpu time and real time usage of the process
 		  ///Class for measuring the cpu time and real time usage of the process.
 		  ///It is quite easy-to-use, here is a short example.
 		  ///\code
 		  /// #include<lemon/time_measure.h>
 		  /// #include<iostream>
 		  ///
 		  /// int main()
 		  /// {
 		  ///
 		  ///   ...
 		  ///
 		  ///   Timer t;
 		  ///   doSomething();
 		  ///   std::cout << t << '\n';
 		  ///   t.restart();
 		  ///   doSomethingElse();
 		  ///   std::cout << t << '\n';
 		  ///
 		  ///   ...
 		  ///
 		  /// }
 		  ///\endcode
 		  ///
 		  ///The \ref Timer can also be \ref stop() "stopped" and
 		  ///\ref start() "started" again, so it is possible to compute collected
 		  ///running times.
 		  ///
 		  ///\warning Depending on the operation system and its actual configuration
 		  ///the time counters have a certain (10ms on a typical Linux system)
 		  ///granularity.
 		  ///Therefore this tool is not appropriate to measure very short times.
 		  ///Also, if you start and stop the timer very frequently, it could lead to
 		  ///distorted results.
 		  ///
 		  ///\note If you want to measure the running time of the execution of a certain
 		  ///function, consider the usage of \ref TimeReport instead.
 		  ///
 		  ///\sa TimeReport
 		  class Timer
+		  {
 		    int _running; //Timer is running iff _running>0; (_running>=0 always holds)
 		    TimeStamp start_time; //This is the relativ start-time if the timer
 		                          //is _running, the collected _running time otherwise.
 		    void _reset() {if(_running) start_time.stamp(); else start_time.reset();}
 		  public:
 		    ///Constructor.
 		    ///\param run indicates whether or not the timer starts immediately.
 		    ///
 		    Timer(bool run=true) :_running(run) {_reset();}
 		    ///\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.
 		    ///
 		    ///@{
 		    ///Reset and stop the time counters
 		    ///This function resets and stops the time counters
 		    ///\sa restart()
 		    void reset()
+		    {
 		      _running=0;
 		      _reset();
+		    }
 		    ///Start the time counters
 		    ///This function starts the time counters.
 		    ///
 		    ///If the timer is started more than ones, it will remain running
 		    ///until the same amount of \ref stop() is called.
 		    ///\sa stop()
 		    void start()
+		    {
 		      if(_running) _running++;
 		      else {
 		        _running=1;
 		        TimeStamp t;
 		        t.stamp();
 		        start_time=t-start_time;
+		      }
+		    }
 		    ///Stop the time counters
 		    ///This function stops the time counters. If start() was executed more than
 		    ///once, then the same number of stop() execution is necessary the really
 		    ///stop the timer.
 		    ///
 		    ///\sa halt()
 		    ///\sa start()
 		    ///\sa restart()
 		    ///\sa reset()
 		    void stop()
+		    {
 		      if(_running && !--_running) {
 		        TimeStamp t;
 		        t.stamp();
 		        start_time=t-start_time;
+		      }
+		    }
 		    ///Halt (i.e stop immediately) the time counters
 		    ///This function stops immediately the time counters, i.e. <tt>t.halt()</tt>
 		    ///is a faster
 		    ///equivalent of the following.
 		    ///\code
 		    ///  while(t.running()) t.stop()
 		    ///\endcode
 		    ///
 		    ///
 		    ///\sa stop()
 		    ///\sa restart()
@@ -411,163 +410,163 @@
 		    ///
 		    void restart()
+		    {
 		      reset();
 		      start();
+		    }
 		    ///@}
 		    ///\name Query Functions for the ellapsed time
 		    ///@{
 		    ///Gives back the ellapsed user time of the process
 		    double userTime() const
+		    {
 		      return operator TimeStamp().userTime();
+		    }
 		    ///Gives back the ellapsed system time of the process
 		    double systemTime() const
+		    {
 		      return operator TimeStamp().systemTime();
+		    }
 		    ///Gives back the ellapsed user time of the process' children
 		    ///\note On <tt>WIN32</tt> platform this value is not calculated.
 		    ///
 		    double cUserTime() const
+		    {
 		      return operator TimeStamp().cUserTime();
+		    }
 		    ///Gives back the ellapsed user time of the process' children
 		    ///\note On <tt>WIN32</tt> platform this value is not calculated.
 		    ///
 		    double cSystemTime() const
+		    {
 		      return operator TimeStamp().cSystemTime();
+		    }
 		    ///Gives back the ellapsed real time
 		    double realTime() const
+		    {
 		      return operator TimeStamp().realTime();
+		    }
 		    ///Computes the ellapsed time
 		    ///This conversion computes the ellapsed time, therefore you can print
 		    ///the ellapsed time like this.
 		    ///\code
 		    ///  Timer t;
 		    ///  doSomething();
 		    ///  std::cout << t << '\n';
 		    ///\endcode
 		    operator TimeStamp () const
+		    {
 		      TimeStamp t;
 		      t.stamp();
 		      return _running?t-start_time:start_time;
+		    }
 		    ///@}
 		  };
-		  ///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.
 		  ///\code
 		  ///  void myAlg(ListGraph &g,int n)
 		  ///  {
 		  ///    TimeReport tr("Running time of myAlg: ");
 		  ///    ... //Here comes the algorithm
 		  ///  }
 		  ///\endcode
 		  ///
 		  ///\sa Timer
 		  ///\sa NoTimeReport
 		  class TimeReport : public Timer
+		  {
 		    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
 		  ///
 		  class NoTimeReport
+		  {
 		  public:
 		    ///\e
 		    NoTimeReport(std::string,std::ostream &,bool) {}
 		    ///\e
 		    NoTimeReport(std::string,std::ostream &) {}
 		    ///\e
 		    NoTimeReport(std::string) {}
 		    ///\e Do nothing.
 		    ~NoTimeReport() {}
 		    operator TimeStamp () const { return TimeStamp(); }
 		    void reset() {}
 		    void start() {}
 		    void stop() {}
 		    void halt() {}
 		    int running() { return 0; }
 		    void restart() {}
 		    double userTime() const { return 0; }
 		    double systemTime() const { return 0; }
 		    double cUserTime() const { return 0; }
 		    double cSystemTime() const { return 0; }
 		    double realTime() const { return 0; }
 		  };
 		  ///Tool to measure the running time more exactly.
 		  ///This function calls \c f several times and returns the average
 		  ///running time. The number of the executions will be choosen in such a way
 		  ///that the full real running time will be roughly between \c min_time
 		  ///and <tt>2*min_time</tt>.
 		  ///\param f the function object to be measured.
 		  ///\param min_time the minimum total running time.
 		  ///\retval num if it is not \c NULL, then the actual
 		  ///        number of execution of \c f will be written into <tt>*num</tt>.
 		  ///\retval full_time if it is not \c NULL, then the actual
 		  ///        total running time will be written into <tt>*full_time</tt>.
 		  ///\return The average running time of \c f.
 		  template<class F>
 		  TimeStamp runningTimeTest(F f,double min_time=10,unsigned int *num = NULL,
 		                            TimeStamp *full_time=NULL)
+		  {
 		    TimeStamp full;
 		    unsigned int total=0;
 		    Timer t;
 		    for(unsigned int tn=1;tn <= 1U<<31 && full.realTime()<=min_time; tn*=2) {
 		      for(;total<tn;total++) f();
 		      full=t;
+		    }
 		    if(num) *num=total;
 		    if(full_time) *full_time=full;
 		    return full/total;
+		  }
 		  /// @}
 		} //namespace lemon

0 comments (0 inline)

RhodeCode

Login to your account