Jumping out of sub-machine not working correctly

[gischthefish]

The example of issue #283 (Jump out from substate) only works when using front::actions::process, but not with sml::back::process. #302 (Process events to/from sub/sibling machines) should have solved the problem when exiting sub-machines.

front::actions::process doesn't help, I need to be able to choose the event getting fired.

Following the example of #283 using sml::back::process (not working):

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

namespace sml = boost::sml;

struct e1 {};
struct e2 {};

auto process_e2 = [](sml::back::process<e2> processEvent) {
    std::cout << "in sub" << std::endl;
    processEvent( e2{} );
};

struct sub {
    auto operator()() {
        using namespace sml;

        return make_transition_table(
                *"start"_s + event<e1> / process_e2
        );
    }
};

struct top {
    auto operator()() {
        using namespace sml;

        return make_transition_table(
                *state<sub> + event<e2> / [] { std::cout << "jumped out from sub-state" << std::endl; } = X
        );
    }
};

int main() {
    sml::sm<top, sml::process_queue<std::queue>> sm{};
    sm.process_event(e1{});
    assert(sm.is(sml::X));
}

See the following compile error: error.txt

Furthermore issue #121 (Submachine terminate event should be actioned in outer state) seems not to be fixed yet. #302 (Process events to/from sub/sibling machines) should have fixed #121. But the event that terminates the sub-machine is not being propagated to the parent sm.

The following test should work:

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

namespace sml = boost::sml;

namespace {
struct e1 {};
struct e2 {};
struct e3 {};
struct e4 {};

struct sub {
    auto operator()() const noexcept {
        using namespace sml;

        return make_transition_table(
                *"idle"_s   + event<e3>         / [] { std::cout << "in sub sm" << std::endl; }     = "s1"_s,
                "s1"_s      + event<e4>         / [] { std::cout << "finish sub sm" << std::endl; } = X
      );
  }
};

struct composite {
    auto operator()() const noexcept {
        using namespace sml;

        return make_transition_table(
                *"idle"_s   + event<e1>                                                                 = "s1"_s,
                "s1"_s      + event<e2>         / [] { std::cout << "enter sub sm" << std::endl; }      = state<sub>,
                state<sub>  + event<e4>         / [] { std::cout << "exit sub sm" << std::endl; }       = X
        );
    }
};

}  // namespace

int main() {
    sml::sm<composite> sm;

    using namespace sml;
    assert(sm.is("idle"_s));
    assert(sm.is<decltype(state<sub>)>("idle"_s));

    sm.process_event(e1{});
    assert(sm.is("s1"_s));
    assert(sm.is<decltype(state<sub>)>("idle"_s));

    sm.process_event(e2{});  // enter sub sm
    assert(sm.is(state<sub>));
    assert(sm.is<decltype(state<sub>)>("idle"_s));

    sm.process_event(e3{});  // in sub sm
    assert(sm.is(state<sub>));
    assert(sm.is<decltype(state<sub>)>("s1"_s));

    sm.process_event(e4{});  // finish sub sm and propagate "exit event" to parent sm to finish parent too.
    assert(sm.is(X));
    assert(sm.is<decltype(state<sub>)>(X));
}

Propagating the event that terminated the sub-machine to the parent is a very essential feature, without that sub-machines are quite useless as the parent does not know what the sub-machine was doing, i.e. the sub-machine needs some means to tell the parent the result of the "computation".

Specifications

• SML 1.1.3
• GCC 9.3

[juehallier]

I also have stumbled around this point for some hours, but indeed you can send events from the inner sm to an outer sm. Please see a working example in the test code in the lambda function "test process_event_sent_from_substate" here. Important fact: you'll have to add the policy sml::process_queue when you initialize the state machine.