RhodeCode

    std::string _title;

    std::ostream &_os;

    int count;

  public:

    typedef _SubCounter<_SubCounter<P> > SubCounter;

    typedef _NoSubCounter<_SubCounter<P> > NoSubCounter;

    _SubCounter(P &parent)

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

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

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

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

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

    ~_SubCounter() { 

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

      _parent+=count;

    }

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

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

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

    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;}

  };

  template<class P>

  class _NoSubCounter 

  {

    P &_parent;

  public:

    typedef _NoSubCounter<_NoSubCounter<P> > SubCounter;

    typedef _NoSubCounter<_NoSubCounter<P> > NoSubCounter;

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

    _NoSubCounter(P &parent,std::string,std::ostream &) 

      :_parent(parent) {}

    _NoSubCounter(P &parent,std::string) 

      :_parent(parent) {}

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

      :_parent(parent) {}

    _NoSubCounter(P &parent,const char *)

      :_parent(parent) {}

    ~_NoSubCounter() {}

    _NoSubCounter &operator++() { ++_parent; return *this;}

    int operator++(int) { _parent++; return 0;}

    _NoSubCounter &operator--() { --_parent; return *this;}

    int operator--(int) { _parent--; return 0;}

    _NoSubCounter &operator+=(int c) { _parent+=c; return *this;}

    _NoSubCounter &operator-=(int c) { _parent-=c; return *this;}

    operator int() {return 0;}

  };

  /// \addtogroup timecount

  /// @{

  /// A counter class

  /// This class makes it easier to count certain events (e.g. for debug

  /// reasons).

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

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

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

  /// for different types of operations.

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

  /// is automatically printed on destruction. 

  ///

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

  /// \code

  /// // Bubble sort

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

  /// ...

  /// Counter op("Operations: ");

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

    /// Constructor.

    Counter(std::string title,std::ostream &os=std::cerr) 

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

    /// Constructor.

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

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

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

    ~Counter() {

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

    }

    ///\e

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

    ///\e

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

    ///\e

    Counter &operator--() { count--; return *this;}

    ///\e

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

    ///\e

    Counter &operator+=(int c) { count+=c; return *this;}

    ///\e

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

    /// Resets the counter to the given value.

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

    /// Returns the value of the counter.

    operator int() {return count;}

  };

  /// 'Do nothing' version of Counter.

  /// This class can be used in the same way as \ref Counter however it

  /// does not count at all and does not print report on destruction.

  ///

  /// Replacing a \ref Counter with a \ref NoCounter makes it possible

  /// to turn off all counting and reporting (SubCounters should also

  /// be replaced with NoSubCounters), so it does not affect the

  /// efficiency of the program at all.

  ///

  /// \sa Counter

  class NoCounter

  {

  public:

    typedef _NoSubCounter<NoCounter> SubCounter;

    typedef _NoSubCounter<NoCounter> NoSubCounter;

    NoCounter() {}

    NoCounter(std::string,std::ostream &) {}