action是用来解析完成以后执行某种动作的类，所有的action类使用起来的形式为parser[action]。
一望而知，parser类必定实现了一个operator[]。这个函数实现在基类parser中，被所有的parser继承。
template <typename ActionT>
action<DerivedT, ActionT>
operator[](ActionT const& actor) const
{
return action<DerivedT, ActionT>(derived(), actor);
}
parser::operator[]有一个参数actor，就是解析成功以后调用的动作函数，是一个function object。
返回模板类action的一个对象。
action模板类实际上是一个标准的装饰器（decorator）模式的实现。回想一下decorator的定义：继承一个类的接口，并给这个类动态透明的添加职责。
对于parser来说，它是完全无须知道action的存在的。action本身继承自parser，实现了parse接口，在parse中，在调用了parser本身的parse功能以后，以parse_result为参数调用actor.operator()(result)。
看看action::parse的实现：
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
{
typedef typename ScannerT::iterator_t iterator_t;
typedef typename parser_result<self_t, ScannerT>::type result_t;
scan.at_end(); // allow skipper to take effect
iterator_t save = scan.first;
//调用subject(parser)的parse方法做解析工作。
result_t hit = this->subject().parse(scan);
//如果解析成功，执行actor动作。通过调用scan.do_action方法实现，具体实现见后。
if (hit)
{
typename result_t::return_t val = hit.value();
scan.do_action(actor, val, save, scan.first);
}
return hit;
}
可以看出，action给parser添加的职责是调用scanner::do_action来实现的，可以回忆一下scanner的action_policy。 实际上，scanner是通过继承action_policy类来继承do_action方法的。
struct action_policy
{
template <typename ActorT, typename AttrT, typename IteratorT>
void
do_action(
ActorT const& actor,
AttrT& val,
IteratorT const& first,
IteratorT const& last) const
{
attributed_action_policy<AttrT>::call(actor, val, first, last);
}
};
调用流转到了模板类attributed_action_policy，这个模板类有两个特化版本：
// 对于有Attribute的parser而言，（比如primitives）可以推导出确定的AttrT，调用这个版本。最终调用actor.operator()(val)。这个时候，需要提供的actor是接受一个确定类型参数(parser解析得到的结果类型)的function object。
template <typename AttrT>
struct attributed_action_policy
{
template <typename ActorT, typename IteratorT>
static void
call(
ActorT const& actor,
AttrT& val,
IteratorT const&,
IteratorT const&)
{
actor(val);
}
};
//对于没有Attribute的parser(比如composite)，AttrT=nil_t，调用这个版本，这个时候调用actor.operator(first, last)；这个时候，需要提供的actor是接受一对迭代器的function object。
template <>
struct attributed_action_policy<nil_t>
{
template <typename ActorT, typename IteratorT>
static void
call(
ActorT const& actor,
nil_t,
IteratorT const& first,
IteratorT const& last)
{
actor(first, last);
}
};
spirit中定义了很多actors，这个actor都实现了operator(AttrT)或是operator(IteratorT, IteratorT)。
spirit实现了5类actor：
实际上，这5类actor都是模板类，都有一个模板参数ActionT，而且都从ActionT继承。actor和ActionT的功能完全正交；actor的功能是决定如何操作三类对象，而ActionT提供实际的操作方式。
actor要操作的三类对象有：
1． 目的对象(actor操作的对象)：这个对象一般作为actor的成员
2． 源对象(parse的结果)：这个对象一般作为operator()函数的参数
3． 其他对象（这些对象作为function object的附加参数）：这些对象一般作为actor的成员
通过继承模板参数类的方式：
template <typename ActionT>
struct any_actor : public ActionT { /*…*/ };
将ActionT的功能混入(mixin) actor中；通过用不同的ActionT实例化actor类，使actor得到不同的操作能力。各种ActionT与各种actor之间的任意混合，我们只需实现n种actor和m种ActionT，就能得到n*m个actor<ActionT>类。
1． ref_actor：只持有目的对象，在operator()中忽略源对象。适合混入只操作一个单一引用的ActionT，比如increment_action。
2． ref_value_actor：最为常用，持有目的对象，并在operator()中引用源对象；适合混入标准ActionT，操作两个引用对象。比如assign_action。
3． ref_const_ref_actor：持有目的和其他对象，在operator()忽略源对象。当然源对象也可以作为其他对象使用，不过需要在构造的时候传入，并不是在operator()中引用。混入的ActionT需要接受两个引用参数。
4． ref_const_ref_value_actor：持有目的对象和其他对象，并且在operator()中引用源对象，混入的ActionT接受三个参数。
5． ref_const_ref_const_ref_actor：持有目的对象和两个其他对象，但是在operator()忽略源对象，混入的ActionT需接受三个参数。
|