DesignPatterns_Observer

///////////////////////////////////////////////////////////////////////////////
// Observer pattern
// - Define a one-to-many dependency between objects so that when one object
//   changes state, all its dependents are notified and updated automaticaaly.
//
// Author     : ZAsia
// Date       : 15/05/16
// Warning    : In practice, declaration and implementation should
//              be separated(.h and .cpp).
///////////////////////////////////////////////////////////////////////////////
#include 
#include 
#include 
using namespace std;

typedef string State;

#define SAFE_DELETE_PTR(ptr) if (ptr) { delete ptr; ptr = nullptr; }

// forward declaration
class Subject;

// Observer
// - defines an updating interface for objects that should be notified of changes
//   in a subject.
class Observer
{
public:
	virtual ~Observer() { }
	virtual void Update(Subject *theChangedSubject) = 0;
protected:
	Observer() { }
};

// Subject
// - knows its observer. Any number of Obsever objects may observe a subject.
// - provides an interface for attaching and detaching Observer objects.
class Subject
{
public:
	virtual ~Subject() 
	{
		if (_observers)
		{
			delete _observers;
		}
	}

	virtual void Attach(Observer *observer)
	{
		_observers->push_back(observer);
	}

	virtual void Detach(Observer *observer)
	{
		_observers->remove(observer);
	}

	virtual void Notify()
	{
		for (list::iterator iter = _observers->begin();
			iter != _observers->end(); ++iter)
		{
			(*iter)->Update(this);
		}
	}

protected:
	Subject() : _observers(new list) { }

private:
	list *_observers;
};

// ConcreteSubject
// - stores state of interest to ConcreteObserver objects.
// - sends notification to its observers when its state changes.
class ConcreteSubject : public Subject
{
public:
	ConcreteSubject(State state = "") : _state(state) { }

	State GetState()
	{
		return _state;
	}

	void SetState(State state)
	{
		_state = state;
	}

private:
	State _state;
};

// ConcreteObserver
// - maintains a reference to a ConcreteSubject object.
// - stores state that should stay consistent with subjects's.
// - implements the Observer updating interface to keep its state consistent
//   with the subject's.
class ConcreteObserver : public Observer
{
public:
	ConcreteObserver(Subject *subject) : _subject(subject) { }

	virtual void Update(Subject *theChangedSubject)
	{
		cout << "ConcreteObserver::Update--> now state is "
			<< dynamic_cast(theChangedSubject)->GetState()
			<< endl;
	}
private:
	Subject *_subject;
};

// collaborations
// - ConcreteSubject notifies its observers whenever a change occurs that could
//   make its observers' state inconsistent with its own.
// - After being informed of a change in the concrete subject, a ConcreteObserver
//   object may query the subject for information. ConcreteObserver uses this
//   information to reconcile its state with that of the subject.
// - Note how the Observer object that initiates the change request postpones its
//   update until it gets a notification from the subject. Notify is not always
//   called by the subject. It can be called by an observer or by another kind of
//   object entirely.
int main()
{
	ConcreteSubject *pConcreteSubject = new ConcreteSubject();

	Observer *pObserverA = new ConcreteObserver(pConcreteSubject);
	Observer *pObserverB = new ConcreteObserver(pConcreteSubject);

	pConcreteSubject->Attach(pObserverA);
	pConcreteSubject->Attach(pObserverB);

	pConcreteSubject->SetState("student");
	pConcreteSubject->Notify();

	pConcreteSubject->Detach(pObserverB);

	pConcreteSubject->SetState("worker");
	pConcreteSubject->Notify();

	SAFE_DELETE_PTR(pConcreteSubject);
	SAFE_DELETE_PTR(pObserverA);
	SAFE_DELETE_PTR(pObserverB);

	return 0;
}

////////////////////////////////////////////////////////////////////////////////
// 1. All a subject knows is that it has a list of observers, each conforming to
//    the simple interface of the abstract Observer class.