Subject: [Boost-commit] svn:boost r57714 - sandbox/msm/boost/msm/back
From: christophe.j.henry_at_[hidden]
Date: 2009-11-16 17:15:04
Author: chenry
Date: 2009-11-16 17:15:04 EST (Mon, 16 Nov 2009)
New Revision: 57714
URL: http://svn.boost.org/trac/boost/changeset/57714
Log:
bugfix deferred events: stack overflow when repeated deferred events.
Text files modified:
sandbox/msm/boost/msm/back/common_types.hpp | 3 +
sandbox/msm/boost/msm/back/state_machine.hpp | 45 +++++++++++++++++++++++----------------
2 files changed, 28 insertions(+), 20 deletions(-)
Modified: sandbox/msm/boost/msm/back/common_types.hpp
==============================================================================
--- sandbox/msm/boost/msm/back/common_types.hpp (original)
+++ sandbox/msm/boost/msm/back/common_types.hpp 2009-11-16 17:15:04 EST (Mon, 16 Nov 2009)
@@ -22,7 +22,8 @@
{
HANDLED_FALSE=0,
HANDLED_TRUE =1,
- HANDLED_GUARD_REJECT=2
+ HANDLED_GUARD_REJECT=2,
+ HANDLED_DEFERRED=4
} HandledEnum;
typedef HandledEnum execute_return;
Modified: sandbox/msm/boost/msm/back/state_machine.hpp
==============================================================================
--- sandbox/msm/boost/msm/back/state_machine.hpp (original)
+++ sandbox/msm/boost/msm/back/state_machine.hpp 2009-11-16 17:15:04 EST (Mon, 16 Nov 2009)
@@ -98,7 +98,7 @@
execute_return ()> transition_fct;
typedef ::boost::function<
execute_return () > deferred_fct;
- typedef std::queue<deferred_fct > deferred_events_queue_t;
+ typedef std::deque<deferred_fct > deferred_events_queue_t;
typedef std::queue<transition_fct > events_queue_t;
typedef bool (*flag_handler)(library_sm&);
@@ -668,13 +668,13 @@
handle_defer_helper<library_sm> defer_helper(m_deferred_events_queue);
defer_helper.do_pre_handle_deferred();
// process event
- bool handled = this->do_process_helper<library_sm,Event>(evt);
+ HandledEnum handled = this->do_process_helper<library_sm,Event>(evt);
if (handled)
{
ret_handled = HANDLED_TRUE;
}
// after handling, take care of the deferred events
- defer_helper.do_post_handle_deferred();
+ defer_helper.do_post_handle_deferred(handled);
// now check if some events were generated in a transition and was not handled
// because of another processing, and if yes, start handling them
@@ -682,7 +682,7 @@
// event can be handled, processing
// handle with lowest priority event-less transitions
- handle_eventless_transitions_helper<library_sm> eventless_helper(this,handled);
+ handle_eventless_transitions_helper<library_sm> eventless_helper(this,(handled!=HANDLED_FALSE));
eventless_helper.process_automatic_event();
return ret_handled;
@@ -809,7 +809,7 @@
};
public:
// Construct with the default initial states
- state_machine<Derived,HistoryPolicy
+ state_machine<Derived,HistoryPolicy
#ifdef BOOST_MSVC
,WorkaroundVC9
#endif
@@ -830,7 +830,7 @@
// create states
fill_states(this);
}
-
+
// Construct with the default initial states and some default argument(s)
#ifdef BOOST_MSVC
@@ -884,6 +884,7 @@
#endif
+
// assignment operator using the copy policy to decide if non_copyable, shallow or deep copying is necessary
library_sm& operator= (library_sm const& rhs)
{
@@ -977,13 +978,13 @@
}
// the following 2 functions handle the processing either with a try/catch protection or without
template <class StateType,class EventType>
- typename ::boost::enable_if<typename is_no_exception_thrown<StateType>::type,bool >::type
+ typename ::boost::enable_if<typename is_no_exception_thrown<StateType>::type,HandledEnum >::type
do_process_helper(EventType const& evt, ::boost::msm::back::dummy<0> = 0)
{
return this->do_process_event(evt);
}
template <class StateType,class EventType>
- typename ::boost::disable_if<typename is_no_exception_thrown<StateType>::type,bool >::type
+ typename ::boost::disable_if<typename is_no_exception_thrown<StateType>::type,HandledEnum >::type
do_process_helper(EventType const& evt, ::boost::msm::back::dummy<1> = 0)
{
try
@@ -995,7 +996,7 @@
// give a chance to the concrete state machine to handle
this->exception_caught(evt,*this,e);
}
- return false;
+ return HANDLED_FALSE;
}
// handling of deferred events
// if none is found in the SM, take the following empty main version
@@ -1007,7 +1008,7 @@
{
}
- void do_post_handle_deferred()
+ void do_post_handle_deferred(HandledEnum)
{
}
};
@@ -1021,14 +1022,20 @@
{
if (!events_queue.empty())
{
- next_deferred_event = events_queue.front();
- events_queue.pop();
+ next_deferred_event = events_queue.back();
+ events_queue.pop_back();
}
}
- void do_post_handle_deferred()
+ void do_post_handle_deferred(HandledEnum handled)
{
- if (next_deferred_event)
+ if (((handled & HANDLED_DEFERRED) == HANDLED_DEFERRED) && next_deferred_event )
+ {
+ // the event was already deferred, no reason to process another deferred event
+ events_queue.push_back(next_deferred_event);
+ return;
+ }
+ else if (next_deferred_event)
{
next_deferred_event();
}
@@ -1073,12 +1080,12 @@
// minimum event processing without exceptions, queues, etc.
template<class Event>
- bool do_process_event(Event const& evt)
+ HandledEnum do_process_event(Event const& evt)
{
// use this table as if it came directly from the user
typedef dispatch_table<library_sm,complete_table,Event> table;
- bool handled = false;
+ HandledEnum handled = HANDLED_FALSE;
// dispatch the event to every region
for (int i=0; i<nr_regions::value;++i)
{
@@ -1086,7 +1093,7 @@
table::instance.entries[this->m_states[i]](
*this, this->m_states[i], evt);
this->m_states[i] = res.first;
- handled = (handled || res.second);
+ handled = (HandledEnum)((int)handled | (int)res.second);
}
// if the event has not been handled and we have orthogonal zones, then
// generate an error on every active state
@@ -1631,7 +1638,7 @@
Event temp (e);
::boost::function<execute_return () > f= ::boost::bind(pf, ::boost::ref(fsm),temp);
fsm.post_deferred_event(f);
- return std::make_pair(state,HANDLED_TRUE);
+ return std::make_pair(state,HANDLED_DEFERRED);
}
// called for automatic events. Default address set in the dispatch_table at init
@@ -1645,7 +1652,7 @@
// puts a deferred event in the queue
void post_deferred_event(deferred_fct& deferred)
{
- m_deferred_events_queue.push(deferred);
+ m_deferred_events_queue.push_front(deferred);
}
// removes one event from the message queue and processes it
void process_message_queue()