职责链模式

        避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止，这就是职责链模式。

#include "stdafx.h"
#include <iostream>
#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>
#include <string>
using namespace boost;

//职责链模式就是一个请求提交给
//职责链中一连串的对象，如果遇到了
//符合处理条件的对象，就处理该请求
//否则就将请求交于该职责链中对象
//的后续对象进行处理,直到遇到符合请求
//条件的对象处理为止
class Request
{
public:
	Request(){}
	Request(const int &data){_m_nData = data;}
	virtual ~Request(){}
	int getData(){return _m_nData;}
protected:
	int _m_nData;
};
//职责链对象基类
class Handler
{
public:
	//处理Request类型对象的请求
	virtual void HandleRequest(shared_ptr<Request>) = 0;
	//设置下一个处理
	virtual void setNextHandler(shared_ptr<Handler> handler)
	{
		_m_Handler = handler;
	}
public:
	shared_ptr<Handler> _m_Handler;
};
class Handler1 : public Handler
{
public:
	virtual void HandleRequest(shared_ptr<Request> request)
	{
		if (request->getData() < 3)
		{
			std::cout << "Handle1 handled the request." << std::endl; 
		}
		else
		{
			this->_m_Handler->HandleRequest(request);
		}
	}
};

class Handler2 : public Handler
{
public:
	virtual void HandleRequest(shared_ptr<Request> request)
	{
		if (request->getData() < 7)
		{
			std::cout << "Handle2 handled the request." << std::endl; 
		}
		else
		{
			this->_m_Handler->HandleRequest(request);
		}
	}
};

class Handler3 : public Handler
{
public:
	virtual void HandleRequest(shared_ptr<Request> request)
	{
		if (request->getData() < 30)
		{
			std::cout << "Handle3 handled the request." << std::endl; 
		}
		else
		{
			std::cout << "Handle3 handled the request:don't agree." << std::endl; 
		}
	}
};

void testChainOfResponsibility()
{
	shared_ptr<Request> request1 = make_shared<Request>(2);
	auto request2 = make_shared<Request>(4);
	auto request3 = make_shared<Request>(6);
	auto request4 = make_shared<Request>(31);
	auto handler1 = make_shared<Handler1>();
	auto handler2 = make_shared<Handler2>();
	auto handler3 = make_shared<Handler3>();
	handler1->setNextHandler(handler2);
	handler2->setNextHandler(handler3);
	handler1->HandleRequest(request1);
 	handler1->HandleRequest(request2);
	handler1->HandleRequest(request3);
	handler1->HandleRequest(request4);

}