COIN-OR::LEMON - Graph Library

source: lemon/lemon/counter.h @ 461:1229dc2f1d36

Last change on this file since 461:1229dc2f1d36 was 209:765619b7cbb2, checked in by Alpar Juttner <alpar@…>, 11 years ago

Apply unify-sources.sh to the source tree

File size: 7.9 KB
Line 
1/* -*- mode: C++; indent-tabs-mode: nil; -*-
2 *
3 * This file is a part of LEMON, a generic C++ optimization library.
4 *
5 * Copyright (C) 2003-2008
6 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7 * (Egervary Research Group on Combinatorial Optimization, EGRES).
8 *
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.
12 *
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
15 * purpose.
16 *
17 */
18
19#ifndef LEMON_COUNTER_H
20#define LEMON_COUNTER_H
21
22#include <string>
23#include <iostream>
24
25///\ingroup timecount
26///\file
27///\brief Tools for counting steps and events
28
29namespace lemon
30{
31
32  template<class P> class _NoSubCounter;
33
34  template<class P>
35  class _SubCounter
36  {
37    P &_parent;
38    std::string _title;
39    std::ostream &_os;
40    int count;
41  public:
42
43    typedef _SubCounter<_SubCounter<P> > SubCounter;
44    typedef _NoSubCounter<_SubCounter<P> > NoSubCounter;
45
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) {}
52    ~_SubCounter() {
53      _os << _title << count <<std::endl;
54      _parent+=count;
55    }
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;}
63  };
64
65  template<class P>
66  class _NoSubCounter
67  {
68    P &_parent;
69  public:
70    typedef _NoSubCounter<_NoSubCounter<P> > SubCounter;
71    typedef _NoSubCounter<_NoSubCounter<P> > NoSubCounter;
72
73    _NoSubCounter(P &parent) :_parent(parent) {}
74    _NoSubCounter(P &parent,std::string,std::ostream &)
75      :_parent(parent) {}
76    _NoSubCounter(P &parent,std::string)
77      :_parent(parent) {}
78    _NoSubCounter(P &parent,const char *,std::ostream &)
79      :_parent(parent) {}
80    _NoSubCounter(P &parent,const char *)
81      :_parent(parent) {}
82    ~_NoSubCounter() {}
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;}
90  };
91
92
93  /// \addtogroup timecount
94  /// @{
95
96  /// A counter class
97
98  /// This class makes it easier to count certain events (e.g. for debug
99  /// reasons).
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.
106  ///
107  /// The following example shows the usage of counters and subcounters.
108  /// \code
109  /// // Bubble sort
110  /// std::vector<T> v;
111  /// ...
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]) {
118  ///       T tmp = v[j];
119  ///       v[j] = v[j+1];
120  ///       v[j+1] = tmp;
121  ///       as += 3;          // three assignments
122  ///     }
123  ///     ++co;               // one comparison
124  ///   }
125  /// }
126  /// \endcode
127  ///
128  /// This code prints out something like that:
129  /// \code
130  /// Comparisons: 45
131  /// Assignments: 57
132  /// Operations: 102
133  /// \endcode
134  ///
135  /// \sa NoCounter
136  class Counter
137  {
138    std::string _title;
139    std::ostream &_os;
140    int count;
141  public:
142
143    /// SubCounter class
144
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.
150    ///
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.
154    ///
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
158    /// instead.
159    ///
160    /// \sa NoSubCounter
161    typedef _SubCounter<Counter> SubCounter;
162
163    /// SubCounter class without printing report on destruction
164
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'.)
169    ///
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.
174    ///
175    /// \sa SubCounter
176    typedef _NoSubCounter<Counter> NoSubCounter;
177
178    /// Constructor.
179    Counter() : _title(), _os(std::cerr), count(0) {}
180    /// Constructor.
181    Counter(std::string title,std::ostream &os=std::cerr)
182      : _title(title), _os(os), count(0) {}
183    /// Constructor.
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.
187    ~Counter() {
188      _os << _title << count <<std::endl;
189    }
190    ///\e
191    Counter &operator++() { count++; return *this;}
192    ///\e
193    int operator++(int) { return count++;}
194    ///\e
195    Counter &operator--() { count--; return *this;}
196    ///\e
197    int operator--(int) { return count--;}
198    ///\e
199    Counter &operator+=(int c) { count+=c; return *this;}
200    ///\e
201    Counter &operator-=(int c) { count-=c; return *this;}
202    /// Resets the counter to the given value.
203
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;}
211  };
212
213  /// 'Do nothing' version of Counter.
214
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.
217  ///
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.
222  ///
223  /// \sa Counter
224  class NoCounter
225  {
226  public:
227    typedef _NoSubCounter<NoCounter> SubCounter;
228    typedef _NoSubCounter<NoCounter> NoSubCounter;
229
230    NoCounter() {}
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;}
241    void reset(int) {}
242    void reset() {}
243    operator int() {return 0;}
244  };
245
246  ///@}
247}
248
249#endif
Note: See TracBrowser for help on using the repository browser.