Entering a previously visited composite of a compisite state re-enters its last active substate

[ken-voly]

The problem seems to be similar to #55. The initial state of a substate of a substate does not get entered if that state has been left previously. See the following diagram and code:

#include <boost/sml.hpp>
#include <cassert>
#include <iostream>

namespace sml = boost::sml;


/******************** Events ********************/
struct activate {};
struct deactivate {};

struct print_sub1_entry {
    void operator()() {
        std::cout << "sub1 entry\n";
    }
} print_sub1_entry;

struct print_sub2_entry {
    void operator()() {
        std::cout << "sub2 entry\n";
    }
} print_sub2_entry;

struct print_sub3_entry {
    void operator()() {
        std::cout << "sub3 entry\n";
    }
} print_sub3_entry;

struct print_other_substate_entry {
    void operator()() {
        std::cout << "other_substate entry\n";
    }
} print_other_substate_entry;


/******************** States ********************/
struct sub2 {
    struct other_substate {};
    struct sub3 {};

    auto operator()() const {
        using namespace sml;

        return make_transition_table(
             *state<sub3> + sml::on_entry<_> / print_sub3_entry
            , state<sub3> = state<other_substate>

            , state<other_substate> + sml::on_entry<_> / print_other_substate_entry
        );
    }
};

struct sub1 {
    struct sub1_otherstate {};

    auto operator()() const {
        using namespace sml;

        return make_transition_table(
             *state<sub2> + sml::on_entry<_> / print_sub2_entry
        );
    }
};

// Top level state machine
struct state_machine {
    struct inactive {};

    auto operator()() const {
        using namespace sml;

        return make_transition_table(
             *state<inactive> + event<activate> = state<sub1>

            , state<sub1> + sml::on_entry<_> / print_sub1_entry
            , state<sub1> + event<deactivate> = state<inactive>
        );
    }
};


struct my_logger {
  template <class SM, class TEvent>
  void log_process_event(const TEvent&) {
  }

  template <class SM, class TGuard, class TEvent>
  void log_guard(const TGuard&, const TEvent&, bool result) {
  }

  template <class SM, class TAction, class TEvent>
  void log_action(const TAction&, const TEvent&) {
  }

  template <class SM, class TSrcState, class TDstState>
  void log_state_change(const TSrcState& src, const TDstState& dst) {
    printf("[%s][transition] %s -> %s\n", sml::aux::get_type_name<SM>(), src.c_str(), dst.c_str());
  }
};


int main() {
  my_logger logger;
  sml::sm<state_machine, sml::logger<my_logger>> sm{logger};
  //sml::sm<state_machine> sm;

  using namespace sml;

  std::cout << "All sub state entry actions should toggle" << std::endl;
  sm.process_event(activate{});

  std::cout << "\nDeactivating\n";
  sm.process_event(deactivate{});

  std::cout << "\nAll sub state entry actions should toggle again" << std::endl;
  sm.process_event(activate{});
}

Expected Behavior

All sub state entry actions should toggle
[state_machine][transition] inactive -> sub1
sub1 entry
sub2 entry
sub3 entry
[sub2][transition] sub3 -> other_substate
other_substate entry

Deactivating
[state_machine][transition] sub1 -> inactive

All sub state entry actions should toggle again
[state_machine][transition] inactive -> sub1
sub1 entry
sub2 entry
sub3 entry
[sub2][transition] sub3 -> other_substate
other_substate entry

Actual Behavior

Actual Output

All sub state entry actions should toggle
[state_machine][transition] inactive -> sub1
sub1 entry
sub2 entry
sub3 entry
[sub2][transition] sub3 -> other_substate
other_substate entry

Deactivating
[state_machine][transition] sub1 -> inactive

All sub state entry actions should toggle again
[state_machine][transition] inactive -> sub1
sub1 entry
sub2 entry
other_substate entry

Missing Output

Sub3 is not entered and the we don't see the following output the second time an activate event is generated.

sub3 entry
[sub2][transition] sub3 -> other_substate

Steps to Reproduce the Problem

Compile and run the program.

• c++14 or c++17
• optimizations on or off

Specifications

• Version: 1.1.4
• OS: Ubuntu 20.4
• Compiler: g++ (Ubuntu 9.3.0-17ubuntu1~20.04) 9.3.0

[ken-voly]

It seems like the "initial pseudostate" --> "initial state" transition is not treated the same as a transition from one normal state to another. When a state is entered from the "initial pseudostate" --> "initial state" transition and that state contains a state machine, the sub state machine does not enter its initial state. By adding a dummy state, the sub state machine in the previous example executes correctly.

[nagua]

Hey everyone,

I'm currently experiencing the same problem. Does anyone have a hint on how to fix this, or where to look?

Greetings,
nagua

[guiserle]

Hi everyone,

Same problem here. Fortunately @ken-voly workaround is simple enough, but I though it would be worth to bring this back to life just in case anybody has time in the future to research a fix

[mahush]

Hey there,

We are also very concerned about this problem. Even if the workaround is simple, it needs to be understood by everyone maintaining the state machine. A solution would therefore be very welcome.

[wiljo-de-ruiter]

Hello there,
Our product is using a lot of state machines with several sub state machines. Although the state machines look okay according to the specification, the product did not always behave as expected. After days trying to fix the issue, we discovered that entering substates, like described in this issue, is only working correctly the first time that substate is entered. When that substate needs to be entered a second time it behaves as if a history flag has been set and the wrong state is entered. We never use the history flag, thus this behaviour came as a surprise.
We also came up with the same workaround by adding a dummy state before entering the actual substate, but this of course not desired. We would also welcome a solution to this problem.

[jefftrull]

Perhaps #649 will help