Re: [Boost-users] Accessing MSM attribute under specific conditions causes non-compile
Thank you for your help! I see now that it's not that that the sub-machine is a state of the main machine, but ANY time you have an entry action performed directly from the machine level the fsm is reported as a state and not as an fsm. This isn't a problem since I know this is happening, but perhaps it might be possible to change this so fsm entry actions put the fsm in the fsm parameter slot? What is fsm equal to when an entry action is performed? Here's some code that shows exactly what can be set where and when for anyone else who is trying to figure this out... #include <vector> #include <iostream> #include <boost/msm/back/state_machine.hpp> #include <boost/msm/front/euml/euml.hpp> using namespace std; using namespace boost::msm::front::euml; namespace msm = boost::msm; namespace MSM_A // Concrete FSM implementation { BOOST_MSM_EUML_DECLARE_ATTRIBUTE(int, borrowedBuffer_attribute); BOOST_MSM_EUML_DECLARE_ATTRIBUTE(int, someother_Attribute); BOOST_MSM_EUML_ACTION(someAction) { template <class Event,class FSM,class STATE> void operator()(Event const& event,FSM& , STATE& state) { std::cout<<"Doing someAction."<<std::endl; state.get_attribute(borrowedBuffer_attribute)=1; } }; BOOST_MSM_EUML_ACTION(someOtherAction) { template <class Event,class FSM ,class STATE> void operator()(Event const& event,FSM& fsm, STATE& state) { std::cout<<"Doing someOtherAction."<<std::endl; fsm.get_attribute(borrowedBuffer_attribute)=1; state.get_attribute(someother_Attribute)=1; } }; BOOST_MSM_EUML_EVENT(someevent) BOOST_MSM_EUML_STATE((someOtherAction, no_action, attributes_<<someother_Attribute), someStateA) BOOST_MSM_EUML_STATE((no_action), someStateB) BOOST_MSM_EUML_TRANSITION_TABLE(( someStateA + someevent == someStateB ),transition_table) BOOST_MSM_EUML_DECLARE_STATE_MACHINE(( transition_table, init_ << someStateA, someAction, // <-------------------- ACTION IS AN ENTRY ACTION no_action, attributes_ << borrowedBuffer_attribute, configure_ << no_configure_ ), MSM_A_frontEnd) //fsm name typedef msm::back::state_machine<MSM_A_frontEnd> MSM_A_player; } namespace MSM_B // Concrete FSM implementation { ::MSM_A::MSM_A_player subMachine; BOOST_MSM_EUML_DECLARE_ATTRIBUTE(int, rootFSM_attribute); BOOST_MSM_EUML_DECLARE_ATTRIBUTE(int, rootstate_attribute); BOOST_MSM_EUML_EVENT(someEvent) BOOST_MSM_EUML_ACTION(rootFSM_action) { template <class Event,class FSM,class STATE> void operator()(Event const& event,FSM& , STATE& state) { std::cout<<"Doing rootFSM_action."<<std::endl; state.get_attribute(rootFSM_attribute)=1; } }; BOOST_MSM_EUML_ACTION(another_rootFSM_action) { template <class Event,class FSM,class STATE> void operator()(Event const& event,FSM& fsm , STATE& state) { std::cout<<"Doing another_rootFSM_action."<<std::endl; fsm.get_attribute(rootFSM_attribute)=1; state.get_attribute(rootstate_attribute)=1; } }; BOOST_MSM_EUML_STATE((another_rootFSM_action, no_action, attributes_<<rootstate_attribute), someState) BOOST_MSM_EUML_TRANSITION_TABLE(( someState + someEvent == someEvent ), transition_table) BOOST_MSM_EUML_DECLARE_STATE_MACHINE(( transition_table, //STT init_ << subMachine << someState, rootFSM_action, // Entry no_action, // Exit attributes_ << rootFSM_attribute, // Attributes configure_ << no_configure_ ), MSM_B_frontEnd) //fsm name typedef msm::back::state_machine<MSM_B_frontEnd> MSM_B_player; } int main() { std::cout<<"Making player."<<std::endl; MSM_B::MSM_B_player player; std::cout<<"Starting player."<<std::endl; player.start(); std::cin.ignore(1); return 0; }
Hi,
I see now that it's not that that the sub-machine is a state of the main machine, but ANY time you have an entry action performed
directly from the machine level the fsm is reported as a state and not as an fsm.
This isn't a problem since I know this is happening, but perhaps it might be possible to change this so fsm entry actions put the fsm
in the fsm parameter slot?
I don't think it'd be a good idea. Or I might misunderstand your point.
What is fsm equal to when an entry action is performed?
FSM is the state machine containing this state / state machine / terminate state etc. STATE is the state being entered / exited. This means, if you have a state executing this entry, you can rely on it being in the STATE parameter. If later you replace this state by a submachine (which is also a state, right? ), your "state" is still represented by the STATE parameter. Anything else could be rightfully considered a violation of the liskov substitution principle. Imagine if you had to rewrite all your functors because you move from a state to a submachine... I'm afraid you're confusing a type, like state_machine with its function in the context of an outer state machine. You're not seeing a TERMINATE_STATE template parameter, right?
Here's some code that shows exactly what can be set where and when for anyone else who is trying to figure this out...
Let's typeid the parameters: rootFSM_action: When this executes, the current state is MSM_B, there is no containing FSM => STATE is MSM_B. FSM also because we have no outer fsm, but this a corner case. I wouldn't want to pass a dummy fsm. someAction: When this executes, the current state is MSM_A, containing FSM is MSM_B => STATE is MSM_A, FSM is MSM_B because this substate is contained by MSM_B. I fail to see what confuses you. FSM is the containing fsm, STATE is the state executing an entry/exit. Losing the information of which fsm is your outer fsm only because the state happens to be a submachine would surely make a lot of people unhappy. HTH, Christophe
Hi again. I understand what you are saying and I guess the real problem comes down to my (mis)understanding. The fsm object, as written, isn't a state machine -- rather it's a composite state. The fsm object itself represents the outer shell state, and the states inside the fsm represent the submachine. This is very clear when using a fsm as a sub-state-machine, but not so clear from the top level. Now that I better understand what's going on, I can see that you implmentation is indeed fully correct, it's just confusing to me because of nomenclature. I guess if there were any change, it would be to rename fsm's to "composite_states", and then write in the documentation that the top-level FSM is always composed of a single composite_state which you call directly, as the only difference between a composite state and an fsm is that an fsm would not normally have an entry and exit action. This is even more clear when I note that having an entry action on both the FSM and the initial state "seems redundant." And it is, but only for the top-most level composite state. For composite state embedded in other machines, history could cause the entry action on the composite state to be called, but the not the entry action on the (normally) initial state. As it seems too late for a change of that magnitude, I'll just have to content myself with a better understanding of what's going on... Thanks for taking your time to help. -Chiem
This is even more clear when I note that having an entry action on both the FSM and the initial state "seems redundant." And it is, but only for the top-most level composite state. For composite state embedded in other machines, history could cause the entry action on the composite state to be called, but the not the entry action on the (normally) initial state.
I don't think it's redundant if you consider the case of orthogonal regions. In this case, you usually want an entry action called only once. In any case, I think I have to precise the doc a bit on this. Regards, Christophe
participants (2)
-
Chiem Whua Ma -
Christophe Henry