Version 5.0 The LEDA User Manual

4. Example
First two simple observer classes. The first one is a dummy class, which ignores all
notifications. The second one merely counts the number of calls to operator++ for all
iterators that share the same observer object through copy construction or assignment
(of course, a real implementation should apply some kind of reference counting or other
garbage collection).
In this example, the counter variable count of class SimpleCountObserver will be initialized
with the counter variable count of class DummyObserver, i.e. the variable is created
only once.
template
class DummyObserver {
int* _count;
public:
DummyObserver() : _count(new int(0)) { }
void notify_constructor(const Iter& ) { }
void notify_forward(const Iter& ) { }
void notify_update(const Iter& ) { }
int counter() const { return *_count; }
int* counter_ptr() const { return _count; }
bool operator==(const DummyObserver& D) const {
return _count==D._count; }
};
template
class SimpleCountObserver {
int* _count;
public:
SimpleCountObserver() : _count(new int(0)) { }
SimpleCountObserver(Observer& obs) :
_count(obs.counter_ptr()) { }
void notify_constructor(const Iter& ) { }
void notify_forward(const Iter& ) { ++(*_count); }
void notify_update(const Iter& ) { }
int counter() const { return *_count; }
int* counter_ptr() const { return _count; }
bool operator==(const SimpleCountObserver& S) const {
return _count==S._count; }
};
Next an exemplary application, which counts the number of calls to operator++ of all
adjacency iterator objects inside dummy algorithm. Here the dummy observer class is