DesignPatterns_Mediator

/
// Mediator pattern
// - Define an object that encapsulates how a set of objects interact. Mediator promotes
//   loose coupling by keeping objects from referring to each other explicitly, and it
//   lets you vary their interaction independently.
// 
// Author     : ZAsia
// Date       : 15/05/15
// Warning    : In practice, declaration and implementation should
//              be separated(.h and .cpp).
/
#include 
   
   
    
    
using namespace std;

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

// forward declaraction
class Mediator;

// Colleague classes
// - each Colleague class knows its Mediator object.
// - each colleague communicates with its mediator whenever it would have
//   otherwise communicated with another colleague.
class Colleague
{
public:
	virtual void SendNotification(const char *message) = 0;
	virtual void HandleNotification(const char *message) = 0;
protected:
	Colleague(Mediator *mediator) : _mediator(mediator) { }
	Mediator *_mediator;
};

class ConcreteColleague1 : public Colleague
{
public:
	ConcreteColleague1(Mediator *mediator) : Colleague(mediator) { }

	// define after ConcreteMediator is defined
	virtual void SendNotification(const char *message);	 

	virtual void HandleNotification(const char *message)
	{
		cout << "ConcreteColleague1 --> has received the message \""
			<< message << "\" , is handling it..." << endl;
	}
};

class ConcreteColleague2 : public Colleague
{
public:
	ConcreteColleague2(Mediator *mediator) : Colleague(mediator) { }

	// define after ConcreteMediator is defined
	virtual void SendNotification(const char *message);

	virtual void HandleNotification(const char *message)
	{
		cout << "ConcreteColleague2 --> has received the message \""
			<< message << "\" , is handling it..." << endl;
	}
};

// Mediator
// - defines an interface for communicating with Colleague objects.
class Mediator
{
public:
	virtual ~Mediator() { }
	virtual void SendNotification(const char *message, Colleague *colleage) = 0;
};

// ConcreteMediator
// - implements cooperative behavior by coordinating Colleague objects.
// - knows and maintains its colleagues.
class ConcreteMediator : public Mediator
{
public:
	ConcreteMediator() : _colleague1(nullptr), _colleague2(nullptr) { }

	void SetColleagues(Colleague *colleague1, Colleague *colleague2)
	{
		_colleague1 = colleague1;
		_colleague2 = colleague2;
	}

	virtual void SendNotification(const char *message, Colleague *colleague)
	{
		if (typeid(*colleague) == typeid(ConcreteColleague1))
		{
			cout << "ConcreteMediator --> routing the message \""
				<< message << "\" to ConcreteColleague2" << endl;
			_colleague2->HandleNotification(message);
		}
		else if (typeid(*colleague) == typeid(ConcreteColleague2))
		{
			cout << "ConcreteMediator --> routing the message \""
				<< message << "\" to ConcreteColleague1" << endl;
			_colleague1->HandleNotification(message);
		}
	}

private:
	Colleague *_colleague1;
	Colleague *_colleague2;
};

void ConcreteColleague1::SendNotification(const char *message)
{
	_mediator->SendNotification(message, this);
}

void ConcreteColleague2::SendNotification(const char *message)
{
	_mediator->SendNotification(message, this);
}

// Collaborations
// - Colleagues send and receive requests form a Mediator object. The mediator
//   implements the cooperative behavior by routing requests between the 
//   appropriate colleague(s).
int main()
{
	Mediator *pMediator = new ConcreteMediator();
	Colleague *pColleague1 = new ConcreteColleague1(pMediator);
	Colleague *pColleague2 = new ConcreteColleague2(pMediator);
	dynamic_cast
    
    
     
     (pMediator)->SetColleagues(pColleague1, pColleague2);

	pColleague1->SendNotification("Hi, I'm colleague1");
	pColleague2->SendNotification("Hi, I'm colleague2");

	SAFE_DELETE_PTR(pMediator);
	SAFE_DELETE_PTR(pColleague1);
	SAFE_DELETE_PTR(pColleague2);

	return 0;
}