observer.h
#ifndef _OBSERVER_H_
#define _OBSERVER_H_ #include <string>
class Observer {
public:
virtual void update(const std::string &type) = ;
};
#endif
quack_observable.h
#ifndef _QUACK_OBSERVABLE_H_
#define _QUACK_OBSERVABLE_H_ #include "observer.h" class QuackObservable {
public:
virtual void register_observer(Observer *observer) = ;
virtual void notify_observers() = ;
};
#endif
duck.h
#ifndef _DUCK_H_
#define _DUCK_H_ #include "quack_observable.h"
class Duck : public QuackObservable{
public:
virtual void quack() = ;
};
#endif
observable.h
#ifndef _OBSERVABLE_H_
#define _OBSERVABLE_H_ #include "quack_observable.h"
#include <vector> class Observable : public QuackObservable {
private:
std::vector<Observer *> observers;
const std::string type;
public:
Observable( const std::string &_type ) : type(_type) {}
void register_observer(Observer *observer) { observers.push_back( observer ); }
void notify_observers() {
for ( std::vector<Observer *>::iterator it = observers.begin();
it < observers.end();
it ++ ) {
(*it)->update( type );
}
}
};
#endif
mallard_duck.h
#ifndef _MALLARD_DUCK_H_
#define _MALLARD_DUCK_H_ #include <iostream>
#include "duck.h"
#include "observable.h" class MallardDuck : public Duck{
private:
Observable observable;
public:
MallardDuck() :observable("Mallard duck") {}
void quack() { std::cout << "Quack" << std::endl; notify_observers(); }
void register_observer(Observer *observer) { observable.register_observer(observer); }
void notify_observers() { observable.notify_observers(); }
}; #endif
redhead_duck.h
#ifndef _REDHEAD_DUCK_H_
#define _REDHEAD_DUCK_H_ #include <iostream>
#include "duck.h"
#include "observable.h"
class RedheadDuck : public Duck{
private:
Observable observable;
public:
RedheadDuck() :observable("Redhead Duck") {}
void quack() { std::cout << "Quack" << std::endl; notify_observers();}
void register_observer(Observer *observer) { observable.register_observer(observer); }
void notify_observers() { observable.notify_observers(); }
}; #endif
duck_call.h
#ifndef _DUCK_CALL_H_
#define _DUCK_CALL_H_ #include <iostream>
#include "duck.h"
#include "observable.h" class DuckCall : public Duck{
private:
Observable observable;
public:
DuckCall() :observable("Duck call") {}
void quack() { std::cout << "Kwak" << std::endl; notify_observers(); }
void register_observer(Observer *observer) { observable.register_observer(observer); }
void notify_observers() { observable.notify_observers(); }
}; #endif
rubber_duck.h
#ifndef _RUBBER_DUCK_H_
#define _RUBBER_DUCK_H_ #include <iostream>
#include "duck.h"
#include "observable.h"
class RubberDuck : public Duck{
private:
Observable observable;
public:
RubberDuck() :observable("Rubber Duck") {}
void quack() { std::cout << "Squeak" << std::endl; notify_observers();}
void register_observer(Observer *observer) { observable.register_observer(observer); }
void notify_observers() { observable.notify_observers(); }
}; #endif
countable_duck.h
#ifndef _COUNTEABLE_DUCK_H_
#define _COUNTEABLE_DUCK_H_ #include "duck.h"
class CountableDuck : public Duck{
public:
CountableDuck( Duck *_duck ) : duck(_duck) {}
void quack() { duck->quack(); quack_count ++; }
void register_observer(Observer *observer) { duck->register_observer(observer); }
void notify_observers() { duck->notify_observers(); }
static int get_quack_count() { return quack_count; }
private:
Duck *duck;
static int quack_count;
};
#endif
countable_duck.cpp
#include "countable_duck.h" int CountableDuck::quack_count = ;
ivector.h
#ifndef _IVECTOR_H_
#define _IVECTOR_H_ #include <vector>
#include <stdlib.h> template<class T> class IVector {
public:
IVector() : pos() {}
void add( const T& t ) { t_v.push_back(t); }
bool has_next() { return pos < t_v.size(); }
T* next() {
if ( has_next() ) {
return &(t_v[pos++]);
}
return NULL;
}
void back_to_begin() { pos = ; }
private:
int pos;
std::vector<T> t_v;
};
#endif
duck_factory.h
#ifndef _DUCK_FACTORY_H_
#define _DUCK_FACTORY_H_ #include "mallard_duck.h"
#include "redhead_duck.h"
#include "duck_call.h"
#include "rubber_duck.h"
#include "countable_duck.h"
#include <string> class SimpleDuckFactory {
public:
static Duck* create_duck( std::string type ) {
if ( type == "mallard" ) { return new CountableDuck( new MallardDuck ); }
if ( type == "redhead" ) { return new CountableDuck( new RedheadDuck ); }
if ( type == "call" ) { return new CountableDuck( new DuckCall ); }
if ( type == "rubber" ) { return new CountableDuck( new RubberDuck ); }
return NULL;
}
}; class AbstractDuckFactory {
public:
static Duck *create_mallard_duck() { return new CountableDuck( new MallardDuck ); }
static Duck *create_redhead_duck() { return new CountableDuck( new RedheadDuck ); }
static Duck *create_duck_call() { return new CountableDuck( new DuckCall ); }
static Duck *create_rubber_duck() { return new CountableDuck( new RubberDuck ); }
};
#endif
flock.h
#ifndef _FLOCK_H_
#define _FLOCK_H_ #include "duck.h"
#include "ivector.h" class Flock : public Duck{
public:
void quack() {
ducks.back_to_begin();
while( ducks.has_next() ) {
(*(ducks.next()))->quack();
}
}
void add( Duck *duck ) { ducks.add(duck); }
void register_observer(Observer *observer) {
ducks.back_to_begin();
while( ducks.has_next() ) {
(*(ducks.next()))->register_observer(observer);
}
}
void notify_observers() {
ducks.back_to_begin();
while( ducks.has_next() ) {
(*(ducks.next()))->notify_observers();
}
}
private:
IVector<Duck *> ducks;
};
#endif
goose.h
#ifndef _GOOSE_H_
#define _GOOSE_H_ #include <iostream>
class Goose {
public:
void honk() { std::cout << "Honk" << std::endl; }
};
#endif
goose_adapter.h
#ifndef _GOOSE_ADAPTER_H_
#define _GOOSE_ADAPTER_H_ #include "goose.h"
#include "duck.h"
#include "observable.h" class GooseAdapter : public Duck{
public:
GooseAdapter( Goose *_goose ) : goose(_goose), observable("Goose pretending to be a duck") {}
void quack() { goose->honk(); notify_observers();}
void register_observer(Observer *observer) { observable.register_observer(observer); }
void notify_observers() { observable.notify_observers(); }
private:
Goose *goose;
Observable observable;
};
#endif
quackologist.h
#ifndef _QUACK_OLOGIST_H_
#define _QUACK_OLOGIST_H_ #include "observer.h"
#include <iostream>
#include <string> class QuackOlogist : public Observer {
public:
void update(const std::string &type ) { std::cout << "Quackologist: " << type << " just quacked." << std::endl; }
};
#endif
main.cpp
#include "goose_adapter.h"
#include "duck_factory.h"
#include "countable_duck.h"
#include <iostream>
#include "flock.h"
#include "quackologist.h" void simulate(Duck *duck) {
if ( NULL != duck ) { duck->quack(); }
} int main() {
Flock *flock_of_mallard = new Flock;
flock_of_mallard->add( AbstractDuckFactory::create_mallard_duck() );
flock_of_mallard->add( AbstractDuckFactory::create_mallard_duck() ); Flock *flock_of_ducks = new Flock; flock_of_ducks->add( new CountableDuck(new GooseAdapter( new Goose ))); flock_of_ducks->add( AbstractDuckFactory::create_redhead_duck() );
flock_of_ducks->add( AbstractDuckFactory::create_duck_call() );
flock_of_ducks->add( AbstractDuckFactory::create_rubber_duck() ); flock_of_ducks->add( flock_of_mallard ); QuackOlogist quackologist;
flock_of_ducks->register_observer(&quackologist); simulate( flock_of_ducks ); std::cout << "quack count: " << CountableDuck::get_quack_count() << std::endl;
};