Is it normal for the entryGuard function to be executed twice when I make a state jump?

[Mystletaine]

e.g. title，and my test code:

#include <iostream>

#include "../common/thirdparty/include/hfsm2/machine.hpp" 

struct Context {
    bool powerOn;
};

using Config = hfsm2::Config::ContextT<Context>;
using M = hfsm2::MachineT<Config>;
#define S(s) struct s

using FSM = M::PeerRoot<
                S(Off),
                M::Composite<S(On),
                    S(Red),
                    S(Yellow),
                    S(Green)
                >,
                S(Done)
            >;
#undef S

struct Off : FSM::State {
  void entryGuard(FullControl& control) { std::cout << "entryGuard off" << std::endl; }
  void update(FullControl& ctl) {
    std::cout << "update off" << std::endl;
    ctl.changeTo<On>();
  }
  void exit(PlanControl& control) { std::cout << "exit off" << std::endl; }
  void exitGuard(FullControl& control) { std::cout << "exitGuard off" << std::endl; }
};

struct On : FSM::State {
  void entryGuard(FullControl& control) {
      std::cout << "entryGuard on" << std::endl;
      control.changeTo<Red>();
      std::cout << "change to red in guard" << std::endl;
  }

  void enter(PlanControl& control) { std::cout << "enter on" << std::endl; }
  void exit(PlanControl& /*control*/) {}
  void planSucceeded(FullControl& control) { control.changeTo<Done>(); }
};

struct Red : FSM::State {
  void update(FullControl& control) {}
};

struct Yellow : FSM::State {};

struct Green : FSM::State {};

struct Done : FSM::State {};

int main() {
    Context context;
    FSM::Instance fsm{context};
    fsm.update();
    fsm.update();
    fsm.update();
    fsm.update();
    fsm.update();
}

the result like this:

entryGuard off
update off
exitGuard off
entryGuard on
change to red in guard
exitGuard off
entryGuard on
change to red in guard
exit off
enter on

[andrew-gresyk]

Yes, that's by design.

During transition processing, exitGuard() is called on all states in the hierarchy to be deactivated, and entryGuard() on all states scheduled for activation.

If any of the guards issue another transition, the process repeats with the new target state(s), up to Config::SubstitutionLimitN<> times (4 by default).

See test_guards.cpp for more info.

[Mystletaine]

If I want to select which sub-state I want to enter within the entryGuard function before entering the parent state, how do I ensure that this part of the code is only executed once? Like in the example, this part of the judgement is always executed twice when I use it

[andrew-gresyk]

One option is to check Control.isPendingEnter<Red>() in On::entryGuard().

Another is to turn On into M::Selectable<On, ...> (or machine.select<On>()) and add Short On::select(const Control&) which would return a 0-based index of the sub-state you want to activate.
See test_select.cpp for more info.