启动状态机无法处理启动时的内部转换。

Question

我有以下状态机（抱歉，我找不到如何制作更小的MRE）：

• SM包含MainSM，MainSM包含SubSM。
• SM有一个内部转换表，其中写着“忽略事件Trigger”。
• 在启动时，SM的初始状态为MainSM，并且MainSM的initial_state为“Default”（因此它不是SubSM）。
• 只有SubSM处理“Trigger”事件。

它完美地工作，状态机按预期忽略了Trigger事件。但是，如果MainSM的on_entry方法发送Trigger事件，则启动状态机将无法处理该事件并调用no_transition。

问题出在哪里？启动时SM还没有准备好吗？这是一个错误还是符合规范？

这是代码片段。删除80行中的process_event调用即可正常工作。

#include <iostream>

#include <boost/core/demangle.hpp>
#include <boost/msm/back/state_machine.hpp>
#include <boost/msm/front/state_machine_def.hpp>
#include <boost/msm/front/functor_row.hpp>

#define ON_ENTRY_LOG_NAME(name) \
    template <class Event, class FSM>                   \
    void on_entry(const Event &, FSM&) {            \
        std::cout << "Entering " #name << std::endl;    \
    }
#define ON_EXIT_LOG_NAME(name) \
    template <class Event, class FSM> \
    void on_exit(const Event &, FSM&) { \
        std::cout << "Exitting " #name << std::endl;    \
    }


namespace  // Concrete FSM implementation
{

    namespace msm = boost::msm;
    namespace msmb = boost::msm::back;
    namespace msmf = boost::msm::front;
    namespace mpl = boost::mpl;

    // events
    struct Stop {};
    struct Recover {};
    struct Start {};
    struct Trigger {};

    struct SubSM_front: msmf::state_machine_def<SubSM_front>
    {
        struct Fidgetting: msmf::state<>
        {
            ON_ENTRY_LOG_NAME(Fidgetting);
            ON_EXIT_LOG_NAME(Fidgetting);
        };

        struct FidgettingCompulsively: msmf::state<>
        {
            ON_ENTRY_LOG_NAME(FidgettingCompulsively);
            ON_EXIT_LOG_NAME(FidgettingCompulsively);
        };

        using initial_state = Fidgetting;

        struct transition_table: mpl::vector<
            msmf::Row<Fidgetting,             Trigger, FidgettingCompulsively>,
            msmf::Row<FidgettingCompulsively, Trigger, Fidgetting>
        > {};

        ON_ENTRY_LOG_NAME(SubSM);
        ON_EXIT_LOG_NAME(SubSM);
    };

    using SubSM = msmb::state_machine<SubSM_front>;

    struct MainSM_front: msmf::state_machine_def<MainSM_front>
    {
        struct Default: msmf::state<>
        {
            ON_ENTRY_LOG_NAME(Default);
            ON_EXIT_LOG_NAME(Default);
        };

        using initial_state = Default;

        struct transition_table: mpl::vector<
            msmf::Row<Default, Start, SubSM>
        > {};

        template <class Event, class FSM>
        void on_entry(const Event &, FSM &fsm)
        {
            std::cout << "Entering MainSM" << std::endl;
            // This line make a call to no_transition
            fsm.process_event(Trigger{});
        }

        ON_EXIT_LOG_NAME(MainSM);
    };

    using MainSM = msmb::state_machine<MainSM_front>;

    struct SM_front: msmf::state_machine_def<SM_front>
    {
        struct Stopped: msmf::state<>
        {
            ON_ENTRY_LOG_NAME(Stopped);
            ON_EXIT_LOG_NAME(Stopped);
        };

        using initial_state = MainSM;

        using transition_table = mpl::vector<
            msmf::Row<MainSM,  Stop,    Stopped>,
            msmf::Row<Stopped, Recover, MainSM>
        >;

        using internal_transition_table = mpl::vector<
            msmf::Internal<Trigger>
        >;

        ON_ENTRY_LOG_NAME(SM);
        ON_EXIT_LOG_NAME(SM);
    };

    using SM = msmb::state_machine<SM_front>;

    void test()
    {
        SM sm;

        sm.start();
        sm.process_event(Trigger{});
        sm.stop();
    }
}

int main()
{
    test();
    return 0;
}

已在GCC 5.5、Clang 8和Boost 1.58和1.73下进行了测试，使用的是C++14。

- Hugal31

Answer 1

在初始化SM时，它将初始化嵌套的MainSM。作为初始化的一部分，它将发送InitEvent，您需要处理该事件以在包含的SM实例上处理TriggerEvent。

换句话说，您正在处理fsm参数上的事件，该参数是与正在初始化过程中的SM状态机完全相同的实例。

我认为这不被支持。实际上，Trigger已经被“很好地”处理了，但是在您的on_entry处理程序退出后，SM遇到了麻烦：

 struct direct_event_start_helper
 {
     direct_event_start_helper(library_sm* self_):self(self_){}
     // this variant is for the standard case, entry due to activation of the containing FSM
     template <class EventType,class FsmType>
     typename ::boost::disable_if<typename has_direct_entry<EventType>::type,void>::type
         operator()(EventType const& evt,FsmType& fsm, ::boost::msm::back::dummy<0> = 0)
     {
         (static_cast<Derived*>(self))->on_entry(evt,fsm);
         self->internal_start(evt);
     }

那个 self->internal_start(evt) 不再起作用，因为外部SM被操纵了。 断言

sotest: boost_1_72_0/boost/msm/front/state_machine_def.hpp:203: void boost::msm::front::state_machine_def<Derived, BaseState>::no_transition(const Event&, FSM&, int) [with FSM = boost::msm::back::state_machine<{anonymous}::MainSM_front>; Event = {anonymous}::Trigger; Derived = {anonymous}::MainSM_front; BaseState = boost::msm::front::default_base_state]: Assertion `false' failed.

确实意味着没有过渡效果：

template <class FSM,class Event>
void no_transition(Event const& ,FSM&, int )
{
    BOOST_ASSERT(false);
}

DOC FIND

在文档中，我偶然发现了这个措辞，它似乎确认了以上所有内容：

注意：您可能已经注意到教程在创建状态机后立即调用start()。start方法将启动状态机，这意味着它将激活初始状态，从而意味着将调用初始状态的进入行为。我们需要这样做的原因将在后端部分中解释。 调用start后，状态机已准备好处理事件。同样，调用stop()将导致调用最后的退出操作。

(强调是我的)

- sehe