EIC code displayed by LXR master/​include/​boost/​statechart/​state_machine.hpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 09:52:32

 #ifndef BOOST_STATECHART_STATE_MACHINE_HPP_INCLUDED
 #define BOOST_STATECHART_STATE_MACHINE_HPP_INCLUDED
 //////////////////////////////////////////////////////////////////////////////
 // Copyright 2002-2010 Andreas Huber Doenni
 // Distributed under the Boost Software License, Version 1.0. (See accompany-
 // ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //////////////////////////////////////////////////////////////////////////////
 
 
 
 #include <boost/statechart/event.hpp>
 #include <boost/statechart/null_exception_translator.hpp>
 #include <boost/statechart/result.hpp>
 
 #include <boost/statechart/detail/rtti_policy.hpp>
 #include <boost/statechart/detail/state_base.hpp>
 #include <boost/statechart/detail/leaf_state.hpp>
 #include <boost/statechart/detail/node_state.hpp>
 #include <boost/statechart/detail/constructor.hpp>
 #include <boost/statechart/detail/avoid_unused_warning.hpp>
 
 #include <boost/mpl/list.hpp>
 #include <boost/mpl/clear.hpp>
 #include <boost/mpl/if.hpp>
 #include <boost/mpl/at.hpp>
 #include <boost/mpl/integral_c.hpp>
 #include <boost/mpl/minus.hpp>
 #include <boost/mpl/equal_to.hpp>
 
 #include <boost/intrusive_ptr.hpp>
 #include <boost/type_traits/is_pointer.hpp>
 #include <boost/type_traits/remove_reference.hpp>
 #include <boost/noncopyable.hpp>
 #include <boost/assert.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/polymorphic_cast.hpp> // boost::polymorphic_downcast
 // BOOST_NO_EXCEPTIONS, BOOST_MSVC, BOOST_MSVC_STD_ITERATOR
 #include <boost/config.hpp>
 
 #include <boost/detail/allocator_utilities.hpp>
 
 #ifdef BOOST_MSVC
 #  pragma warning( push )
 #  pragma warning( disable: 4702 ) // unreachable code (in release mode only)
 #endif
 
 #include <map>
 
 #ifdef BOOST_MSVC
 #  pragma warning( pop )
 #endif
 
 #include <memory>   // std::allocator
 #include <typeinfo> // std::bad_cast
 #include <functional> // std::less
 #include <iterator>
 
 
 
 namespace boost
 {
 namespace statechart
 {
 namespace detail
 {
 
 
 
 //////////////////////////////////////////////////////////////////////////////
 template< class StateBaseType, class EventBaseType, class IdType >
 class send_function
 {
   public:
     //////////////////////////////////////////////////////////////////////////
     send_function(
       StateBaseType & toState,
       const EventBaseType & evt,
       IdType eventType
     ) :
       toState_( toState ), evt_( evt ), eventType_( eventType )
     {
     }
 
     result operator()()
     {
       return detail::result_utility::make_result(
         toState_.react_impl( evt_, eventType_ ) );
     }
 
   private:
     //////////////////////////////////////////////////////////////////////////
     // avoids C4512 (assignment operator could not be generated)
     send_function & operator=( const send_function & );
 
     StateBaseType & toState_;
     const EventBaseType & evt_;
     IdType eventType_;
 };
 
 
 //////////////////////////////////////////////////////////////////////////////
 struct state_cast_impl_pointer_target
 {
   public:
     //////////////////////////////////////////////////////////////////////////
     template< class StateBaseType >
     static const StateBaseType * deref_if_necessary(
       const StateBaseType * pState )
     {
       return pState;
     }
 
     template< class Target, class IdType >
     static IdType type_id()
     {
       Target p = 0;
       return type_id_impl< IdType >( p );
     }
 
     static bool found( const void * pFound )
     {
       return pFound != 0;
     }
 
     template< class Target >
     static Target not_found()
     {
       return 0;
     }
 
   private:
     //////////////////////////////////////////////////////////////////////////
     template< class IdType, class Type >
     static IdType type_id_impl( const Type * )
     {
       return Type::static_type();
     }
 };
 
 struct state_cast_impl_reference_target
 {
   template< class StateBaseType >
   static const StateBaseType & deref_if_necessary(
     const StateBaseType * pState )
   {
     return *pState;
   }
 
   template< class Target, class IdType >
   static IdType type_id()
   {
     return remove_reference< Target >::type::static_type();
   }
 
   template< class Dummy >
   static bool found( const Dummy & )
   {
     return true;
   }
 
   template< class Target >
   static Target not_found()
   {
     throw std::bad_cast();
   }
 };
 
 template< class Target >
 struct state_cast_impl : public mpl::if_<
   is_pointer< Target >,
   state_cast_impl_pointer_target,
   state_cast_impl_reference_target
 >::type {};
 
 
 //////////////////////////////////////////////////////////////////////////////
 template< class RttiPolicy >
 class history_key
 {
   public:
     //////////////////////////////////////////////////////////////////////////
     template< class HistorizedState >
     static history_key make_history_key()
     {
       return history_key(
         HistorizedState::context_type::static_type(),
         HistorizedState::orthogonal_position::value );
     }
 
     typename RttiPolicy::id_type history_context_type() const
     {
       return historyContextType_;
     }
 
     friend bool operator<(
       const history_key & left, const history_key & right )
     {
       return
         std::less< typename RttiPolicy::id_type >()( 
           left.historyContextType_, right.historyContextType_ ) ||
         ( ( left.historyContextType_ == right.historyContextType_ ) &&
           ( left.historizedOrthogonalRegion_ <
             right.historizedOrthogonalRegion_ ) );
     }
 
   private:
     //////////////////////////////////////////////////////////////////////////
     history_key(
       typename RttiPolicy::id_type historyContextType, 
       orthogonal_position_type historizedOrthogonalRegion
     ) :
       historyContextType_( historyContextType ),
       historizedOrthogonalRegion_( historizedOrthogonalRegion )
     {
     }
 
     // avoids C4512 (assignment operator could not be generated)
     history_key & operator=( const history_key & );
 
     const typename RttiPolicy::id_type historyContextType_;
     const orthogonal_position_type historizedOrthogonalRegion_;
 };
 
 
 
 } // namespace detail
 
 
 
 //////////////////////////////////////////////////////////////////////////////
 template< class MostDerived,
           class InitialState,
           class Allocator = std::allocator< none >,
           class ExceptionTranslator = null_exception_translator >
 class state_machine : noncopyable
 {
   public:
     //////////////////////////////////////////////////////////////////////////
     typedef Allocator allocator_type;
     typedef detail::rtti_policy rtti_policy_type;
     typedef event_base event_base_type;
     typedef intrusive_ptr< const event_base_type > event_base_ptr_type;
 
     void initiate()
     {
       terminate();
 
       {
         terminator guard( *this, 0 );
         detail::result_utility::get_result( translator_(
           initial_construct_function( *this ),
           exception_event_handler( *this ) ) );
         guard.dismiss();
       }
 
       process_queued_events();
     }
 
     void terminate()
     {
       terminator guard( *this, 0 );
       detail::result_utility::get_result( translator_(
         terminate_function( *this ),
         exception_event_handler( *this ) ) );
       guard.dismiss();
     }
 
     bool terminated() const
     {
       return pOutermostState_ == 0;
     }
 
     void process_event( const event_base_type & evt )
     {
       if ( send_event( evt ) == detail::do_defer_event )
       {
         deferredEventQueue_.push_back( evt.intrusive_from_this() );
       }
 
       process_queued_events();
     }
 
     template< class Target >
     Target state_cast() const
     {
       typedef detail::state_cast_impl< Target > impl;
 
       for ( typename state_list_type::const_iterator pCurrentLeafState =
               currentStates_.begin();
             pCurrentLeafState != currentStatesEnd_;
             ++pCurrentLeafState )
       {
         const state_base_type * pCurrentState(
           get_pointer( *pCurrentLeafState ) );
 
         while ( pCurrentState != 0 )
         {
           // The unnecessary try/catch overhead for pointer targets is
           // typically small compared to the cycles dynamic_cast needs
           #ifndef BOOST_NO_EXCEPTIONS
           try
           #endif
           {
             Target result = dynamic_cast< Target >(
               impl::deref_if_necessary( pCurrentState ) );
 
             if ( impl::found( result ) )
             {
               return result;
             }
           }
           #ifndef BOOST_NO_EXCEPTIONS
           // Intentionally swallow std::bad_cast exceptions. We'll throw one
           // ourselves when we fail to find a state that can be cast to Target
           catch ( const std::bad_cast & ) {}
           #endif
 
           pCurrentState = pCurrentState->outer_state_ptr();
         }
       }
 
       return impl::template not_found< Target >();
     }
 
     template< class Target >
     Target state_downcast() const
     {
       typedef detail::state_cast_impl< Target > impl;
 
       typename rtti_policy_type::id_type targetType =
         impl::template type_id< Target, rtti_policy_type::id_type >();
 
       for ( typename state_list_type::const_iterator pCurrentLeafState =
               currentStates_.begin();
             pCurrentLeafState != currentStatesEnd_;
             ++pCurrentLeafState )
       {
         const state_base_type * pCurrentState(
           get_pointer( *pCurrentLeafState ) );
 
         while ( pCurrentState != 0 )
         {
           if ( pCurrentState->dynamic_type() == targetType )
           {
             return static_cast< Target >(
               impl::deref_if_necessary( pCurrentState ) );
           }
 
           pCurrentState = pCurrentState->outer_state_ptr();
         }
       }
 
       return impl::template not_found< Target >();
     }
 
     typedef detail::state_base< allocator_type, rtti_policy_type >
       state_base_type;
 
     class state_iterator : public std::iterator<
       std::forward_iterator_tag,
       state_base_type, std::ptrdiff_t
       #ifndef BOOST_MSVC_STD_ITERATOR
       , const state_base_type *, const state_base_type &
       #endif
     >
     {
       public:
         //////////////////////////////////////////////////////////////////////
         explicit state_iterator(
           typename state_base_type::state_list_type::const_iterator 
             baseIterator
         ) : baseIterator_( baseIterator ) {}
 
         const state_base_type & operator*() const { return **baseIterator_; }
         const state_base_type * operator->() const
         {
           return &**baseIterator_;
         }
 
         state_iterator & operator++() { ++baseIterator_; return *this; }
         state_iterator operator++( int )
         {
           return state_iterator( baseIterator_++ );
         }
 
         bool operator==( const state_iterator & right ) const
         {
           return baseIterator_ == right.baseIterator_;
         }
         bool operator!=( const state_iterator & right ) const
         {
           return !( *this == right );
         }
 
       private:
         typename state_base_type::state_list_type::const_iterator
           baseIterator_;
     };
 
     state_iterator state_begin() const
     {
       return state_iterator( currentStates_.begin() );
     }
 
     state_iterator state_end() const
     {
       return state_iterator( currentStatesEnd_ );
     }
 
     void unconsumed_event( const event_base & ) {}
 
   protected:
     //////////////////////////////////////////////////////////////////////////
     state_machine() :
       currentStatesEnd_( currentStates_.end() ),
       pOutermostState_( 0 ),
       isInnermostCommonOuter_( false ),
       performFullExit_( true ),
       pTriggeringEvent_( 0 )
     {
     }
 
     // This destructor was only made virtual so that that
     // polymorphic_downcast can be used to cast to MostDerived.
     virtual ~state_machine()
     {
       terminate_impl( false );
     }
 
     void post_event( const event_base_ptr_type & pEvent )
     {
       post_event_impl( pEvent );
     }
 
     void post_event( const event_base & evt )
     {
       post_event_impl( evt );
     }
 
   public:
     //////////////////////////////////////////////////////////////////////////
     // The following declarations should be protected.
     // They are only public because many compilers lack template friends.
     //////////////////////////////////////////////////////////////////////////
     template<
       class HistoryContext,
       detail::orthogonal_position_type orthogonalPosition >
     void clear_shallow_history()
     {
       // If you receive a
       // "use of undefined type 'boost::STATIC_ASSERTION_FAILURE<x>'" or
       // similar compiler error here then you tried to clear shallow history
       // for a state that does not have shallow history. That is, the state
       // does not pass either statechart::has_shallow_history or
       // statechart::has_full_history to its base class template.
       BOOST_STATIC_ASSERT( HistoryContext::shallow_history::value );
 
       typedef typename mpl::at_c<
         typename HistoryContext::inner_initial_list,
         orthogonalPosition >::type historized_state;
 
       store_history_impl(
         shallowHistoryMap_,
         history_key_type::make_history_key< historized_state >(),
         0 );
     }
 
     template<
       class HistoryContext,
       detail::orthogonal_position_type orthogonalPosition >
     void clear_deep_history()
     {
       // If you receive a
       // "use of undefined type 'boost::STATIC_ASSERTION_FAILURE<x>'" or
       // similar compiler error here then you tried to clear deep history for
       // a state that does not have deep history. That is, the state does not
       // pass either statechart::has_deep_history or
       // statechart::has_full_history to its base class template
       BOOST_STATIC_ASSERT( HistoryContext::deep_history::value );
 
       typedef typename mpl::at_c<
         typename HistoryContext::inner_initial_list,
         orthogonalPosition >::type historized_state;
 
       store_history_impl(
         deepHistoryMap_,
         history_key_type::make_history_key< historized_state >(),
         0 );
     }
 
     const event_base_type * triggering_event() const
     {
         return pTriggeringEvent_;
     }
 
   public:
     //////////////////////////////////////////////////////////////////////////
     // The following declarations should be private.
     // They are only public because many compilers lack template friends.
     //////////////////////////////////////////////////////////////////////////
     typedef MostDerived inner_context_type;
     typedef mpl::integral_c< detail::orthogonal_position_type, 0 >
       inner_orthogonal_position;
     typedef mpl::integral_c< detail::orthogonal_position_type, 1 >
       no_of_orthogonal_regions;
 
     typedef MostDerived outermost_context_type;
     typedef state_machine outermost_context_base_type;
     typedef state_machine * inner_context_ptr_type;
     typedef typename state_base_type::node_state_base_ptr_type
       node_state_base_ptr_type;
     typedef typename state_base_type::leaf_state_ptr_type leaf_state_ptr_type;
     typedef typename state_base_type::state_list_type state_list_type;
 
     typedef mpl::clear< mpl::list<> >::type context_type_list;
 
     typedef mpl::bool_< false > shallow_history;
     typedef mpl::bool_< false > deep_history;
     typedef mpl::bool_< false > inherited_deep_history;
 
     void post_event_impl( const event_base_ptr_type & pEvent )
     {
       BOOST_ASSERT( get_pointer( pEvent ) != 0 );
       eventQueue_.push_back( pEvent );
     }
 
     void post_event_impl( const event_base & evt )
     {
       post_event_impl( evt.intrusive_from_this() );
     }
 
     detail::reaction_result react_impl(
       const event_base_type &,
       typename rtti_policy_type::id_type )
     {
       return detail::do_forward_event;
     }
 
     void exit_impl(
       inner_context_ptr_type &,
       typename state_base_type::node_state_base_ptr_type &,
       bool ) {}
 
     void set_outermost_unstable_state(
       typename state_base_type::node_state_base_ptr_type &
         pOutermostUnstableState )
     {
       pOutermostUnstableState = 0;
     }
 
     // Returns a reference to the context identified by the template
     // parameter. This can either be _this_ object or one of its direct or
     // indirect contexts.
     template< class Context >
     Context & context()
     {
       // As we are in the outermost context here, only this object can be
       // returned.
       return *polymorphic_downcast< MostDerived * >( this );
     }
 
     template< class Context >
     const Context & context() const
     {
       // As we are in the outermost context here, only this object can be
       // returned.
       return *polymorphic_downcast< const MostDerived * >( this );
     }
 
     outermost_context_type & outermost_context()
     {
       return *polymorphic_downcast< MostDerived * >( this );
     }
 
     const outermost_context_type & outermost_context() const
     {
       return *polymorphic_downcast< const MostDerived * >( this );
     }
 
     outermost_context_base_type & outermost_context_base()
     {
       return *this;
     }
 
     const outermost_context_base_type & outermost_context_base() const
     {
       return *this;
     }
 
     void terminate_as_reaction( state_base_type & theState )
     {
       terminate_impl( theState, performFullExit_ );
       pOutermostUnstableState_ = 0;
     }
 
     void terminate_as_part_of_transit( state_base_type & theState )
     {
       terminate_impl( theState, performFullExit_ );
       isInnermostCommonOuter_ = true;
     }
 
     void terminate_as_part_of_transit( state_machine & )
     {
       terminate_impl( *pOutermostState_, performFullExit_ );
       isInnermostCommonOuter_ = true;
     }
 
 
     template< class State >
     void add( const intrusive_ptr< State > & pState )
     {
       // The second dummy argument is necessary because the call to the
       // overloaded function add_impl would otherwise be ambiguous.
       node_state_base_ptr_type pNewOutermostUnstableStateCandidate =
         add_impl( pState, *pState );
 
       if ( isInnermostCommonOuter_ ||
         ( is_in_highest_orthogonal_region< State >() &&
         ( get_pointer( pOutermostUnstableState_ ) ==
           pState->State::outer_state_ptr() ) ) )
       {
         isInnermostCommonOuter_ = false;
         pOutermostUnstableState_ = pNewOutermostUnstableStateCandidate;
       }
     }
 
 
     void add_inner_state(
       detail::orthogonal_position_type position,
       state_base_type * pOutermostState )
     {
       BOOST_ASSERT( position == 0 );
       detail::avoid_unused_warning( position );
       pOutermostState_ = pOutermostState;
     }
 
     void remove_inner_state( detail::orthogonal_position_type position )
     {
       BOOST_ASSERT( position == 0 );
       detail::avoid_unused_warning( position );
       pOutermostState_ = 0;
     }
 
 
     void release_events()
     {
       eventQueue_.splice( eventQueue_.begin(), deferredEventQueue_ );
     }
 
 
     template< class HistorizedState >
     void store_shallow_history()
     {
       // 5.2.10.6 declares that reinterpret_casting a function pointer to a
       // different function pointer and back must yield the same value. The
       // following reinterpret_cast is the first half of such a sequence.
       store_history_impl(
         shallowHistoryMap_,
         history_key_type::make_history_key< HistorizedState >(),
         reinterpret_cast< void (*)() >( &HistorizedState::deep_construct ) );
     }
 
     template< class DefaultState >
     void construct_with_shallow_history(
       const typename DefaultState::context_ptr_type & pContext )
     {
       construct_with_history_impl< DefaultState >(
         shallowHistoryMap_, pContext );
     }
 
 
     template< class HistorizedState, class LeafState >
     void store_deep_history()
     {
       typedef typename detail::make_context_list<
         typename HistorizedState::context_type,
         LeafState >::type history_context_list;
       typedef detail::constructor< 
         history_context_list, outermost_context_base_type > constructor_type;
       // 5.2.10.6 declares that reinterpret_casting a function pointer to a
       // different function pointer and back must yield the same value. The
       // following reinterpret_cast is the first half of such a sequence.
       store_history_impl(
         deepHistoryMap_, 
         history_key_type::make_history_key< HistorizedState >(),
         reinterpret_cast< void (*)() >( &constructor_type::construct ) );
     }
 
     template< class DefaultState >
     void construct_with_deep_history(
       const typename DefaultState::context_ptr_type & pContext )
     {
       construct_with_history_impl< DefaultState >(
         deepHistoryMap_, pContext );
     }
 
   private: // implementation
     //////////////////////////////////////////////////////////////////////////
     void initial_construct()
     {
       InitialState::initial_deep_construct(
         *polymorphic_downcast< MostDerived * >( this ) );
     }
 
     class initial_construct_function
     {
       public:
         //////////////////////////////////////////////////////////////////////
         initial_construct_function( state_machine & machine ) :
           machine_( machine )
         {
         }
 
         result operator()()
         {
           machine_.initial_construct();
           return detail::result_utility::make_result(
             detail::do_discard_event ); // there is nothing to be consumed
         }
 
       private:
         //////////////////////////////////////////////////////////////////////
         // avoids C4512 (assignment operator could not be generated)
         initial_construct_function & operator=(
           const initial_construct_function & );
 
         state_machine & machine_;
     };
     friend class initial_construct_function;
 
     class terminate_function
     {
       public:
         //////////////////////////////////////////////////////////////////////
         terminate_function( state_machine & machine ) : machine_( machine ) {}
 
         result operator()()
         {
           machine_.terminate_impl( true );
           return detail::result_utility::make_result(
             detail::do_discard_event ); // there is nothing to be consumed
         }
 
       private:
         //////////////////////////////////////////////////////////////////////
         // avoids C4512 (assignment operator could not be generated)
         terminate_function & operator=( const terminate_function & );
 
         state_machine & machine_;
     };
     friend class terminate_function;
 
     template< class ExceptionEvent >
     detail::reaction_result handle_exception_event(
       const ExceptionEvent & exceptionEvent,
       state_base_type * pCurrentState )
     {
       if ( terminated() )
       {
         // there is no state that could handle the exception -> bail out
         throw;
       }
 
       // If we are stable, an event handler has thrown.
       // Otherwise, either a state constructor, a transition action or an exit
       // function has thrown and the state machine is now in an invalid state.
       // This situation can be resolved by the exception event handler
       // function by orderly transiting to another state or terminating.
       // As a result of this, the machine must not be unstable when this
       // function is left.
       state_base_type * const pOutermostUnstableState =
         get_pointer( pOutermostUnstableState_ );
       state_base_type * const pHandlingState = pOutermostUnstableState == 0 ?
         pCurrentState : pOutermostUnstableState;
 
       BOOST_ASSERT( pHandlingState != 0 );
       terminator guard( *this, &exceptionEvent );
       // There is another scope guard up the call stack, which will terminate
       // the machine. So this guard only sets the triggering event.
       guard.dismiss();
 
       // Setting a member variable to a special value for the duration of a
       // call surely looks like a kludge (normally it should be a parameter of
       // the call). However, in this case it is unavoidable because the call
       // below could result in a call to user code where passing through an
       // additional bool parameter is not acceptable.
       performFullExit_ = false;
       const detail::reaction_result reactionResult = pHandlingState->react_impl(
         exceptionEvent, exceptionEvent.dynamic_type() );
       // If the above call throws then performFullExit_ will obviously not be
       // set back to true. In this case the termination triggered by the
       // scope guard further up in the call stack will take care of this.
       performFullExit_ = true;
 
       if ( ( reactionResult != detail::do_discard_event ) ||
         ( get_pointer( pOutermostUnstableState_ ) != 0 ) )
       {
         throw;
       }
 
       return detail::do_discard_event;
     }
 
     class exception_event_handler
     {
       public:
         //////////////////////////////////////////////////////////////////////
         exception_event_handler(
           state_machine & machine,
           state_base_type * pCurrentState = 0
         ) :
           machine_( machine ),
           pCurrentState_( pCurrentState )
         {
         }
 
         template< class ExceptionEvent >
         result operator()(
           const ExceptionEvent & exceptionEvent )
         {
           return detail::result_utility::make_result(
             machine_.handle_exception_event(
               exceptionEvent, pCurrentState_ ) );
         }
 
       private:
         //////////////////////////////////////////////////////////////////////
         // avoids C4512 (assignment operator could not be generated)
         exception_event_handler & operator=(
           const exception_event_handler & );
 
         state_machine & machine_;
         state_base_type * pCurrentState_;
     };
     friend class exception_event_handler;
 
     class terminator
     {
       public:
         //////////////////////////////////////////////////////////////////////
         terminator(
           state_machine & machine, const event_base * pNewTriggeringEvent ) :
           machine_( machine ),
           pOldTriggeringEvent_(machine_.pTriggeringEvent_),
           dismissed_( false )
         {
             machine_.pTriggeringEvent_ = pNewTriggeringEvent;
         }
 
         ~terminator()
         {
           if ( !dismissed_ ) { machine_.terminate_impl( false ); }
           machine_.pTriggeringEvent_ = pOldTriggeringEvent_;
         }
 
         void dismiss() { dismissed_ = true; }
 
       private:
         //////////////////////////////////////////////////////////////////////
         // avoids C4512 (assignment operator could not be generated)
         terminator & operator=( const terminator & );
 
         state_machine & machine_;
         const event_base_type * const pOldTriggeringEvent_;
         bool dismissed_;
     };
     friend class terminator;
 
 
     detail::reaction_result send_event( const event_base_type & evt )
     {
       terminator guard( *this, &evt );
       BOOST_ASSERT( get_pointer( pOutermostUnstableState_ ) == 0 );
       const typename rtti_policy_type::id_type eventType = evt.dynamic_type();
       detail::reaction_result reactionResult = detail::do_forward_event;
       
       for (
         typename state_list_type::iterator pState = currentStates_.begin();
         ( reactionResult == detail::do_forward_event ) &&
           ( pState != currentStatesEnd_ );
         ++pState )
       {
         // CAUTION: The following statement could modify our state list!
         // We must not continue iterating if the event was consumed
         reactionResult = detail::result_utility::get_result( translator_(
           detail::send_function<
             state_base_type, event_base_type, rtti_policy_type::id_type >(
               **pState, evt, eventType ),
           exception_event_handler( *this, get_pointer( *pState ) ) ) );
       }
 
       guard.dismiss();
 
       if ( reactionResult == detail::do_forward_event )
       {
         polymorphic_downcast< MostDerived * >( this )->unconsumed_event( evt );
       }
 
       return reactionResult;
     }
 
 
     void process_queued_events()
     {
       while ( !eventQueue_.empty() )
       {
         event_base_ptr_type pEvent = eventQueue_.front();
         eventQueue_.pop_front();
 
         if ( send_event( *pEvent ) == detail::do_defer_event )
         {
           deferredEventQueue_.push_back( pEvent );
         }
       }
     }
 
 
     void terminate_impl( bool performFullExit )
     {
       performFullExit_ = true;
 
       if ( !terminated() )
       {
         terminate_impl( *pOutermostState_, performFullExit );
       }
 
       eventQueue_.clear();
       deferredEventQueue_.clear();
       shallowHistoryMap_.clear();
       deepHistoryMap_.clear();
     }
 
     void terminate_impl( state_base_type & theState, bool performFullExit )
     {
       isInnermostCommonOuter_ = false;
 
       // If pOutermostUnstableState_ == 0, we know for sure that
       // currentStates_.size() > 0, otherwise theState couldn't be alive any
       // more
       if ( get_pointer( pOutermostUnstableState_ ) != 0 )
       {
         theState.remove_from_state_list(
           currentStatesEnd_, pOutermostUnstableState_, performFullExit );
       }
       // Optimization: We want to find out whether currentStates_ has size 1
       // and if yes use the optimized implementation below. Since
       // list<>::size() is implemented quite inefficiently in some std libs
       // it is best to just decrement the currentStatesEnd_ here and
       // increment it again, if the test failed.
       else if ( currentStates_.begin() == --currentStatesEnd_ )
       {
         // The machine is stable and there is exactly one innermost state.
         // The following optimization is only correct for a stable machine
         // without orthogonal regions.
         leaf_state_ptr_type & pState = *currentStatesEnd_;
         pState->exit_impl(
           pState, pOutermostUnstableState_, performFullExit );
       }
       else
       {
         BOOST_ASSERT( currentStates_.size() > 1 );
         // The machine is stable and there are multiple innermost states
         theState.remove_from_state_list(
           ++currentStatesEnd_, pOutermostUnstableState_, performFullExit );
       }
     }
 
 
     node_state_base_ptr_type add_impl(
       const leaf_state_ptr_type & pState,
       detail::leaf_state< allocator_type, rtti_policy_type > & )
     {
       if ( currentStatesEnd_ == currentStates_.end() )
       {
         pState->set_list_position( 
           currentStates_.insert( currentStatesEnd_, pState ) );
       }
       else
       {
         *currentStatesEnd_ = pState;
         pState->set_list_position( currentStatesEnd_ );
         ++currentStatesEnd_;
       }
 
       return 0;
     }
 
     node_state_base_ptr_type add_impl(
       const node_state_base_ptr_type & pState,
       state_base_type & )
     {
       return pState;
     }
 
     template< class State >
     static bool is_in_highest_orthogonal_region()
     {
       return mpl::equal_to<
         typename State::orthogonal_position,
         mpl::minus< 
           typename State::context_type::no_of_orthogonal_regions,
           mpl::integral_c< detail::orthogonal_position_type, 1 > >
       >::value;
     }
 
 
     typedef detail::history_key< rtti_policy_type > history_key_type;
 
     typedef std::map<
       history_key_type, void (*)(),
       std::less< history_key_type >,
       typename boost::detail::allocator::rebind_to<
         allocator_type, std::pair< const history_key_type, void (*)() >
       >::type
     > history_map_type;
 
     void store_history_impl(
       history_map_type & historyMap,
       const history_key_type & historyId,
       void (*pConstructFunction)() )
     {
       historyMap[ historyId ] = pConstructFunction;
     }
 
     template< class DefaultState >
     void construct_with_history_impl(
       history_map_type & historyMap,
       const typename DefaultState::context_ptr_type & pContext )
     {
       typename history_map_type::iterator pFoundSlot = historyMap.find(
         history_key_type::make_history_key< DefaultState >() );
       
       if ( ( pFoundSlot == historyMap.end() ) || ( pFoundSlot->second == 0 ) )
       {
         // We have never entered this state before or history was cleared
         DefaultState::deep_construct(
           pContext, *polymorphic_downcast< MostDerived * >( this ) );
       }
       else
       {
         typedef void construct_function(
           const typename DefaultState::context_ptr_type &,
           typename DefaultState::outermost_context_base_type & );
         // 5.2.10.6 declares that reinterpret_casting a function pointer to a
         // different function pointer and back must yield the same value. The
         // following reinterpret_cast is the second half of such a sequence.
         construct_function * const pConstructFunction =
           reinterpret_cast< construct_function * >( pFoundSlot->second );
         (*pConstructFunction)(
           pContext, *polymorphic_downcast< MostDerived * >( this ) );
       }
     }
 
     typedef std::list<
       event_base_ptr_type,
       typename boost::detail::allocator::rebind_to<
         allocator_type, event_base_ptr_type >::type
     > event_queue_type;
 
     typedef std::map<
       const state_base_type *, event_queue_type,
       std::less< const state_base_type * >,
       typename boost::detail::allocator::rebind_to<
         allocator_type,
         std::pair< const state_base_type * const, event_queue_type >
       >::type
     > deferred_map_type;
 
 
     event_queue_type eventQueue_;
     event_queue_type deferredEventQueue_;
     state_list_type currentStates_;
     typename state_list_type::iterator currentStatesEnd_;
     state_base_type * pOutermostState_;
     bool isInnermostCommonOuter_;
     node_state_base_ptr_type pOutermostUnstableState_;
     ExceptionTranslator translator_;
     bool performFullExit_;
     history_map_type shallowHistoryMap_;
     history_map_type deepHistoryMap_;
     const event_base_type * pTriggeringEvent_;
 };
 
 
 
 } // namespace statechart
 } // namespace boost
 
 
 
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team