Mediator 中介者模式

中介者模式主要用于对象之间的通信

Mediator.h文件：

#include "stdafx.h"
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>
#include <string>
#include <iostream>
#include <boost/format.hpp>
#include <boost/enable_shared_from_this.hpp>

using namespace boost;

typedef std::string ColleageAData;
typedef long ColleageBData;

class Mediator;

class Colleage
{
protected:
	shared_ptr<Mediator> _m_mediator;
};

class ColleageA : public Colleage
{
public:
	ColleageA(){m_data = "asdf";m_recvBData = 0;};
	void setMediator(shared_ptr<Mediator> mediator);
	void sendDataToColleageB(ColleageAData data);

	void setData(ColleageAData data){m_data = data;}
	ColleageAData getData(){return m_data;}

	void showInfo()
	{
		std::cout << "A:" << m_data << "B:" << m_recvBData << std::endl;
	}
public:
	ColleageBData m_recvBData;
	ColleageAData m_data;
};

class ColleageB : public Colleage
{
public:
	ColleageB(){m_data = 1113;m_recvAData = "null";}
	void setMediator(shared_ptr<Mediator> mediator);
	void sendDataToColleageA(ColleageBData data);
	void setData(ColleageBData data){m_data = data;}
	ColleageBData getData(){return m_data;}
	void showInfo()
	{
		std::cout << "B:" << m_data << "A:" << m_recvAData << std::endl;
	}
public:
	ColleageAData m_recvAData;
	ColleageBData m_data;
};

class Mediator
{
public:
	Mediator(){}
	virtual ~Mediator(){}
	Mediator(shared_ptr<ColleageA> a,shared_ptr<ColleageB> b)
	{
		_m_A = a;
		_m_B = b;
	}

	void AsendtoB(ColleageAData dataA);

	void BsendtoA(ColleageBData dataB);

	void setA(shared_ptr<ColleageA> a)
	{
		_m_A = a;
	}

	void setB(shared_ptr<ColleageB> b)
	{
		_m_B = b;
	}

protected:
	//该中介者用于处理A和B
	shared_ptr<ColleageA> _m_A;
	shared_ptr<ColleageB> _m_B;
};

Mediator.cpp文件：

#include "stdafx.h"
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>
#include <string>
#include <iostream>
#include <boost/format.hpp>
#include <boost/enable_shared_from_this.hpp>
#include "Mediator.h"

using namespace boost;

void Mediator::AsendtoB(ColleageAData dataA)
{
	_m_B->m_recvAData = dataA;
}

void Mediator::BsendtoA(ColleageBData dataB)
{
	_m_A->m_recvBData = dataB;
}
void ColleageA::setMediator(shared_ptr<Mediator> mediator)
{
	_m_mediator = mediator;
}
void ColleageA::sendDataToColleageB(ColleageAData data)
{
	_m_mediator->AsendtoB(data);
}
void ColleageB::setMediator(shared_ptr<Mediator> mediator)
{
	_m_mediator = mediator;
}
void ColleageB::sendDataToColleageA(ColleageBData data)
{
	_m_mediator->BsendtoA(data);
}


void testMediatorMode()
{
	shared_ptr<ColleageA> a = make_shared<ColleageA>();
	auto b = make_shared<ColleageB>();
	auto mediator = make_shared<Mediator>();
	a->setMediator(mediator);
	b->setMediator(mediator);
	mediator->setA(a);
	mediator->setB(b);
	a->showInfo();
	b->showInfo();
 	a->sendDataToColleageB(a->getData());
	a->showInfo();
	b->showInfo();
	b->sendDataToColleageA(b->getData());
	a->showInfo();
	b->showInfo();
}