// Purpose. Observer class Obs;
//
// Discussion. On the left: Subject class Subject {
// has hard-wired the number and type public:
// of "dependent" objects, the compil- Subject();
// er must have the declaration of the void attach( Obs* );
// concrete Obs classes to compile void setVal( int );
// Subject's decl, the Obs classes ex- int getVal();
// ercise no reuse of i/f or impl, and void notify();
// Subject "pushes" updates to the Obs private:
// objects. On the right: Subject is Obs* obs_[10];
// decoupled from the number, type, int num_, val_;
// and declaration of concrete Obs };
// subclasses; the Obs objects accept
// polymorphism; and Subject broad- class Obs { public:
// casts that a change has occurred virtual void update() = 0;
// followed by Obs objects requesting protected:
// just the info that they want. Subject* sub_;
int div_;
class DivObs { public: };
DivObs( int ); class DivObs : public Obs { public:
void update( int ); DivObs( Subject*, int );
private: void update();
int div_; };
}; class ModObs : public Obs { public:
class ModObs { public: ModObs( Subject*, int );
ModObs( int ); void update();
void update( int ); };
private:
int div_; Subject::Subject() { num_ = 0; }
}; int Subject::getVal() { return val_; }
void Subject::attach( Obs* o ) {
class Subject { obs_[num_++] = o; }
public: void Subject::setVal( int v ) {
Subject(); val_ = v; notify(); }
void setVal( int ); void Subject::notify() {
private: for (int i=0; i < num_; i++)
int val_; obs_[i]->update(); }
DivObs div_;
ModObs mod_; DivObs::DivObs( Subject* s, int d ) {
}; sub_ = s; div_ = d;
sub_->attach( this ); }
Subject::Subject() : div_(4), mod_(3) void DivObs::update() {
{ } int v = sub_->getVal();
void Subject::setVal( int v ) { cout << v << " div " << div_
val_ = v; << " is " << v / div_ << endl; }
div_.update( val_ ); ModObs::ModObs( Subject* s, int d ) {
mod_.update( val_ ); } sub_ = s; div_ = d;
sub_->attach( this ); }
DivObs::DivObs( int d ) { div_ = d; } void ModObs::update() {
void DivObs::update( int v ) { int v = sub_->getVal();
cout << v << " div " << div_ cout << v << " mod " << div_
<< " is " << v / div_ << endl; } << " is " << v % div_ << endl; }
ModObs::ModObs( int d ) { div_ = d; }
void ModObs::update( int v ) { void main( void )
cout << v << " mod " << div_ {
<< " is " << v % div_ << endl; } Subject subj;
DivObs divObs1( &subj, 4 );
void main( void ) DivObs divObs2( &subj, 3 );
{ ModObs modObs3( &subj, 3 );
Subject subj; subj.setVal( 14 );
subj.setVal( 14 ); }
}
// 14 div 4 is 3
// 14 div 4 is 3 // 14 div 3 is 4
// 14 mod 3 is 2 // 14 mod 3 is 2




// Purpose. Observer design pattern

// 1. Model the "independent" functionality with a "subject" abstraction
// 2. Model the "dependent" functionality with "observer" hierarchy
// 3. The Subject is coupled only to the Observer base class
// 4. Observers register themselves with the Subject
// 5. The Subject broadcasts events to all registered Observers
// 6. Observers "pull" the information they need from the Subject
// 7. Client configures the number and type of Observers

#include <iostream>
#include <vector>
using namespace std;

class Subject { // 1. "independent" functionality
vector<class Observer*> views; // 3. Coupled only to "interface"
int value;
public:
void attach( Observer* obs ) { views.push_back( obs ); }
void setVal( int val ) { value = val; notify(); }
int getVal() { return value; }
void notify();
};

class Observer { // 2. "dependent" functionality
Subject* model;
int denom;
public:
Observer( Subject* mod, int div ) {
model = mod; denom = div;
// 4. Observers register themselves with the Subject
model->attach( this );
}
virtual void update() = 0;
protected:
Subject* getSubject() { return model; }
int getDivisor() { return denom; }
};

void Subject::notify() { // 5. Publisher broadcasts
for (int i=0; i < views.size(); i++) views[i]->update();
}

class DivObserver : public Observer { public:
DivObserver( Subject* mod, int div ) : Observer(mod,div) { }
void update() { // 6. "Pull" information of interest
int v = getSubject()->getVal(), d = getDivisor();
cout << v << " div " << d << " is " << v / d << '\n';
} };

class ModObserver : public Observer { public:
ModObserver( Subject* mod, int div ) : Observer(mod,div) { }
void update() {
int v = getSubject()->getVal(), d = getDivisor();
cout << v << " mod " << d << " is " << v % d << '\n';
} };

void main( void ) {
Subject subj;
DivObserver divObs1( &subj,4 ); // 7. Client configures the number and
DivObserver divObs2( &subj,3 ); // type of Observers
ModObserver modObs3( &subj,3 );
subj.setVal( 14 );
}

// 14 div 4 is 3
// 14 div 3 is 4
// 14 mod 3 is 2




// Purpose. Observer design pattern, class inheritance vs type inheritance

// SensorSystem is the "subject". Lighting, Gates, and Surveillance are the
// "views". The subject is only coupled to the "abstraction" of AlarmListener.

// An object's class defines how the object is implemented. In contrast, an
// object's type only refers to its interface. Class inheritance defines an
// object's implementation in terms of another object's implementation. Type
// inheritance describes when an object can be used in place of another.
// [GoF, pp13-17]

#include <iostream>
#include <vector>
using namespace std;

class AlarmListener { public: virtual void alarm() = 0; };

class SensorSystem {
vector<AlarmListener*> listeners;
public:
void attach( AlarmListener* al ) { listeners.push_back( al ); }
void soundTheAlarm() {
for (int i=0; i < listeners.size(); i++)
listeners[i]->alarm();
} };

class Lighting : public AlarmListener {
public: /*virtual*/ void alarm() { cout << "lights up" << '\n'; }
};

class Gates : public AlarmListener {
public: /*virtual*/ void alarm() { cout << "gates close" << '\n'; }
};

class CheckList {
virtual void localize() { cout << " establish a perimeter" << '\n'; }
virtual void isolate() { cout << " isolate the grid" << '\n'; }
virtual void identify() { cout << " identify the source" << '\n'; }
public:
void byTheNumbers() { // Template Method design pattern
localize();
isolate();
identify();
} };
// class inheri. // type inheritance
class Surveillance : public CheckList, public AlarmListener {
/*virtual*/ void isolate() { cout << " train the cameras" << '\n'; }
public:
/*virtual*/ void alarm() {
cout << "Surveillance - by the numbers:" << '\n';
byTheNumbers();
} };

void main( void ) {
SensorSystem ss;
ss.attach( &Gates() );
ss.attach( &Lighting() );
ss.attach( &Surveillance() );
ss.soundTheAlarm();
}

// gates close
// lights up
// Surveillance - by the numbers:
// establish a perimeter
// train the cameras
// identify the source




// Purpose. Observer and Mediator demo
//
// Observer - 1. Sender is coupled to a Receiver interface
// 2. Receivers register with Sender
// 3. Sender broadcasts (in the blind) to all Receivers
//
// Mediator - 4. Sender(s) has handle to Mediator
// 5. Mediator has handle to Receiver(s)
// 6. Sender(s) sends to Mediator
// 7. Mediator sends to Receiver(s)

#include <iostream>
#include <vector>
using namespace std;
void gotoxy( int, int );

class Observer { public: virtual void update( int ) = 0; };

class Mediator {
vector<Observer*> groups[3]; // 1. Sender is coupled to an interface
public:
enum Message { ODD, EVEN, THREE }; // 1. Sender is coupled to an interface
void attach( Observer* o, Message type ) { groups[type].push_back( o ); }
void disseminate( int num ) {
if (num % 2 == 1) // odd // 3,7. Sender/Mediator broadcasts
for (int i=0; i < groups[0].size(); i++) groups[0][i]->update(num);
else // even
for (int i=0; i < groups[1].size(); i++) groups[1][i]->update(num);
if (num % 3 == 0) // /3
for (int i=0; i < groups[2].size(); i++) groups[2][i]->update(num);
} };

class OddObserver : public Observer {
int col, row;
public:
OddObserver( Mediator& med, int c ) {
col = c; row = 3;
gotoxy( col, 1 ); cout << "Odd";
gotoxy( col, 2 ); cout << "---";
med.attach( this, Mediator::ODD ); // 2,5. Receivers register with Sender
}
void update( int num ) { gotoxy( col, row++ ); cout << num; }
};

class EvenObserver : public Observer {
int col, row;
public:
EvenObserver( Mediator& med, int c ) {
col = c; row = 3;
gotoxy( col, 1 ); cout << "/2";
gotoxy( col, 2 ); cout << "--";
med.attach( this, Mediator::EVEN );
}
void update( int num ) { gotoxy( col, row++ ); cout << num; }
};

class ThreeObserver : public Observer {
int col, row;
public:
ThreeObserver( Mediator& med, int c ) {
col = c; row = 3;
gotoxy( col, 1 ); cout << "/3";
gotoxy( col, 2 ); cout << "--";
med.attach( this, Mediator::THREE );
}
void update( int num ) { gotoxy( col, row++ ); cout << num; }
};

class Publisher { public: // 6. Sender sends to Mediator
Publisher( Mediator& med ) { for (int i=1; i < 10; i++) med.disseminate(i); }
};

void main( void ) {
Mediator mediator;
OddObserver( mediator, 1 );
EvenObserver( mediator, 11 );
ThreeObserver( mediator, 21 );
Publisher producer( mediator ); // 4. Sender has handle to Mediator
}

// Odd /2 /3
// --- -- --
// 1 2 3
// 3 4 6
// 5 6 9
// 7 8
// 9




// Purpose. TypedMessage - embellished Observer, decoupled messaging
//
// Messages inherit from TypedMessage<self>
// Message listeners inherit from many Message::Handlers
// Application tells message to publish/broadcast/notify
// Messages are the subject (receive registrations from subscribers)
// Subsystems are the observers (receive broadcast messages)
// TypedMessage accomodates everything: registration, containment, and
// notification of observers

#include <iostream>
#include <vector>
#include <string>
using namespace std;

template <class T>
class TypedMessage {
static vector<Handler*> registry;
public:
class Handler {
public:
Handler() { TypedMessage<T>::registerHandler( this ); }
virtual void handleEvent( const T* t ) = 0;
};
void notify() {
for (int i=0; i < registry.size(); i++)
registry.at(i)->handleEvent( (T*)this );
}
static void registerHandler( Handler* h ) { registry.push_back( h ); }
};

class On : public TypedMessage<On> {
string comment;
public:
On( string str ) { comment = str; }
void start() const { cout << "OnEvent.start - " << comment << '\n'; }
};
vector<TypedMessage<On>::Handler*> TypedMessage<On>::registry;

class Off : public TypedMessage<Off> {
string comment;
public:
Off( string str ) { comment = str; }
void stop() const { cout << "OffEvent.stop - " << comment << '\n'; }
};
vector<TypedMessage<Off>::Handler*> TypedMessage<Off>::registry;

class MasterConsole : public On::Handler, public Off::Handler { public:
void handleEvent( const On* msg ) {
cout << "MasterConsole - "; msg->start(); }
void handleEvent( const Off* msg ) {
cout << "MasterConsole - "; msg->stop(); }
};

class PowerMonitor : public On::Handler { public:
void handleEvent( const On* msg ) {
cout << "PowerMonitor - "; msg->start(); }
};

void main( void ) {
MasterConsole mc;
PowerMonitor pm;
On oneEvent( "lights" ); Off thrEvent( "elevators" );
On twoEvent( "hvac" ); Off fouEvent( "frontDoor" );
oneEvent.notify(); twoEvent.notify();
thrEvent.notify(); fouEvent.notify();
}

// MasterConsole - OnEvent.start - lights
// PowerMonitor - OnEvent.start - lights
// MasterConsole - OnEvent.start - hvac
// PowerMonitor - OnEvent.start - hvac
// MasterConsole - OffEvent.stop - elevators
// MasterConsole - OffEvent.stop - frontDoor