Set the proper version for CMAKE in the tarballs (made by autotools).
1 /* -*- mode: C++; indent-tabs-mode: nil; -*-
3 * This file is a part of LEMON, a generic C++ optimization library.
5 * Copyright (C) 2003-2008
6 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7 * (Egervary Research Group on Combinatorial Optimization, EGRES).
9 * Permission to use, modify and distribute this software is granted
10 * provided that this copyright notice appears in all copies. For
11 * precise terms see the accompanying LICENSE file.
13 * This software is provided "AS IS" with no warranty of any kind,
14 * express or implied, and with no claim as to its suitability for any
19 #ifndef LEMON_COUNTER_H
20 #define LEMON_COUNTER_H
27 ///\brief Tools for counting steps and events
32 template<class P> class _NoSubCounter;
43 typedef _SubCounter<_SubCounter<P> > SubCounter;
44 typedef _NoSubCounter<_SubCounter<P> > NoSubCounter;
46 _SubCounter(P &parent)
47 : _parent(parent), _title(), _os(std::cerr), count(0) {}
48 _SubCounter(P &parent,std::string title,std::ostream &os=std::cerr)
49 : _parent(parent), _title(title), _os(os), count(0) {}
50 _SubCounter(P &parent,const char *title,std::ostream &os=std::cerr)
51 : _parent(parent), _title(title), _os(os), count(0) {}
53 _os << _title << count <<std::endl;
56 _SubCounter &operator++() { count++; return *this;}
57 int operator++(int) { return count++; }
58 _SubCounter &operator--() { count--; return *this;}
59 int operator--(int) { return count--; }
60 _SubCounter &operator+=(int c) { count+=c; return *this;}
61 _SubCounter &operator-=(int c) { count-=c; return *this;}
62 operator int() {return count;}
70 typedef _NoSubCounter<_NoSubCounter<P> > SubCounter;
71 typedef _NoSubCounter<_NoSubCounter<P> > NoSubCounter;
73 _NoSubCounter(P &parent) :_parent(parent) {}
74 _NoSubCounter(P &parent,std::string,std::ostream &)
76 _NoSubCounter(P &parent,std::string)
78 _NoSubCounter(P &parent,const char *,std::ostream &)
80 _NoSubCounter(P &parent,const char *)
83 _NoSubCounter &operator++() { ++_parent; return *this;}
84 int operator++(int) { _parent++; return 0;}
85 _NoSubCounter &operator--() { --_parent; return *this;}
86 int operator--(int) { _parent--; return 0;}
87 _NoSubCounter &operator+=(int c) { _parent+=c; return *this;}
88 _NoSubCounter &operator-=(int c) { _parent-=c; return *this;}
89 operator int() {return 0;}
93 /// \addtogroup timecount
98 /// This class makes it easier to count certain events (e.g. for debug
100 /// You can increment or decrement the counter using \c operator++,
101 /// \c operator--, \c operator+= and \c operator-=. You can also
102 /// define subcounters for the different phases of the algorithm or
103 /// for different types of operations.
104 /// A report containing the given title and the value of the counter
105 /// is automatically printed on destruction.
107 /// The following example shows the usage of counters and subcounters.
110 /// std::vector<T> v;
112 /// Counter op("Operations: ");
113 /// Counter::SubCounter as(op, "Assignments: ");
114 /// Counter::SubCounter co(op, "Comparisons: ");
115 /// for (int i = v.size()-1; i > 0; --i) {
116 /// for (int j = 0; j < i; ++j) {
117 /// if (v[j] > v[j+1]) {
121 /// as += 3; // three assignments
123 /// ++co; // one comparison
128 /// This code prints out something like that:
145 /// This class can be used to setup subcounters for a \ref Counter
146 /// to have finer reports. A subcounter provides exactly the same
147 /// operations as the main \ref Counter, but it also increments and
148 /// decrements the value of its parent.
149 /// Subcounters can also have subcounters.
151 /// The parent counter must be given as the first parameter of the
152 /// constructor. Apart from that a title and an \c ostream object
153 /// can also be given just like for the main \ref Counter.
155 /// A report containing the given title and the value of the
156 /// subcounter is automatically printed on destruction. If you
157 /// would like to turn off this report, use \ref NoSubCounter
161 typedef _SubCounter<Counter> SubCounter;
163 /// SubCounter class without printing report on destruction
165 /// This class can be used to setup subcounters for a \ref Counter.
166 /// It is the same as \ref SubCounter but it does not print report
167 /// on destruction. (It modifies the value of its parent, so 'No'
168 /// only means 'do not print'.)
170 /// Replacing \ref SubCounter "SubCounter"s with \ref NoSubCounter
171 /// "NoSubCounter"s makes it possible to turn off reporting
172 /// subcounter values without actually removing the definitions
173 /// and the increment or decrement operators.
176 typedef _NoSubCounter<Counter> NoSubCounter;
179 Counter() : _title(), _os(std::cerr), count(0) {}
181 Counter(std::string title,std::ostream &os=std::cerr)
182 : _title(title), _os(os), count(0) {}
184 Counter(const char *title,std::ostream &os=std::cerr)
185 : _title(title), _os(os), count(0) {}
186 /// Destructor. Prints the given title and the value of the counter.
188 _os << _title << count <<std::endl;
191 Counter &operator++() { count++; return *this;}
193 int operator++(int) { return count++;}
195 Counter &operator--() { count--; return *this;}
197 int operator--(int) { return count--;}
199 Counter &operator+=(int c) { count+=c; return *this;}
201 Counter &operator-=(int c) { count-=c; return *this;}
202 /// Resets the counter to the given value.
204 /// Resets the counter to the given value.
205 /// \note This function does not reset the values of
206 /// \ref SubCounter "SubCounter"s but it resets \ref NoSubCounter
207 /// "NoSubCounter"s along with the main counter.
208 void reset(int c=0) {count=c;}
209 /// Returns the value of the counter.
210 operator int() {return count;}
213 /// 'Do nothing' version of Counter.
215 /// This class can be used in the same way as \ref Counter however it
216 /// does not count at all and does not print report on destruction.
218 /// Replacing a \ref Counter with a \ref NoCounter makes it possible
219 /// to turn off all counting and reporting (SubCounters should also
220 /// be replaced with NoSubCounters), so it does not affect the
221 /// efficiency of the program at all.
227 typedef _NoSubCounter<NoCounter> SubCounter;
228 typedef _NoSubCounter<NoCounter> NoSubCounter;
231 NoCounter(std::string,std::ostream &) {}
232 NoCounter(const char *,std::ostream &) {}
233 NoCounter(std::string) {}
234 NoCounter(const char *) {}
235 NoCounter &operator++() { return *this; }
236 int operator++(int) { return 0; }
237 NoCounter &operator--() { return *this; }
238 int operator--(int) { return 0; }
239 NoCounter &operator+=(int) { return *this;}
240 NoCounter &operator-=(int) { return *this;}
243 operator int() {return 0;}