Using event instance with process_event()

[ladislas]

Expected Behavior

As described in the tutorial section, I'm using event instances to simplify the transition table.

struct start { ... };
auto e_start = sml::event<start>;

struct game_over { ... };
auto e_game_over = sml::event<game_over>;

class StateMachine {
public:
  auto operator()() {
    using namespace sml;
    return make_transition_table(
     *"src_state"_s + e_start = "dst_state"_s,
      "dst_state"_s + e_game_over = X
    );
  }
};

Now, when I try to call sm.process_event() with the instance, it does not work:

sm.process_event(e_start); // not working
sm.process_event(e_start()); // working but is ugly and people will forget to add the ()
sm.process_event(start {}); // working

Actual Behavior

Just calling process_event() with the instance doesn't do anything.

Steps to Reproduce the Problem

n/a

Specifications

• Version: latest
• Platform: macOS
• Subsystem: n/a

[Rijom]

I always use sm.process_event(start {}); // working.
You create an instance of the event and pass it on to the state machine. To me this seems like the most natural way to do it. Even more so, once you start adding a payload to an event.

I guess one could implement your wish by adding a special overload of process_event that calls operator() on the front::event<T>. But I think this would only increase complexity for the user.

[cppden]

sml::event is the marker for the library to distinguish events from states/actions, i.e. it's meant to be used for FSM definition.

once FSM defined you should just use your raw events w/o sml's markers. this is similar case as with a definition of template and its actual use, i.e. you don't write template SOME<int> when you need to instantiate it for particular type.