Re: [Boost-users] [MSM] Boost.MSM: statemachine to transition on templatized event-type

Subject: Re: [Boost-users] [MSM] Boost.MSM: statemachine to transition on templatized event-type
From: nice sw123 (nicesw123_at_[hidden])
Date: 2015-05-29 17:46:21

On Fri, May 29, 2015 at 4:00 PM, Christophe Henry <
christophe.j.henry_at_[hidden]> wrote:
>
> Hi,
>
> > having tested Boost.MSM, I'm pretty happy with it.
>
> :)
>
> >It's interesting, in that it seems to handle all states in a static
table.
> >No "new" operator etc.
>
> It's much faster without dynamic allocation.
>
> <snip>
>
>     g_row<StateInitial, EventT, StateEven,
 &Machine_<EventT>::guardToEven>,
>
>
> >Unfortunately
> >gcc gives this error:
> >d.cpp:119:5: error: ‘g_row’ was not declared in this scope
> >     g_row<StateInitial, EventT, StateEven,
 &Machine_<EventT>::guardToEven>,
>
> Short answer. Try:
>
> typename Machine_<EventT>::template g_row<StateFloat,   EventT,
StateFloat, &Machine_<EventT>::guardToFloat>

Thanks so much for taking the time to help out! This works perfectly!!!

> Long answer: g_row is a type of state_machine_def and as your fsm is a
template, it becomes a dependent type (=> typename) and a template one even
(=> template).
>
> C++ is sometimes really annoying :(
>
>
> Longer answer. Give up this front-end, it's deprecated anyway. A better
solution will be:
>
> #include <boost/msm/front/functor_row.hpp>
> using namespace boost::msm::front;
>
> struct GuardToOdd
>   {
>       template <class EVT,class FSM,class SourceState,class TargetState>
>       bool operator()(EVT const& num,FSM& ,SourceState& ,TargetState& )
>       {
>           const long long x = static_cast<long long>(num.getNum());
>           return ((x == num.getNum()) // is Integral type
>                   && ((x % 2) != 0));
>       }
>   };
>
> Row< StateFloat,   EventT, StateOdd, none, GuardToOdd>
>

I've tried it! Nice, thanks.

>
> HTH,
> Christophe
>

I have a question about optimization regarding guard conditions.
How can one optimize the states and guard-checking??

This is one way:

/// see full working code example at the bottom of this post

  struct transition_table : mpl::vector<
    Row<StateInitial, EventT, StateEven,  none, none>,
    Row<StateInitial, EventT, StateOdd,   none, GuardToOdd>,
    Row<StateInitial, EventT, StateFloat, none, GuardToFloat>,

    Row<StateEven, EventT, StateEven,  none, none>,
    Row<StateEven, EventT, StateOdd,   none, GuardToOdd>,
    Row<StateEven, EventT, StateFloat, none, GuardToFloat>,

    Row<StateOdd, EventT, StateEven,  none, none>,
    Row<StateOdd, EventT, StateOdd,   none, GuardToOdd>,
    Row<StateOdd, EventT, StateFloat, none, GuardToFloat>,

    Row<StateFloat, EventT, StateEven,  none, none>,
    Row<StateFloat, EventT, StateOdd,   none, GuardToOdd>,
    Row<StateFloat, EventT, StateFloat, none, GuardToFloat>
    >{};

which relies on the guard-checking from the bottom to the top (first guard
returning true wins).

The guards can then be:

struct GuardToOdd
{
  template <class EVT, class FSM, class SourceState, class TargetState>
  bool operator()(EVT const& num, FSM&, SourceState&, TargetState&)
  {
    const long long x = static_cast<long long>(num.getNum());
    /* do not have to check if number is float or integral here.
        Reason: GuardToFloat is guaranteed to be false if we are here,
        because it is lower in transition_table !!!!!! */
    return ((x % 2) != 0);
  }
};

struct GuardToFloat
{
  template <class EVT, class FSM, class SourceState, class TargetState>
  bool operator()(EVT const& num, FSM&, SourceState&, TargetState&)
  {
    const long long x = static_cast<long long>(num.getNum());
    return (x != num.getNum()); // is Floating type
  }
};

But the transition table is still huge.
Is it possible to use MSM to create a parentstate "StateEval" with
substates "StateEven", "StateOdd", "StateFloat" ?, the idea being to make
transition_table as short as possible.
Something like this maby (but it does not work):

  struct transition_table : mpl::vector<
    Row<StateEval, EventT, StateEval::StateEven,  none, none>,
    Row<StateEval, EventT, StateEval::StateOdd,   none, GuardToOdd>,
    Row<StateEval, EventT, StateEval::StateFloat, none, GuardToFloat>
    >{};

Basically: is it possible to create a parentstate, that listens to events
(even when an inner substate is already active)?

Thanks.
nicesw123

Full code-example (using large transition_table):

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

#include <boost/msm/front/functor_row.hpp>
using namespace boost::msm::front;

namespace msm = boost::msm;
namespace mpl = boost::mpl;

// events
struct EventNumber1 {    // int number!
  EventNumber1(int num_) : num{num_} {}
  int getNum() const { return num; }
private:
  int num;
};

struct EventNumber2 {    // double number!
  EventNumber2(double num_) : num{num_} {}
  double getNum() const { return num; }
private:
  double num;
};

typedef EventNumber2 MyEvent;     // using doubles

// StateBase -- a base (parent) state
struct StateBase : public msm::front::state<> {
  StateBase(const std::string& stateName = "") : stateName{stateName} {}

  template <typename Event, typename FSM>
  void on_entry(const Event&, FSM&) {
    std::cout << "Entering " << stateName << std::endl;
  }

  template <typename Event, typename FSM>
  void on_exit(const Event&, FSM&) {
    std::cout << "Leaving  " << stateName << std::endl;
  }

private:
  std::string stateName;
};

template <typename T>
struct StateMachineFront_Base : public
msm::front::state_machine_def<StateMachineFront_Base<T>>
{
  StateMachineFront_Base(const std::string& stateMachineName = "") :
stateMachineName{stateMachineName} {}

  template <typename Event, typename FSM>
  void on_entry(const Event&, FSM&) {
    std::cout << "Entering " << stateMachineName << std::endl;
  }

  template <typename Event, typename FSM>
  void on_exit(const Event&, FSM&) {
    std::cout << "Leaving  " << stateMachineName << std::endl;
  }

 private:
  std::string stateMachineName;
};

//guards

struct GuardToOdd
{
  template <class EVT, class FSM, class SourceState, class TargetState>
  bool operator()(EVT const& num, FSM&, SourceState&, TargetState&)
  {
    const long long x = static_cast<long long>(num.getNum());
    return ((x % 2) != 0);
  }
};

struct GuardToFloat
{
  template <class EVT, class FSM, class SourceState, class TargetState>
  bool operator()(EVT const& num, FSM&, SourceState&, TargetState&)
  {
    const long long x = static_cast<long long>(num.getNum());
    return (x != num.getNum()); // is Floating type
  }
};

template <typename EventT>
struct Machine_ : public StateMachineFront_Base<Machine_<EventT> > {

  Machine_(const std::string& stateMachineName = "Machine_") :
StateMachineFront_Base<Machine_<EventT> >{stateMachineName} {}

  // states
  struct StateInitial : public StateBase {
    StateInitial(const std::string name = "StateInitial") : StateBase{name}
{}
  };

  struct StateEven : public StateBase {
    StateEven(const std::string name = "StateEven") : StateBase{name} {}
  };

  struct StateOdd : public StateBase {
    StateOdd(const std::string name = "StateOdd") : StateBase{name} {}
  };

  struct StateFloat : public StateBase {
    StateFloat(const std::string name = "StateFloat") : StateBase{name} {}
  };

  typedef StateInitial initial_state;

  struct transition_table : mpl::vector<
    Row<StateInitial, EventT, StateEven,  none, none>,
    Row<StateInitial, EventT, StateOdd,   none, GuardToOdd>,
    Row<StateInitial, EventT, StateFloat, none, GuardToFloat>,

    Row<StateEven, EventT, StateEven,  none, none>,
    Row<StateEven, EventT, StateOdd,   none, GuardToOdd>,
    Row<StateEven, EventT, StateFloat, none, GuardToFloat>,

    Row<StateOdd, EventT, StateEven,  none, none>,
    Row<StateOdd, EventT, StateOdd,   none, GuardToOdd>,
    Row<StateOdd, EventT, StateFloat, none, GuardToFloat>,

    Row<StateFloat, EventT, StateEven,  none, none>,
    Row<StateFloat, EventT, StateOdd,   none, GuardToOdd>,
    Row<StateFloat, EventT, StateFloat, none, GuardToFloat>
    >{};

};

typedef msm::back::state_machine<Machine_<MyEvent>> Machine;

template <typename T>
void postEvents(Machine& machine)
{
  for (T i; std::cin >> i; ) {
    machine.process_event(MyEvent{i});
  }
}

int main()
{
  Machine machine;
  machine.start();

  postEvents<double>(machine);

  machine.stop();
  return 0;
}