]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // Copyright 2008 Christophe Henry |
2 | // henry UNDERSCORE christophe AT hotmail DOT com | |
3 | // This is an extended version of the state machine available in the boost::mpl library | |
4 | // Distributed under the same license as the original. | |
5 | // Copyright for the original version: | |
6 | // Copyright 2005 David Abrahams and Aleksey Gurtovoy. Distributed | |
7 | // under the Boost Software License, Version 1.0. (See accompanying | |
8 | // file LICENSE_1_0.txt or copy at | |
9 | // http://www.boost.org/LICENSE_1_0.txt) | |
10 | ||
11 | #ifndef BOOST_MSM_BACK_FAVOR_COMPILE_TIME_H | |
12 | #define BOOST_MSM_BACK_FAVOR_COMPILE_TIME_H | |
13 | ||
14 | #include <utility> | |
15 | #include <deque> | |
16 | ||
17 | #include <boost/mpl/filter_view.hpp> | |
18 | #include <boost/mpl/for_each.hpp> | |
19 | #include <boost/mpl/bool.hpp> | |
20 | #include <boost/any.hpp> | |
21 | ||
22 | #include <boost/msm/common.hpp> | |
23 | #include <boost/msm/back/metafunctions.hpp> | |
24 | #include <boost/msm/back/common_types.hpp> | |
25 | #include <boost/msm/back/dispatch_table.hpp> | |
26 | ||
27 | namespace boost { namespace msm { namespace back | |
28 | { | |
29 | ||
30 | template <class Fsm> | |
31 | struct process_any_event_helper | |
32 | { | |
33 | process_any_event_helper(msm::back::HandledEnum& res_,Fsm* self_,::boost::any any_event_): | |
34 | res(res_),self(self_),any_event(any_event_),finished(false){} | |
35 | template <class Event> | |
36 | void operator()(boost::msm::wrap<Event> const&) | |
37 | { | |
38 | if ( ! finished && ::boost::any_cast<Event>(&any_event)!=0) | |
39 | { | |
40 | finished = true; | |
41 | res = self->process_event_internal(::boost::any_cast<Event>(any_event),false); | |
42 | ||
43 | } | |
44 | } | |
45 | private: | |
46 | msm::back::HandledEnum& res; | |
47 | Fsm* self; | |
48 | ::boost::any any_event; | |
49 | bool finished; | |
50 | }; | |
51 | ||
52 | #define BOOST_MSM_BACK_GENERATE_PROCESS_EVENT(fsmname) \ | |
53 | namespace boost { namespace msm { namespace back{ \ | |
54 | template<> \ | |
55 | ::boost::msm::back::HandledEnum fsmname::process_any_event( ::boost::any const& any_event) \ | |
56 | { \ | |
57 | typedef ::boost::msm::back::recursive_get_transition_table<fsmname>::type stt; \ | |
58 | typedef ::boost::msm::back::generate_event_set<stt>::type stt_events; \ | |
59 | typedef ::boost::msm::back::recursive_get_internal_transition_table<fsmname, ::boost::mpl::true_ >::type istt; \ | |
60 | typedef ::boost::msm::back::generate_event_set<create_real_stt<fsmname,istt>::type >::type istt_events; \ | |
61 | typedef ::boost::msm::back::set_insert_range<stt_events,istt_events>::type all_events; \ | |
62 | ::boost::msm::back::HandledEnum res= ::boost::msm::back::HANDLED_FALSE; \ | |
63 | ::boost::mpl::for_each<all_events, ::boost::msm::wrap< ::boost::mpl::placeholders::_1> > \ | |
64 | (::boost::msm::back::process_any_event_helper<fsmname>(res,this,any_event)); \ | |
65 | return res; \ | |
66 | } \ | |
67 | }}} | |
68 | ||
69 | struct favor_compile_time | |
70 | { | |
71 | typedef int compile_policy; | |
72 | typedef ::boost::mpl::false_ add_forwarding_rows; | |
73 | }; | |
74 | ||
75 | // Generates a singleton runtime lookup table that maps current state | |
76 | // to a function that makes the SM take its transition on the given | |
77 | // Event type. | |
78 | template <class Fsm,class Stt, class Event> | |
79 | struct dispatch_table < Fsm, Stt, Event, ::boost::msm::back::favor_compile_time> | |
80 | { | |
81 | private: | |
82 | // This is a table of these function pointers. | |
83 | typedef HandledEnum (*cell)(Fsm&, int,int,Event const&); | |
84 | typedef bool (*guard)(Fsm&, Event const&); | |
85 | ||
86 | // Compute the maximum state value in the sm so we know how big | |
87 | // to make the table | |
88 | typedef typename generate_state_set<Stt>::type state_list; | |
89 | BOOST_STATIC_CONSTANT(int, max_state = ( ::boost::mpl::size<state_list>::value)); | |
90 | ||
91 | struct chain_row | |
92 | { | |
93 | HandledEnum operator()(Fsm& fsm, int region,int state,Event const& evt) const | |
94 | { | |
95 | HandledEnum res = HANDLED_FALSE; | |
96 | typename std::deque<cell>::const_iterator it = one_state.begin(); | |
97 | while (it != one_state.end() && (res != HANDLED_TRUE && res != HANDLED_DEFERRED )) | |
98 | { | |
99 | HandledEnum handled = (*it)(fsm,region,state,evt); | |
100 | // reject is considered as erasing an error (HANDLED_FALSE) | |
101 | if ((HANDLED_FALSE==handled) && (HANDLED_GUARD_REJECT==res) ) | |
102 | res = HANDLED_GUARD_REJECT; | |
103 | else | |
104 | res = handled; | |
105 | ++it; | |
106 | } | |
107 | return res; | |
108 | } | |
109 | std::deque<cell> one_state; | |
110 | }; | |
111 | template <class TransitionState> | |
112 | static HandledEnum call_submachine(Fsm& fsm, int , int , Event const& evt) | |
113 | { | |
114 | return (fsm.template get_state<TransitionState&>()).process_any_event( ::boost::any(evt)); | |
115 | } | |
116 | // A function object for use with mpl::for_each that stuffs | |
117 | // transitions into cells. | |
118 | struct init_cell | |
119 | { | |
120 | init_cell(dispatch_table* self_) | |
121 | : self(self_) | |
122 | {} | |
123 | // version for transition event not base of our event | |
124 | template <class Transition> | |
125 | typename ::boost::disable_if< | |
126 | typename ::boost::is_same<typename Transition::current_state_type,Fsm>::type | |
127 | ,void>::type | |
128 | init_event_base_case(Transition const&, ::boost::mpl::true_ const &) const | |
129 | { | |
130 | typedef typename create_stt<Fsm>::type stt; | |
131 | BOOST_STATIC_CONSTANT(int, state_id = | |
132 | (get_state_id<stt,typename Transition::current_state_type>::value)); | |
133 | self->entries[state_id+1].one_state.push_front(reinterpret_cast<cell>(&Transition::execute)); | |
134 | } | |
135 | template <class Transition> | |
136 | typename ::boost::enable_if< | |
137 | typename ::boost::is_same<typename Transition::current_state_type,Fsm>::type | |
138 | ,void>::type | |
139 | init_event_base_case(Transition const&, ::boost::mpl::true_ const &) const | |
140 | { | |
141 | self->entries[0].one_state.push_front(reinterpret_cast<cell>(&Transition::execute)); | |
142 | } | |
143 | ||
144 | // version for transition event base of our event | |
145 | template <class Transition> | |
146 | typename ::boost::disable_if< | |
147 | typename ::boost::is_same<typename Transition::current_state_type,Fsm>::type | |
148 | ,void>::type | |
149 | init_event_base_case(Transition const&, ::boost::mpl::false_ const &) const | |
150 | { | |
151 | typedef typename create_stt<Fsm>::type stt; | |
152 | BOOST_STATIC_CONSTANT(int, state_id = | |
153 | (get_state_id<stt,typename Transition::current_state_type>::value)); | |
154 | self->entries[state_id+1].one_state.push_front(&Transition::execute); | |
155 | } | |
156 | template <class Transition> | |
157 | typename ::boost::enable_if< | |
158 | typename ::boost::is_same<typename Transition::current_state_type,Fsm>::type | |
159 | ,void>::type | |
160 | init_event_base_case(Transition const&, ::boost::mpl::false_ const &) const | |
161 | { | |
162 | self->entries[0].one_state.push_front(&Transition::execute); | |
163 | } | |
164 | // Cell initializer function object, used with mpl::for_each | |
165 | template <class Transition> | |
166 | typename ::boost::enable_if<typename has_not_real_row_tag<Transition>::type,void >::type | |
167 | operator()(Transition const&,boost::msm::back::dummy<0> = 0) const | |
168 | { | |
169 | // version for not real rows. No problem because irrelevant for process_event | |
170 | } | |
171 | template <class Transition> | |
172 | typename ::boost::disable_if<typename has_not_real_row_tag<Transition>::type,void >::type | |
173 | operator()(Transition const& tr,boost::msm::back::dummy<1> = 0) const | |
174 | { | |
175 | //only if the transition event is a base of our event is the reinterpret_case safe | |
176 | init_event_base_case(tr, | |
177 | ::boost::mpl::bool_< | |
178 | ::boost::is_base_of<typename Transition::transition_event,Event>::type::value>() ); | |
179 | } | |
180 | ||
181 | dispatch_table* self; | |
182 | }; | |
183 | ||
184 | // Cell default-initializer function object, used with mpl::for_each | |
185 | // initializes with call_no_transition, defer_transition or default_eventless_transition | |
186 | // variant for non-anonymous transitions | |
187 | template <class EventType,class Enable=void> | |
188 | struct default_init_cell | |
189 | { | |
190 | default_init_cell(dispatch_table* self_,chain_row* tofill_entries_) | |
191 | : self(self_),tofill_entries(tofill_entries_) | |
192 | {} | |
193 | template <bool deferred,bool composite, int some_dummy=0> | |
194 | struct helper | |
195 | {}; | |
196 | template <int some_dummy> struct helper<true,false,some_dummy> | |
197 | { | |
198 | template <class State> | |
199 | static void execute(boost::msm::wrap<State> const&,chain_row* tofill) | |
200 | { | |
201 | typedef typename create_stt<Fsm>::type stt; | |
202 | BOOST_STATIC_CONSTANT(int, state_id = (get_state_id<stt,State>::value)); | |
203 | cell call_no_transition = &Fsm::defer_transition; | |
204 | tofill[state_id+1].one_state.push_back(call_no_transition); | |
205 | } | |
206 | }; | |
207 | template <int some_dummy> struct helper<true,true,some_dummy> | |
208 | { | |
209 | template <class State> | |
210 | static void execute(boost::msm::wrap<State> const&,chain_row* tofill) | |
211 | { | |
212 | typedef typename create_stt<Fsm>::type stt; | |
213 | BOOST_STATIC_CONSTANT(int, state_id = (get_state_id<stt,State>::value)); | |
214 | cell call_no_transition = &Fsm::defer_transition; | |
215 | tofill[state_id+1].one_state.push_back(call_no_transition); | |
216 | } | |
217 | }; | |
218 | template <int some_dummy> struct helper<false,true,some_dummy> | |
219 | { | |
220 | template <class State> | |
221 | static | |
222 | typename ::boost::enable_if< | |
223 | typename ::boost::is_same<State,Fsm>::type | |
224 | ,void>::type | |
225 | execute(boost::msm::wrap<State> const&,chain_row* tofill,boost::msm::back::dummy<0> = 0) | |
226 | { | |
227 | // for internal tables | |
228 | cell call_no_transition_internal = &Fsm::call_no_transition; | |
229 | tofill[0].one_state.push_front(call_no_transition_internal); | |
230 | } | |
231 | template <class State> | |
232 | static | |
233 | typename ::boost::disable_if< | |
234 | typename ::boost::is_same<State,Fsm>::type | |
235 | ,void>::type | |
236 | execute(boost::msm::wrap<State> const&,chain_row* tofill,boost::msm::back::dummy<1> = 0) | |
237 | { | |
238 | typedef typename create_stt<Fsm>::type stt; | |
239 | BOOST_STATIC_CONSTANT(int, state_id = (get_state_id<stt,State>::value)); | |
240 | cell call_no_transition = &call_submachine< State >; | |
241 | tofill[state_id+1].one_state.push_front(call_no_transition); | |
242 | } | |
243 | }; | |
244 | template <int some_dummy> struct helper<false,false,some_dummy> | |
245 | { | |
246 | template <class State> | |
247 | static void execute(boost::msm::wrap<State> const&,chain_row* tofill) | |
248 | { | |
249 | typedef typename create_stt<Fsm>::type stt; | |
250 | BOOST_STATIC_CONSTANT(int, state_id = (get_state_id<stt,State>::value)); | |
251 | cell call_no_transition = &Fsm::call_no_transition; | |
252 | tofill[state_id+1].one_state.push_back(call_no_transition); | |
253 | } | |
254 | }; | |
255 | template <class State> | |
256 | void operator()(boost::msm::wrap<State> const& s) | |
257 | { | |
258 | helper<has_state_delayed_event<State,Event>::type::value, | |
259 | is_composite_state<State>::type::value>::execute(s,tofill_entries); | |
260 | } | |
261 | dispatch_table* self; | |
262 | chain_row* tofill_entries; | |
263 | }; | |
264 | ||
265 | // variant for anonymous transitions | |
266 | template <class EventType> | |
267 | struct default_init_cell<EventType, | |
268 | typename ::boost::enable_if< | |
269 | typename is_completion_event<EventType>::type>::type> | |
270 | { | |
271 | default_init_cell(dispatch_table* self_,chain_row* tofill_entries_) | |
272 | : self(self_),tofill_entries(tofill_entries_) | |
273 | {} | |
274 | ||
275 | // this event is a compound one (not a real one, just one for use in event-less transitions) | |
276 | // Note this event cannot be used as deferred! | |
277 | template <class State> | |
278 | void operator()(boost::msm::wrap<State> const&) | |
279 | { | |
280 | typedef typename create_stt<Fsm>::type stt; | |
281 | BOOST_STATIC_CONSTANT(int, state_id = (get_state_id<stt,State>::value)); | |
282 | cell call_no_transition = &Fsm::default_eventless_transition; | |
283 | tofill_entries[state_id+1].one_state.push_back(call_no_transition); | |
284 | } | |
285 | ||
286 | dispatch_table* self; | |
287 | chain_row* tofill_entries; | |
288 | }; | |
289 | ||
290 | public: | |
291 | // initialize the dispatch table for a given Event and Fsm | |
292 | dispatch_table() | |
293 | { | |
294 | // Initialize cells for no transition | |
295 | ::boost::mpl::for_each< | |
296 | ::boost::mpl::filter_view< | |
297 | Stt, ::boost::is_base_of<transition_event< ::boost::mpl::placeholders::_>, Event> > > | |
298 | (init_cell(this)); | |
299 | ||
300 | ::boost::mpl::for_each< | |
301 | typename generate_state_set<Stt>::type, | |
302 | boost::msm::wrap< ::boost::mpl::placeholders::_1> > | |
303 | (default_init_cell<Event>(this,entries)); | |
304 | ||
305 | } | |
306 | ||
307 | // The singleton instance. | |
308 | static const dispatch_table instance; | |
309 | ||
310 | public: // data members | |
311 | chain_row entries[max_state+1]; | |
312 | }; | |
313 | ||
314 | template <class Fsm,class Stt, class Event> | |
315 | const boost::msm::back::dispatch_table<Fsm,Stt, Event,favor_compile_time> | |
316 | dispatch_table<Fsm,Stt, Event,favor_compile_time>::instance; | |
317 | ||
318 | }}} // boost::msm::back | |
319 | ||
320 | #endif //BOOST_MSM_BACK_FAVOR_COMPILE_TIME_H |