Почему повышение MSM вызывает охрану дважды?

Question

Я реализую конечный автомат, как показано на следующей диаграмме Диаграмма конечного автомата

Я запускаю «событие1» и «событие2» на конечный автомат, когда «событие1» срабатывает,конечный автомат выходит из состояния «state1», входит в «конечный автомат state3» и остается в состоянии «state3-state1».Когда срабатывает «event2», машина состояний «state3» входит в указатель выхода и входит в состояние «state1».После входа в состояние «state1» я обнаружил, что «охранник» вызывается дважды.Ниже приведен мой код

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

#include <string>
#include <iostream>

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

struct event1 {};
struct event2 {};

struct S_ : public msmf::state_machine_def<S_>
{
    typedef msmb::state_machine<S_> S;

    struct guard
    {
        template <class Event,class FSM,class SourceState,class TargetState>
        bool operator()(const Event& event, FSM&, SourceState&, TargetState&)
        {
            std::cout << "guard.\n";
            return false;
        }
    };

    struct State1 : public msmf::state<>
    {
        template<class Event, class FSM>
        void on_entry(const Event&, FSM&)
        {
            cout << "entering state: <state1>\n";
        }

        template <class Event,class FSM>
        void on_exit(const Event&, FSM&)
        {
            cout << "leaving state: <state1>\n";
        }
    };

    struct State2 : public msmf::state<>
    {
        template<class Event, class FSM>
        void on_entry(const Event&, FSM&)
        {
            cout << "entering state: <state2>\n";
        }

        template <class Event,class FSM>
        void on_exit(const Event&, FSM&)
        {
            cout << "leaving state: <state2>\n";
        }
    };

    struct State3_ : public msmf::state_machine_def<State3_>
    {
        template<class Event,class FSM>
        void on_entry(const Event&, FSM&)
        {
            cout << "entering state: <state3>\n";
        }

        template <class Event,class FSM>
        void on_exit(const Event&, FSM&)
        {
            cout << "leaving state: <state3>\n";
        }

        struct State1 : public msmf::state<>
        {
            template<class Event, class FSM>
            void on_entry(const Event&, FSM&)
            {
                cout << "entering state: <state3-state1>\n";
            }

            template <class Event,class FSM>
            void on_exit(const Event&, FSM&)
            {
                cout << "leaving state: <state3-state1>\n";
            }
        };

        struct Exit: msmf::exit_pseudo_state<event2>
        {

        };

        typedef State1 initial_state;

        struct transition_table : mpl::vector<
            msmf::Row<State1, event2, Exit, msmf::none, msmf::none>
        >{};

    };
    typedef msmb::state_machine<State3_> State3;
    typedef State1 initial_state;

    struct transition_table : mpl::vector<
        msmf::Row<State1,                         event1,     State3, msmf::none, msmf::none>,
        msmf::Row<State1,                         msmf::none, State2, msmf::none, guard>,
        msmf::Row<State3::exit_pt<State3_::Exit>, event2,     State1, msmf::none, msmf::none>
    >{};
};

typedef msmb::state_machine<S_> S;

int main()
{
    S s;
    s.start();
    s.process_event(event1());
    s.process_event(event2());

    return 0;
}

Версия надстройки 1.66, вывод программы:

entering state: <state1>
guard.
leaving state: <state1>
entering state: <state3>
entering state: <state3-state1>
leaving state: <state3-state1>
leaving state: <state3>
entering state: <state1>
guard.
guard.

Я считаю, что купол легче показать тот же вопрос, конечный автоматдиаграмма здесь и код

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

#include <string>
#include <iostream>

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

struct event1 {};
struct event2 {};

struct S_ : public msmf::state_machine_def<S_>
{
    typedef msmb::state_machine<S_> S;

    struct guard
    {
        template <class Event,class FSM,class SourceState,class TargetState>
        bool operator()(const Event& event, FSM&, SourceState&, TargetState&)
        {
            std::cout << "guard.\n";
            return false;
        }
    };

    struct State1 : public msmf::state<>
    {
        template<class Event, class FSM>
        void on_entry(const Event&, FSM&)
        {
            cout << "entering state: <state1>\n";
        }

        template <class Event,class FSM>
        void on_exit(const Event&, FSM&)
        {
            cout << "leaving state: <state1>\n";
        }
    };

    struct State2_ : public msmf::state_machine_def<State2_>
    {
        template<class Event,class FSM>
        void on_entry(const Event&, FSM& fsm)
        {
            cout << "entering state: <state2>\n";
        }

        template <class Event,class FSM>
        void on_exit(const Event&, FSM&)
        {
            cout << "leaving state: <state2>\n";
        }

        struct State1 : public msmf::state<>
        {
            template<class Event, class FSM>
            void on_entry(const Event&, FSM&)
            {
                cout << "entering state: <state2-state1>\n";
            }

            template <class Event,class FSM>
            void on_exit(const Event&, FSM&)
            {
                cout << "leaving state: <state2-state1>\n";
            }
        };

        struct State2 : public msmf::state<>
        {
            template<class Event, class FSM>
            void on_entry(const Event&, FSM&)
            {
                cout << "entering state: <state2-state2>\n";
            }

            template <class Event,class FSM>
            void on_exit(const Event&, FSM&)
            {
                cout << "leaving state: <state2-state2>\n";
            }
        };

        typedef State1 initial_state;

        struct transition_table : mpl::vector<
            msmf::Row<State1, msmf::none, State2, msmf::none, guard>
        >{};

    };

    typedef msmb::state_machine<State2_> State2;
    typedef State1 initial_state;

    struct transition_table : mpl::vector<
        msmf::Row<State1, msmf::none, State2, msmf::none, msmf::none>
    >{};
};

typedef msmb::state_machine<S_> S;

int main()
{
    S s;
    s.start();
    return 0;
}

Вывод программы

entering state: <state1>
leaving state: <state1>
entering state: <state2>
entering state: <state2-state1>
guard.
guard.