//---------------------------15/04/25----------------------------
//Chain of responsibility 责任链-----对象行为型模式
/*
1:意图：
使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。将这些对象
连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。
2:动机：
3:适用性：
1>有多个对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。
2>你想在不明确指定接受者的情况下，向多个对象中的一个 请求提交一个请求。
3>可处理一个请求的对象集合应被动态指定。
4:结构：
Client-------------->Handler:<---------
successor---------|
HandleRequest(){ successor->HandleRequest()}
|
-------------------
| |
ConcreteHandler1: ConcereteHandler2:
HandleRequest() HandleRequest()
{ if can handle
{ do something}
else
{ Handler::HandleRequest()}
}
5:参与者：
1>Handler：
1)定义一个处理请求的接口。
2)(可选)实现后继链。
2>ConcreteHandler
1)处理它所负责的请求。
2)可访问它的后继者。
3)如果可处理该请求，就处理之；否则将该请求转发给它的后继者。
3>Clinet
向链上的具体处理者对象提交请求。
6:协作：
当客户提交一个请求时，请求沿着链传递直至有一个ConcreteHandler对象负责处理它。
7:效果：
优点：
1>降低耦合度：
该模式使得对象无需知道是其他哪一个对象处理其请求。接收者和发送者都没有对方的明确的
信息，且链中的对象不需知道链的结构。
所以责任链可简化对象的相互连接。
2>增强了给对象指派职责的灵活性：
可以在运行时刻动态增加或修改职责。
缺点：
1>不保证被接受。
既然一个请求没有明确的就收者，那么不能保证一定会被处理。
2>当链条太长时，会有效率问题(ps:这一点是我自己加的)
和明确指派任务相比，这么做或多或少会损失点效率，所以不能乱用。
8:实现：
1>实现后继者链：
1)定义新的链接：
没有已有链接时只能自己定义了。
2)使用已有的链接：
如果已经有个链接了，比如说Composite模式中定义了Parent的引用。直接拿来用就行了
也就是把父部件当作后继者，因为责任链一般都是向“上”传递的，也就是越往“上”越普通。
2>链接后继者：
如果是自己定义一个后继者链，Handler不仅要定义接口，通常也要维护链接。也就是要提供一个
缺省实现：向后继者转发请求。
3>表示请求：
1)硬编码：
也就是直接调用，这样只能表示一种请求类型。
2)使用处理函数：
通过传递参数来判断请求的类型。这就需要发送者和接收者在编码问题上达成一致。
9:代码示例： */
//定义了请求的类型
typedef int Topic;
const Topic NO_HELP_TOPIC = -1;
//Handler 定义了各种接口
class HelpHandler
{
public:
HelpHandler(HelpHandler* = 0, Topic = NO_HELP_TOPIC);
virtual bool HasHelp();
virtual void SetHandler(HelpHandler*, Topic);
virtual void HandleHelp();
private:
HelpHandler* _successor;
Topic _topic;
};
HelpHandler::HelpHandler(HelpHandler* h, Topic t)
: _successor(h), _topic(t) {}
bool HelpHandler::hasHelp()
{
return _topic != NO_HELP_TOPIC;
}
//调用后继者的HandleHelp()
void HelpHandler::HandleHelp()
{
if(_successor != 0)
_successor->HandleHelp();
}
//ConcreteHandler中的abstract类 听起来很奇怪，但是就是这样的
//很多东西都有帮助，窗口组件则一般都会有帮助，所以定义一个继承子Handler的abstract 类
//但是它确实也属于Handler的ConcreteHandler类，因为它指定了是窗口组件类。
class Widget : public HelpHandler
{
protected:
Widget(Widget* parent, Topic t = NO_HELP_TOPIC);
private:
Widget* _parent;
};
Widget::Widget(Widget* w, Topic t) : HelpHandler(w, t)
{
_parent = w;
}
//ConcreteHandler： 具体的处理者。
class Button : public Widget
{
public:
Button(Widget* d, Topic t = NO_HELP_TOPIC);
virtual void HandleHelp();
};
Button::Button(Widget* h, Topic t) : Widget(h, t){}
//如果有帮助就调用，否则传递给后继者(如果有的话)。
void Button::HandleHelp()
{
if(HasHelp())
{
//do something
}
else
{
HelpHandler::HandleHelp();
}
}
//ConcreteHandler:类似上面，只不过它后继者可以是任意的帮助类，而不一定只是窗口类
class Dialog : public Widget
{
public:
Dialog(HelpHandler* h, Topic = NO_HELP_TOPIC);
virtual void HandleHelp();
};
Dialog::Dialog(HelpHandler* h, Topic t) : Widget(0)
{
SetHandler(h, t);
}
void Dialog::HandleHelp()
{
if(HasHelp())
{
//do something
}
else
{
HelpHandler::HandleHelp();
}
}
//ConcreteHandler:最后一个节点，没有后继者了。
class Application : public HelpHandler
{
Application(Topic t) : HelpHandler(0, t){}
virtual void HandleHelp();
};
void Application::HandleHelp()
{
//do something
}
const Topic PRINT_TOPIC = 1;
const Topic PAPER_ORIENTATION_TOPIC = 2;
const Topic APPLICATION_TOPIC = 3;
Application* application = new Application(APPLICATION_TOPIC);
Dialog* dialog = new Dialog(application, PRINT_TOPIC);
Button* button = new Button(dialog, PAPER_ORIENTATION_TOPIC);
//这里Button有自己的帮助(PAPER_ORIENTATION_TOPIC)所以会自己处理，并不会交给后继者
//当然如果里面的do something中调用了Handler::HandlerHelp()，那么还是会传递下去的。
button->HandleHelp();