On Fri, May 29, 2015 at 4:00 PM, Christophe Henry < christophe.j.henry@gmail.com> 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; }