*

  *

  * Copyright (C) 2003-2008

  * Copyright (C) 2003-2008

  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

  * (Egervary Research Group on Combinatorial Optimization, EGRES).

  * (Egervary Research Group on Combinatorial Optimization, EGRES).

  *

  *

 ///\ingroup timecount

 ///\ingroup timecount

 ///\file

 ///\file

 ///\brief Tools for counting steps and events

 ///\brief Tools for counting steps and events

 {

 {

   template<class P> class _NoSubCounter;

   template<class P> class _NoSubCounter;

   template<class P>

   template<class P>

   {

   {

     P &_parent;

     P &_parent;

     std::string _title;

     std::string _title;

     std::ostream &_os;

     std::ostream &_os;

     int count;

     int count;

       : _parent(parent), _title(), _os(std::cerr), count(0) {}

       : _parent(parent), _title(), _os(std::cerr), count(0) {}

     _SubCounter(P &parent,std::string title,std::ostream &os=std::cerr)

     _SubCounter(P &parent,std::string title,std::ostream &os=std::cerr)

       : _parent(parent), _title(title), _os(os), count(0) {}

       : _parent(parent), _title(title), _os(os), count(0) {}

     _SubCounter(P &parent,const char *title,std::ostream &os=std::cerr)

     _SubCounter(P &parent,const char *title,std::ostream &os=std::cerr)

       : _parent(parent), _title(title), _os(os), count(0) {}

       : _parent(parent), _title(title), _os(os), count(0) {}

       _os << _title << count <<std::endl;

       _os << _title << count <<std::endl;

       _parent+=count;

       _parent+=count;

     }

     }

     _SubCounter &operator++() { count++; return *this;}

     _SubCounter &operator++() { count++; return *this;}

     int operator++(int) { return count++; }

     int operator++(int) { return count++; }

     _SubCounter &operator-=(int c) { count-=c; return *this;}

     _SubCounter &operator-=(int c) { count-=c; return *this;}

     operator int() {return count;}

     operator int() {return count;}

   };

   };

   template<class P>

   template<class P>

   {

   {

     P &_parent;

     P &_parent;

   public:

   public:

     typedef _NoSubCounter<_NoSubCounter<P> > SubCounter;

     typedef _NoSubCounter<_NoSubCounter<P> > SubCounter;

     typedef _NoSubCounter<_NoSubCounter<P> > NoSubCounter;

     typedef _NoSubCounter<_NoSubCounter<P> > NoSubCounter;

     _NoSubCounter(P &parent) :_parent(parent) {}

     _NoSubCounter(P &parent) :_parent(parent) {}

       :_parent(parent) {}

       :_parent(parent) {}

     _NoSubCounter(P &parent,const char *,std::ostream &)

     _NoSubCounter(P &parent,const char *,std::ostream &)

       :_parent(parent) {}

       :_parent(parent) {}

     _NoSubCounter(P &parent,const char *)

     _NoSubCounter(P &parent,const char *)

       :_parent(parent) {}

       :_parent(parent) {}

   /// You can increment or decrement the counter using \c operator++,

   /// You can increment or decrement the counter using \c operator++,

   /// \c operator--, \c operator+= and \c operator-=. You can also

   /// \c operator--, \c operator+= and \c operator-=. You can also

   /// define subcounters for the different phases of the algorithm or

   /// define subcounters for the different phases of the algorithm or

   /// for different types of operations.

   /// for different types of operations.

   /// A report containing the given title and the value of the counter

   /// A report containing the given title and the value of the counter

   ///

   ///

   /// The following example shows the usage of counters and subcounters.

   /// The following example shows the usage of counters and subcounters.

   /// \code

   /// \code

   /// // Bubble sort

   /// // Bubble sort

   /// std::vector<T> v;

   /// std::vector<T> v;

   /// Assignments: 57

   /// Assignments: 57

   /// Operations: 102

   /// Operations: 102

   /// \endcode

   /// \endcode

   ///

   ///

   /// \sa NoCounter

   /// \sa NoCounter

   {

   {

     std::string _title;

     std::string _title;

     std::ostream &_os;

     std::ostream &_os;

     int count;

     int count;

   public:

   public:

     /// SubCounter class

     /// SubCounter class

     /// This class can be used to setup subcounters for a \ref Counter

     /// This class can be used to setup subcounters for a \ref Counter

     /// to have finer reports. A subcounter provides exactly the same

     /// to have finer reports. A subcounter provides exactly the same

     /// operations as the main \ref Counter, but it also increments and

     /// operations as the main \ref Counter, but it also increments and

     /// decrements the value of its parent.

     /// decrements the value of its parent.

     /// Subcounters can also have subcounters.

     /// Subcounters can also have subcounters.

     /// The parent counter must be given as the first parameter of the

     /// The parent counter must be given as the first parameter of the

     /// constructor. Apart from that a title and an \c ostream object

     /// constructor. Apart from that a title and an \c ostream object

     /// can also be given just like for the main \ref Counter.

     /// can also be given just like for the main \ref Counter.

     ///

     ///

     /// A report containing the given title and the value of the

     /// A report containing the given title and the value of the

     /// subcounter is automatically printed on destruction. If you

     /// subcounter is automatically printed on destruction. If you

     /// would like to turn off this report, use \ref NoSubCounter

     /// would like to turn off this report, use \ref NoSubCounter

     /// instead.

     /// instead.

     /// \sa NoSubCounter

     /// \sa NoSubCounter

     typedef _SubCounter<Counter> SubCounter;

     typedef _SubCounter<Counter> SubCounter;

     /// This class can be used to setup subcounters for a \ref Counter.

     /// This class can be used to setup subcounters for a \ref Counter.

     /// It is the same as \ref SubCounter but it does not print report

     /// It is the same as \ref SubCounter but it does not print report

     /// on destruction. (It modifies the value of its parent, so 'No'

     /// on destruction. (It modifies the value of its parent, so 'No'

     /// only means 'do not print'.)

     /// only means 'do not print'.)

     ///

     ///

     /// Replacing \ref SubCounter "SubCounter"s with \ref NoSubCounter

     /// Replacing \ref SubCounter "SubCounter"s with \ref NoSubCounter

     /// subcounter values without actually removing the definitions

     /// subcounter values without actually removing the definitions

     /// and the increment or decrement operators.

     /// and the increment or decrement operators.

     ///

     ///

     /// \sa SubCounter

     /// \sa SubCounter

     typedef _NoSubCounter<Counter> NoSubCounter;

     typedef _NoSubCounter<Counter> NoSubCounter;

     /// Constructor.

     /// Constructor.

     Counter() : _title(), _os(std::cerr), count(0) {}

     Counter() : _title(), _os(std::cerr), count(0) {}

     /// Constructor.

     /// Constructor.

       : _title(title), _os(os), count(0) {}

       : _title(title), _os(os), count(0) {}

     /// Constructor.

     /// Constructor.

     Counter(const char *title,std::ostream &os=std::cerr)

     Counter(const char *title,std::ostream &os=std::cerr)

       : _title(title), _os(os), count(0) {}

       : _title(title), _os(os), count(0) {}

     /// Destructor. Prints the given title and the value of the counter.

     /// Destructor. Prints the given title and the value of the counter.

     /// Resets the counter to the given value.

     /// Resets the counter to the given value.

     /// Resets the counter to the given value.

     /// Resets the counter to the given value.

     /// \note This function does not reset the values of

     /// \note This function does not reset the values of

     /// \ref SubCounter "SubCounter"s but it resets \ref NoSubCounter

     /// \ref SubCounter "SubCounter"s but it resets \ref NoSubCounter

     void reset(int c=0) {count=c;}

     void reset(int c=0) {count=c;}

     /// Returns the value of the counter.

     /// Returns the value of the counter.

     operator int() {return count;}

     operator int() {return count;}

   };

   };