#ifndef BOOST_STATECHART_STATE_MACHINE_HPP_INCLUDED

 #define BOOST_STATECHART_STATE_MACHINE_HPP_INCLUDED

 //////////////////////////////////////////////////////////////////////////////

 // Copyright 2002-2006 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/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>

 #ifdef BOOST_MSVC

 // We permanently turn off the following level 4 warnings because users will

 // have to do so themselves anyway if we turn them back on

 #  pragma warning( disable: 4511 ) // copy constructor could not be generated

 #  pragma warning( disable: 4512 ) // assignment op could not be generated

 #endif

 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:

     //////////////////////////////////////////////////////////////////////////

     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 )

     {

     }

     const typename RttiPolicy::id_type historyContextType_;

     const orthogonal_position_type historizedOrthogonalRegion_;

 };

 } // namespace detail

 //////////////////////////////////////////////////////////////////////////////

 template< class MostDerived,

           class InitialState, 

           class Allocator = std::allocator< void >,

           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 );

         detail::result_utility::get_result( translator_(

           initial_construct_function( *this ),

           exception_event_handler( *this ) ) );

         guard.dismiss();

       }

       process_queued_events();

     }

     void terminate()

     {

       terminator guard( *this );

       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 )

     {

       send_event( evt );

       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 )

     {

     }

     // This destructor was only made virtual so that that

     // polymorphic_downcast can be used to cast to MostDerived.

     virtual ~state_machine()

     {

       terminate_impl( false );

     }

   public:

     //////////////////////////////////////////////////////////////////////////

     // The following declarations should be protected.

     // They are only public because many compilers lack template friends.

     //////////////////////////////////////////////////////////////////////////

     void post_event( const event_base_ptr_type & pEvent )

     {

       BOOST_ASSERT( get_pointer( pEvent ) != 0 );

       eventQueue_.push_back( pEvent );

     }

     void post_event( const event_base & evt )

     {

       post_event( evt.intrusive_from_this() );

     }

   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;

     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 defer_event(

       const event_base_type & evt,

       const state_base_type * pForState )

     {

       deferredMap_[ pForState ].push_back( evt.intrusive_from_this() );

     }

     void release_events( const state_base_type * pForState )

     {

       const typename deferred_map_type::iterator pFound =

         deferredMap_.find( pForState );

       // We are not guaranteed to find an entry because a state is marked for

       // having deferred events _before_ the event is actually deferred. An

       // exception might be thrown during deferral.

       if ( pFound != deferredMap_.end() )

       {

         eventQueue_.splice( eventQueue_.end(), pFound->second );

         deferredMap_.erase( pFound );

       }

     }

     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 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 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 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 );

     }

     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:

         //////////////////////////////////////////////////////////////////////

         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:

         //////////////////////////////////////////////////////////////////////

         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 );

       // 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:

         //////////////////////////////////////////////////////////////////////

         state_machine & machine_;

         state_base_type * pCurrentState_;

     };

     friend class exception_event_handler;

     class terminator

     {

       public:

         terminator( state_machine & machine ) :

           machine_( machine ), dismissed_( false ) {}

         ~terminator()

         {

           if ( !dismissed_ ) { machine_.terminate_impl( false ); }

         }

         void dismiss() { dismissed_ = true; }

       private:

         state_machine & machine_;

         bool dismissed_;

     };

     friend class terminator;

     void send_event( const event_base_type & evt )

     {

       terminator guard( *this );

       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 );

       }

     }

     void process_queued_events()

     {

       while ( !eventQueue_.empty() )

       {

         const event_base_ptr_type pCurrentEvent( eventQueue_.front() );

         eventQueue_.pop_front();

         send_event( *pCurrentEvent );

       }

     }

     void terminate_impl( bool performFullExit )

     {

       performFullExit_ = true;

       if ( !terminated() )

       {

         // this also empties deferredMap_

         terminate_impl( *pOutermostState_, performFullExit );

       }

       eventQueue_.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_;

     deferred_map_type deferredMap_;

     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_;

 };

 } // namespace statechart

 } // namespace boost

 #endif