简单状态机
简单状态机按照如下工作流程：
它包括一个初始化伪状态，一个正常状态和一个结束状态。如下代码是上述图表中流程的一种实现。
#include <iostream>
#include <boost/msm/back/state_machine.hpp>
#include <boost/msm/front/state_machine_def.hpp>
#include <boost/msm/front/functor_row.hpp>
namespace {
namespace msm = boost::msm;
namespace msmf = boost::msm::front;
namespace mpl = boost::mpl;
// ----- Events
struct Event1 {};
// ----- State machine
struct Sm1_:msmf::state_machine_def<Sm1_>
{
// States
struct State1:msmf::state<>
{
// Entry action
template <class Event,class Fsm>
void on_entry(Event const&, Fsm&) const {
std::cout << "State1::on_entry()" << std::endl;
}
// Exit action
template <class Event,class Fsm>
void on_exit(Event const&, Fsm&) const {
std::cout << "State1::on_exit()" << std::endl;
}
};
struct End:msmf::terminate_state<> {};
// Set initial state
typedef State1 initial_state;
// Transition table
struct transition_table:mpl::vector<
// Start Event Next Action Guard
msmf::Row < State1, Event1, End, msmf::none, msmf::none >
> {};
};
// Pick a back-end
typedef msm::back::state_machine<Sm1_> Sm1;
void test()
{
Sm1 sm1;
sm1.start();
std::cout << "> Send Event1" << std::endl;
sm1.process_event(Event1());
}
}
int main()
{
test();
return 0;
}
// Output:
//
// State1::on_entry()
// > Send Event1
// State1::on_exit()
Sm1_ 是一个状态机的定义，在 Sm1_，有两个状态，state1 和 End。初始伪状态是定义在一下代码行：
typedef State1 initial_state;
此初始状态类型定义意味着状态机 Sm1 从状态 State1 开始。
考虑如下图表：
从初始状态转变到 State1 有一个动作。为了实现这种类型的状态机，你需要额外的代码。
A transition from an initial pseudo state to State1 has an action. To implement this kind of state machine, you need additional codes.
初始状态转换的动作
如下图表和代码展示了如何实现一个初始状态转变的动作：
在如下代码片段中，此初始状态类型定义仅仅表明状态机从State1开始，此初始状态定义并没有引入一个初始伪状态。
// Set initial state
typedef State1 initial_state;
为了实现从 State1 和 初始伪状态转换的转换动作，需要在代码中定义初始伪状态。Boost.Msm 不能直接支持初始伪状态，但是可以用一个正常状态来替代。则将原始图表改写为如下图表：
你不必写此模型，此模型的目的在于帮助你更好理解下面的代码的实现过程：
#include <iostream>
#include <boost/msm/back/state_machine.hpp>
#include <boost/msm/front/state_machine_def.hpp>
#include <boost/msm/front/functor_row.hpp>
namespace {
namespace msm = boost::msm;
namespace msmf = boost::msm::front;
namespace mpl = boost::mpl;
// ----- Events
struct Event1 {};
// ----- State machine
struct Sm1_:msmf::state_machine_def<Sm1_>
{
// States
struct Init:msmf::state<> {};
struct State1:msmf::state<>
{
// Entry action
template <class Event,class Fsm>
void on_entry(Event const&, Fsm&) {
std::cout << "State1::on_entry()" << std::endl;
}
// Exit action
template <class Event,class Fsm>
void on_exit(Event const&, Fsm&) {
std::cout << "State1::on_exit()" << std::endl;
}
};
// Set initial state
typedef Init initial_state;
// Actions
struct InitAction {
template <class Event, class Fsm, class SourceState, class TargetState>
void operator()(Event const&, Fsm&, SourceState&, TargetState&) const
{
std::cout << "InitAction()" << std::endl;
}
};
// Transition table
struct transition_table:mpl::vector<
// Start Event Next Action Guard
msmf::Row < Init, msmf::none, State1, InitAction, msmf::none >,
msmf::Row < State1, Event1, State1, msmf::none, msmf::none >
> {};
};
// Pick a back-end
typedef msm::back::state_machine<Sm1_> Sm1;
void test()
{
Sm1 sm1;
sm1.start();
std::cout << "> Send Event1" << std::endl;
sm1.process_event(Event1());
}
}
int main()
{
test();
return 0;
}
// Output:
//
// InitAction()
// State1::on_entry()
// > Send Event1
// State1::on_exit()
// State1::on_entry()
看下面代码行：
msmf::Row < Init, msmf::none, State1, InitAction, msmf::none >,
这是一个状态转换表行。这里最重要的是其事件为msmf::none。这意味着当状态机处于Init状态时，自动触发从 Init 到 state1 的转换。
明确地指定的事件句柄
Boost.Msm的事件句柄能够重载。on_entry 和 on_exit 动作的句柄可以通过事件类型匹配。守卫条件和动作因子能够通过 Event，SourceState 和 TargetState 来匹配。
让我们看如下图表：
所有的转变都有同样的守卫条件和动作因子。
以上图表的代码实现如下：
#include <iostream>
#include <boost/msm/back/state_machine.hpp>
#include <boost/msm/front/state_machine_def.hpp>
#include <boost/msm/front/functor_row.hpp>
namespace {
namespace msm = boost::msm;
namespace msmf = boost::msm::front;
namespace mpl = boost::mpl;
// ----- Events
struct Event1 {};
struct Event2 {};
struct InitialEvent {};
// ----- State machine
struct Sm1_:msm::front::state_machine_def<Sm1_>
{
typedef InitialEvent initial_event;
// States
struct State1:msm::front::state<>
{
// Entry action
template <class Fsm>
void on_entry(InitialEvent const&, Fsm&) const {
std::cout << "State1::on_entry(InitialEvent)" << std::endl;
}
template <class Fsm>
void on_entry(Event1 const&, Fsm&) const {
std::cout << "State1::on_entry(Event1)" << std::endl;
}
template <class Fsm>
void on_entry(Event2 const&, Fsm&) const {
std::cout << "State1::on_entry(Event2)" << std::endl;
}
// Exit action
template <class Fsm>
void on_exit(Event1 const&, Fsm&) const {
std::cout << "State1::on_exit(Event1)" << std::endl;
}
template <class Fsm>
void on_exit(Event2 const&, Fsm&) const {
std::cout << "State1::on_exit(Event2)" << std::endl;
}
};
struct State2:msm::front::state<>
{
// Entry action
template <class Fsm>
void on_entry(Event1 const&, Fsm&) const {
std::cout << "State2::on_entry(Event1)" << std::endl;
}
template <class Fsm>
void on_entry(Event2 const&, Fsm&) const {
std::cout << "State2::on_entry(Event2)" << std::endl;
}
// Exit action
template <class Fsm>
void on_exit(Event1 const&, Fsm&) const {
std::cout << "State2::on_exit(Event1)" << std::endl;
}
template <class Fsm>
void on_exit(Event2 const&, Fsm&) const {
std::cout << "State2::on_exit(Event2)" << std::endl;
}
};
struct Action1 {
template <class Fsm>
void operator()(Event1 const& e, Fsm&, State1&, State2&) const
{
std::cout << "Action1(Event1, Fsm, State1, State2)" << std::endl;
}
template <class Fsm>
void operator()(Event2 const& e, Fsm&, State1&, State2&) const
{
std::cout << "Action1(Event2, Fsm, State1, State2)" << std::endl;
}
template <class Fsm>
void operator()(Event1 const& e, Fsm&, State2&, State1&) const
{
std::cout << "Action1(Event1, Fsm, State2, State1)" << std::endl;
}
template <class Fsm>
void operator()(Event2 const& e, Fsm&, State2&, State1&) const
{
std::cout << "Action1(Event2, Fsm, State2, State1)" << std::endl;
}
};
struct Guard1 {
template <class Fsm>
bool operator()(Event1 const& e, Fsm&, State1&, State2&) const
{
std::cout << "Guard1(Event1, Fsm, State1, State2)" << std::endl;
return true;
}
template <class Fsm>
bool operator()(Event2 const& e, Fsm&, State1&, State2&) const
{
std::cout << "Guard1(Event2, Fsm, State1, State2)" << std::endl;
return true;
}
template <class Fsm>
bool operator()(Event1 const& e, Fsm&, State2&, State1&) const
{
std::cout << "Guard1(Event1, Fsm, State2, State1)" << std::endl;
return true;
}
template <class Fsm>
bool operator()(Event2 const& e, Fsm&, State2&, State1&) const
{
std::cout << "Guard1(Event2, Fsm, State2, State1)" << std::endl;
return true;
}
};
// Set initial state
typedef State1 initial_state;
// Transition table
struct transition_table:mpl::vector<
// Start Event Next Action Guard
msmf::Row < State1, Event1, State2, Action1, Guard1 >,
msmf::Row < State1, Event2, State2, Action1, Guard1 >,
msmf::Row < State2, Event1, State1, Action1, Guard1 >,
msmf::Row < State2, Event2, State1, Action1, Guard1 >
> {};
};
// Pick a back-end
typedef msm::back::state_machine<Sm1_> Sm1;
void test()
{
Sm1 sm1;
sm1.start();
std::cout << "> Send Event1" << std::endl;
sm1.process_event(Event1());
std::cout << "> Send Event1" << std::endl;
sm1.process_event(Event1());
std::cout << "> Send Event2" << std::endl;
sm1.process_event(Event2());
std::cout << "> Send Event2" << std::endl;
sm1.process_event(Event2());
}
}
int main()
{
test();
return 0;
}
// Output:
//
// State1::on_entry(InitialEvent)
// > Send Event1
// Guard1(Event1, Fsm, State1, State2)
// State1::on_exit(Event1)
// Action1(Event1, Fsm, State1, State2)
// State2::on_entry(Event1)
// > Send Event1
// Guard1(Event1, Fsm, State2, State1)
// State2::on_exit(Event1)
// Action1(Event1, Fsm, State2, State1)
// State1::on_entry(Event1)
// > Send Event2
// Guard1(Event2, Fsm, State1, State2)
// State1::on_exit(Event2)
// Action1(Event2, Fsm, State1, State2)
// State2::on_entry(Event2)
// > Send Event2
// Guard1(Event2, Fsm, State2, State1)
// State2::on_exit(Event2)
// Action1(Event2, Fsm, State2, State1)
// State1::on_entry(Event2)
当你不想关心具体的事件、原状态和目标状态时，你能用如下模板参数：
struct State1:msm::front::state<>
{
// Entry action
template <class Event,class Fsm>
void on_entry(Event const&, Fsm&) const {
std::cout << "State1::on_entry()" << std::endl;
}
};
// Actions
struct Action1 {
template <class Event, class Fsm, class SourceState, class TargetState>
void operator()(Event const&, Fsm&, SourceState&, TargetState&) const
{
std::cout << "Action1()" << std::endl;
}
}
自转变和内部转变
Event1/Action1 是一个自转变，Event2/Action2 是一个内部转变。当内部转变发生时，entry 和 exit 动作不会被调用。与此对比，自转变会引起 entry 和 exit 的调用。
#include <iostream>
#include <boost/msm/back/state_machine.hpp>
#include <boost/msm/front/state_machine_def.hpp>
#include <boost/msm/front/functor_row.hpp>
namespace {
namespace msm = boost::msm;
namespace msmf = boost::msm::front;
namespace mpl = boost::mpl;
// ----- Events
struct Event1 {};
struct Event2 {};
// ----- State machine
struct Sm1_:msmf::state_machine_def<Sm1_>
{
// States
struct State1:msmf::state<>
{
// Entry action
template <class Event,class Fsm>
void on_entry(Event const&, Fsm&) const {
std::cout << "State1::on_entry()" << std::endl;
}
// Exit action
template <class Event,class Fsm>
void on_exit(Event const&, Fsm&) const {
std::cout << "State1::on_exit()" << std::endl;
}
};
// Set initial state
typedef State1 initial_state;
// Actions
struct Action1 {
template <class Event, class Fsm, class SourceState, class TargetState>
void operator()(Event const&, Fsm&, SourceState&, TargetState&) const
{
std::cout << "Action1()" << std::endl;
}
};
struct Action2 {
template <class Event, class Fsm, class SourceState, class TargetState>
void operator()(Event const&, Fsm&, SourceState&, TargetState&) const
{
std::cout << "Action2()" << std::endl;
}
};
// Transition table
struct transition_table:mpl::vector<
// Start Event Next Action Guard
msmf::Row < State1, Event1, State1, Action1, msmf::none >,
msmf::Row < State1, Event2, msmf::none, Action2, msmf::none >
> {};
};
// Pick a back-end
typedef msm::back::state_machine<Sm1_> Sm1;
void test()
{
Sm1 sm1;
sm1.start();
std::cout << "> Send Event1" << std::endl;
sm1.process_event(Event1());
std::cout << "> Send Event2" << std::endl;
sm1.process_event(Event2());
}
}
int main()
{
test();
return 0;
}
// Output:
//
// State1::on_entry()
// > Send Event1
// State1::on_exit()
// Action1()
// State1::on_entry()
// > Send Event2
// Action2()
为了描述自转变，设置 Start 和 Next 为同样的状态在状态转换表中。而对于内部转变，设置 Next 为 none。none是被定义在 boost::msm::front。
// Transition table
struct transition_table:mpl::vector<
// Start Event Next Action Guard
// Self transition
msmf::Row < State1, Event1, State1, Action1, msmf::none >,
// Internal transition
msmf::Row < State1, Event2, msmf::none, Action2, msmf::none >
> {};
两种不同实现内部转变得方式
为了实现内部转换有两种不同方式。一种是在状态机中利用正常转变表并设置其 Next 状态为 none。此方法得优势在于此转变与其它转变放在一起，增强了其易读性。
另一种方式是使用内部转变表，此表仅仅用于内部转变。该方法允许我们重用内部转变和状态重用。另外内部状态转换表优先于正常状态转换表。
#include <iostream>
#include <boost/msm/back/state_machine.hpp>
#include <boost/msm/front/state_machine_def.hpp>
#include <boost/msm/front/functor_row.hpp>
namespace {
namespace msm = boost::msm;
namespace msmf = boost::msm::front;
namespace mpl = boost::mpl;
// Events
struct Event1 {};
// ----- State machine
struct Sm1_:msmf::state_machine_def<Sm1_>
{
struct State1_:msmf::state_machine_def<State1_>
{
// Guards
struct InternalGuard1 {
template <class Event, class Fsm, class SourceState, class TargetState>
bool operator()(Event const&, Fsm&, SourceState&, TargetState&) const
{
std::cout << "Internal Transition Table's Guard1" << std::endl;
return false;
}
};
struct InternalGuard2 {
template <class Event, class Fsm, class SourceState, class TargetState>
bool operator()(Event const&, Fsm&, SourceState&, TargetState&) const
{
std::cout << "Internal Transition Table's Guard2" << std::endl;
return false;
}
};
// Internal Transition table
struct internal_transition_table:mpl::vector<
// Event Action Guard
msmf::Internal < Event1, msmf::none, InternalGuard1 >,
msmf::Internal < Event1, msmf::none, InternalGuard2 >
> {};
};
// Set initial state
typedef State1_ initial_state;
// Guards
struct Guard1 {
template <class Event, class Fsm, class SourceState, class TargetState>
bool operator()(Event const&, Fsm&, SourceState&, TargetState&) const
{
std::cout << "Transition Table's Guard1" << std::endl;
return false;
}
};
struct Guard2 {
template <class Event, class Fsm, class SourceState, class TargetState>
bool operator()(Event const&, Fsm&, SourceState&, TargetState&) const
{
std::cout << "Transition Table's Guard2" << std::endl;
return false;
}
};
// Transition table
struct transition_table:mpl::vector<
// Start Event Next Action Guard
msmf::Row < State1_, Event1, msmf::none, msmf::none, Guard1 >,
msmf::Row < State1_, Event1, msmf::none, msmf::none, Guard2 >
> {};
};
// back-end
typedef msm::back::state_machine<Sm1_> Sm1;
void test()
{
Sm1 sm1;
sm1.start();
std::cout << "> Send Event1" << std::endl;
sm1.process_event(Event1());
}
}
int main()
{
test();
return 0;
}
// Output:
//
// > Send Event1
// Internal Transition Table's Guard2
// Internal Transition Table's Guard1
// Transition Table's Guard2
// Transition Table's Guard1
连接点伪状态
Boost.Msm 不能直接支持连接点伪状态。如果想实现连接点伪状态，必须要转变 UML 模型。此转变过程十分简单。从于连接点伪状态相关的转变中分离每个独立的转变。
例如，关于如下图表：
它可以被转换为以下图表：
#include <iostream>
#include <boost/msm/back/state_machine.hpp>
#include <boost/msm/front/state_machine_def.hpp>
#include <boost/msm/front/functor_row.hpp>
namespace {
namespace msm = boost::msm;
namespace msmf = boost::msm::front;
namespace mpl = boost::mpl;
// Events
struct Event1 {
Event1(int val):val(val) {}
int val;
};
// ----- State machine
struct Sm1_:msmf::state_machine_def<Sm1_>
{
struct State1_:msmf::state_machine_def<State1_>{};
// Set initial state
typedef State1_ initial_state;
// Guards
struct Guard1 {
template <class Event, class Fsm, class SourceState, class TargetState>
bool operator()(Event const& e, Fsm&, SourceState&, TargetState&) const
{
if (e.val == 1) return true;
return false;
}
};
struct Guard2 {
template <class Event, class Fsm, class SourceState, class TargetState>
bool operator()(Event const& e, Fsm&, SourceState&, TargetState&) const
{
if (e.val == 2) return true;
return false;
}
};
// Actions
struct Action1 {
template <class Event, class Fsm, class SourceState, class TargetState>
void operator()(Event const&, Fsm&, SourceState&, TargetState&) const
{
std::cout << "Action1" << std::endl;
}
};
struct Action2 {
template <class Event, class Fsm, class SourceState, class TargetState>
void operator()(Event const&, Fsm&, SourceState&, TargetState&) const
{
std::cout << "Action2" << std::endl;
}
};
// Transition table
struct transition_table:mpl::vector<
// Start Event Next Action Guard
msmf::Row < State1_, Event1, State1_, Action1, Guard1 >,
msmf::Row < State1_, Event1, State1_, Action2, Guard2 >
> {};
};
// back-end
typedef msm::back::state_machine<Sm1_> Sm1;
void test()
{
Sm1 sm1;
sm1.start();
std::cout << "> Send Event1(1)" << std::endl;
sm1.process_event(Event1(1));
std::cout << "> Send Event1(2)" << std::endl;
sm1.process_event(Event1(2));
}
}
int main()
{
test();
return 0;
}
// Output:
//
// > Send Event1(1)
// Action1
// > Send Event1(2)
// Action2
if/else 分支
有时可能需要用 if/else分支。考虑如下图表：
Boost.Msm 不能直接支持 if/else 分支。如早些时候所提到，转变表和内部转变表是最低行到最高行逐步评估。这意味着你可以通过状态转变行在转变组中的位置来实现 if/else 分支。在else行的 guard 是 none。如下的状态转变表：
// Transition table
struct transition_table:mpl::vector<
// Start Event Next Action Guard
msmf::Row < State1_, Event1, State1_, Action2, msmf::none >, // else
msmf::Row < State1_, Event1, State1_, Action1, Guard1 >
> {};
选择伪状态
首先，考虑下连接点伪状态和选择伪状态的不同。
这两个图表很相似。其唯一的差别在于一个用连接伪状态，另一个用选择伪状态。先来看图1，当 Event1 发生时，根据状态表中顺序选择首先执行哪个分支，且守卫条件的评估应该优先于Event1的动作调用，随后根据守卫条件的评估结果来决定是否调用对应分支的Event1的动作调用与否。若val = 1，则两个分支都的动作根据转换表中的顺序进行先后调用。(注意:与上一节中if/else分支的选择类似在val != 1是方能达到二者选其一的效果。)
然后，来看图2中的选择伪状态。当 Event1 发生时，在 Event1/val=1 的相应动作调用后将评估守卫条件。因此 val==1 分支被选择，随后 Val1Action 被调用。这意味着当此状态转换完成(转换到choice状态)后，相应的转换动作将被一个一个被评估是否进行条用。
接下来，看看选择伪状态在 Boost.Msm 中如何实现。Boost.Msm 不直接支持选择伪状态，但是可以用正常状态替代选择伪状态。替换后如下图表中所描述。
以下是对上述状态转换图表的具体代码实现：
#include <iostream>
#include <boost/msm/back/state_machine.hpp>
#include <boost/msm/front/state_machine_def.hpp>
#include <boost/msm/front/functor_row.hpp>
namespace {
namespace msm = boost::msm;
namespace msmf = boost::msm::front;
namespace mpl = boost::mpl;
// Events
struct Event1 {};
// ----- State machine
struct Sm1_:msmf::state_machine_def<Sm1_>
{
struct State1_:msmf::state<>{
template <class Event, class Fsm, class SourceState, class TargetState>
void operator()(Event const&, Fsm& f, SourceState&, TargetState&) const
{
f.val = 0;
std::cout << "val = " << f.val << std::endl;
}
};
struct Choice_:msmf::state<>{};
// Set initial state
typedef State1_ initial_state;
// Guards
struct GuardVal1 {
template <class Event, class Fsm, class SourceState, class TargetState>
bool operator()(Event const&, Fsm& f, SourceState&, TargetState&) const
{
if (f.val == 1) return true;
return false;
}
};
// Actions
struct ActionVal1Assign {
template <class Event, class Fsm, class SourceState, class TargetState>
void operator()(Event const&, Fsm& f, SourceState&, TargetState&) const
{
f.val = 1;
std::cout << "ActionVal1Assign val = " << f.val << std::endl;
}
};
struct ActionVal1Branch {
template <class Event, class Fsm, class SourceState, class TargetState>
void operator()(Event const&, Fsm& f, SourceState&, TargetState&) const
{
std::cout << "ActionVal1Branch val = " << f.val << std::endl;
}
};
struct ActionElseBranch {
template <class Event, class Fsm, class SourceState, class TargetState>
void operator()(Event const&, Fsm& f, SourceState&, TargetState&) const
{
std::cout << "ActionElseBranch val = " << f.val << std::endl;
}
};
// Transition table
struct transition_table:mpl::vector<
// Start Event Next Action Guard
msmf::Row < State1_, Event1, Choice_, ActionVal1Assign, msmf::none >,
msmf::Row < Choice_, msmf::none, State1_, ActionElseBranch, msmf::none >, // else
msmf::Row < Choice_, msmf::none, State1_, ActionVal1Branch, GuardVal1 >
> {};
private:
int val;
};
// back-end
typedef msm::back::state_machine<Sm1_> Sm1;
void test()
{
Sm1 sm1;
sm1.start();
std::cout << "> Send Event1" << std::endl;
sm1.process_event(Event1());
}
}
int main()
{
test();
return 0;
}
// Output:
//
// > Send Event1
// ActionVal1Assign val = 1
// ActionVal1Branch val = 1
延时事件
TODO.