comparison DEPENDENCIES/generic/include/boost/statechart/simple_state.hpp @ 16:2665513ce2d3

Add boost headers

+#ifndef BOOST_STATECHART_SIMPLE_STATE_HPP_INCLUDED
+#define BOOST_STATECHART_SIMPLE_STATE_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/detail/leaf_state.hpp>
+#include <boost/statechart/detail/node_state.hpp>
+#include <boost/statechart/detail/constructor.hpp>
+#include <boost/statechart/detail/memory.hpp>
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/list.hpp>
+#include <boost/mpl/empty.hpp>
+#include <boost/mpl/size.hpp>
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/at.hpp>
+#include <boost/mpl/find.hpp>
+#include <boost/mpl/find_if.hpp>
+#include <boost/mpl/contains.hpp>
+#include <boost/mpl/distance.hpp>
+#include <boost/mpl/deref.hpp>
+#include <boost/mpl/pop_front.hpp>
+#include <boost/mpl/push_front.hpp>
+#include <boost/mpl/clear.hpp>
+#include <boost/mpl/placeholders.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/integral_c.hpp>
+#include <boost/mpl/less.hpp>
+#include <boost/mpl/equal_to.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/or.hpp>
+
+#include <boost/mpl/plus.hpp>
+#include <boost/mpl/max_element.hpp>
+#include <boost/mpl/greater.hpp>
+
+#include <boost/get_pointer.hpp>
+#include <boost/intrusive_ptr.hpp>
+#include <boost/assert.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/cast.hpp> // boost::polymorphic_downcast
+
+#include <cstddef> // std::size_t
+
+
+
+namespace boost
+{
+namespace statechart
+{
+namespace detail
+{
+
+
+
+//////////////////////////////////////////////////////////////////////////////
+template< class T >
+struct make_list : public mpl::eval_if<
+  mpl::is_sequence< T >,
+  mpl::identity< T >,
+  mpl::identity< mpl::list< T > > > {};
+
+//////////////////////////////////////////////////////////////////////////////
+template< class MostDerived, class Context, class InnerInitial >
+struct simple_state_base_type
+{
+  private:
+    typedef typename Context::outermost_context_base_type::allocator_type
+      allocator_type;
+    typedef typename Context::outermost_context_base_type::rtti_policy_type
+      rtti_policy_type;
+    typedef typename detail::make_list< InnerInitial >::type
+      inner_initial_list;
+    typedef typename mpl::size< inner_initial_list >::type
+      inner_initial_list_size;
+
+  public:
+    typedef typename mpl::eval_if<
+      mpl::empty< inner_initial_list >,
+      mpl::identity< typename rtti_policy_type::
+        template rtti_derived_type< MostDerived, leaf_state<
+          allocator_type,
+          rtti_policy_type > > >,
+      mpl::identity< typename rtti_policy_type::
+        template rtti_derived_type< MostDerived, node_state<
+          inner_initial_list_size,
+          allocator_type,
+          rtti_policy_type > > > >::type type;
+};
+
+
+//////////////////////////////////////////////////////////////////////////////
+struct no_transition_function
+{
+  template< class CommonContext >
+  void operator()( CommonContext & ) const {}
+};
+
+template< class TransitionContext, class Event >
+class transition_function
+{
+  public:
+    transition_function(
+      void ( TransitionContext::*pTransitionAction )( const Event & ),
+      const Event & evt
+    ) :
+      pTransitionAction_( pTransitionAction ),
+      evt_( evt )
+    {
+    }
+
+    template< class CommonContext >
+    void operator()( CommonContext & commonContext ) const
+    {
+      ( commonContext.template context< TransitionContext >()
+        .*pTransitionAction_ )( evt_ );
+    }
+
+  private:
+    // avoids C4512 (assignment operator could not be generated)
+    transition_function & operator=( const transition_function & );
+
+    void ( TransitionContext::*pTransitionAction_ )( const Event & );
+    const Event & evt_;
+};
+
+
+template< bool contextHasInheritedDeepHistory, bool contextHasDeepHistory >
+struct deep_history_storer
+{
+  template< class HistorizedState, class LeafState, class Context >
+  static void store_deep_history( Context & ) {}
+};
+
+template<>
+struct deep_history_storer< true, false >
+{
+  template< class HistorizedState, class LeafState, class Context >
+  static void store_deep_history( Context & ctx )
+  {
+    ctx.template store_deep_history_impl< LeafState >();
+  }
+};
+
+template<>
+struct deep_history_storer< true, true >
+{
+  template< class HistorizedState, class LeafState, class Context >
+  static void store_deep_history( Context & ctx )
+  {
+    ctx.outermost_context_base().template store_deep_history<
+      HistorizedState, LeafState >();
+    ctx.template store_deep_history_impl< LeafState >();
+  }
+};
+
+
+
+} // namespace detail
+
+
+
+//////////////////////////////////////////////////////////////////////////////
+enum history_mode
+{
+  has_no_history,
+  has_shallow_history,
+  has_deep_history,
+  has_full_history // shallow & deep
+};
+
+
+
+//////////////////////////////////////////////////////////////////////////////
+template< class MostDerived,
+          class Context,
+          class InnerInitial = mpl::list<>,
+          history_mode historyMode = has_no_history >
+class simple_state : public detail::simple_state_base_type< MostDerived,
+  typename Context::inner_context_type, InnerInitial >::type
+{
+  typedef typename detail::simple_state_base_type<
+    MostDerived, typename Context::inner_context_type,
+    InnerInitial >::type base_type;
+
+  public:
+    //////////////////////////////////////////////////////////////////////////
+    typedef mpl::list<> reactions;
+
+    typedef typename Context::inner_context_type context_type;
+
+    template< detail::orthogonal_position_type innerOrthogonalPosition >
+    struct orthogonal
+    {
+      typedef mpl::integral_c<
+        detail::orthogonal_position_type,
+        innerOrthogonalPosition > inner_orthogonal_position;
+      typedef MostDerived inner_context_type;
+    };
+
+    typedef typename context_type::outermost_context_type
+      outermost_context_type;
+
+    outermost_context_type & outermost_context()
+    {
+      // This assert fails when an attempt is made to access the state machine
+      // from a constructor of a state that is *not* a subtype of state<>.
+      // To correct this, derive from state<> instead of simple_state<>.
+      BOOST_ASSERT( get_pointer( pContext_ ) != 0 );
+      return pContext_->outermost_context();
+    }
+
+    const outermost_context_type & outermost_context() const
+    {
+      // This assert fails when an attempt is made to access the state machine
+      // from a constructor of a state that is *not* a subtype of state<>.
+      // To correct this, derive from state<> instead of simple_state<>.
+      BOOST_ASSERT( get_pointer( pContext_ ) != 0 );
+      return pContext_->outermost_context();
+    }
+
+    template< class OtherContext >
+    OtherContext & context()
+    {
+      typedef typename mpl::if_<
+        is_base_of< OtherContext, MostDerived >,
+        context_impl_this_context,
+        context_impl_other_context
+      >::type impl;
+      return impl::template context_impl< OtherContext >( *this );
+    }
+
+    template< class OtherContext >
+    const OtherContext & context() const
+    {
+      typedef typename mpl::if_<
+        is_base_of< OtherContext, MostDerived >,
+        context_impl_this_context,
+        context_impl_other_context
+      >::type impl;
+      return impl::template context_impl< OtherContext >( *this );
+    }
+
+    template< class Target >
+    Target state_cast() const
+    {
+      return outermost_context_base().template state_cast< Target >();
+    }
+
+    template< class Target >
+    Target state_downcast() const
+    {
+      return outermost_context_base().template state_downcast< Target >();
+    }
+
+    typedef typename context_type::state_base_type state_base_type;
+    typedef typename context_type::state_iterator state_iterator;
+
+    state_iterator state_begin() const
+    {
+      return outermost_context_base().state_begin();
+    }
+
+    state_iterator state_end() const
+    {
+      return outermost_context_base().state_end();
+    }
+
+
+    typedef typename context_type::event_base_ptr_type event_base_ptr_type;
+
+    void post_event( const event_base_ptr_type & pEvent )
+    {
+      outermost_context_base().post_event_impl( pEvent );
+    }
+
+    void post_event( const event_base & evt )
+    {
+      outermost_context_base().post_event_impl( evt );
+    }
+
+    result discard_event()
+    {
+      return detail::result_utility::make_result( detail::do_discard_event );
+    }
+
+    result forward_event()
+    {
+      return detail::result_utility::make_result( detail::do_forward_event );
+    }
+
+    result defer_event()
+    {
+      this->state_base_type::defer_event();
+      return detail::result_utility::make_result( detail::do_defer_event );
+    }
+
+    template< class DestinationState >
+    result transit()
+    {
+      return transit_impl< DestinationState, outermost_context_type >(
+        detail::no_transition_function() );
+    }
+
+    template< class DestinationState, class TransitionContext, class Event >
+    result transit(
+      void ( TransitionContext::*pTransitionAction )( const Event & ),
+      const Event & evt )
+    {
+      return transit_impl< DestinationState, TransitionContext >(
+        detail::transition_function< TransitionContext, Event >(
+          pTransitionAction, evt ) );
+    }
+
+    result terminate()
+    {
+      outermost_context_base().terminate_as_reaction( *this );
+      return detail::result_utility::make_result( detail::do_discard_event );
+    }
+
+    template<
+      class HistoryContext,
+      detail::orthogonal_position_type orthogonalPosition >
+    void clear_shallow_history()
+    {
+      outermost_context_base().template clear_shallow_history<
+        HistoryContext, orthogonalPosition >();
+    }
+
+    template<
+      class HistoryContext,
+      detail::orthogonal_position_type orthogonalPosition >
+    void clear_deep_history()
+    {
+      outermost_context_base().template clear_deep_history<
+        HistoryContext, orthogonalPosition >();
+    }
+
+    const event_base * triggering_event() const
+    {
+      return outermost_context_base().triggering_event();
+    }
+
+  protected:
+    //////////////////////////////////////////////////////////////////////////
+    simple_state() : pContext_( 0 ) {}
+
+    ~simple_state()
+    {
+      // As a result of a throwing derived class constructor, this destructor
+      // can be called before the context is set.
+      if ( get_pointer( pContext_ ) != 0 )
+      {
+        if ( this->deferred_events() )
+        {
+          outermost_context_base().release_events();
+        }
+
+        pContext_->remove_inner_state( orthogonal_position::value );
+      }
+    }
+
+  public:
+    //////////////////////////////////////////////////////////////////////////
+    // The following declarations should be private.
+    // They are only public because many compilers lack template friends.
+    //////////////////////////////////////////////////////////////////////////
+    typedef typename Context::inner_orthogonal_position orthogonal_position;
+
+    // If you receive a
+    // "use of undefined type 'boost::STATIC_ASSERTION_FAILURE<x>'" or similar
+    // compiler error here then either this state resides in a non-existent
+    // orthogonal region of the outer state or the outer state does not have
+    // inner states.
+    BOOST_STATIC_ASSERT( ( mpl::less<
+      orthogonal_position,
+      typename context_type::no_of_orthogonal_regions >::value ) );
+
+    typedef MostDerived inner_context_type;
+    typedef mpl::integral_c< detail::orthogonal_position_type, 0 >
+      inner_orthogonal_position;
+
+    typedef typename context_type::event_base_type event_base_type;
+    typedef typename context_type::rtti_policy_type rtti_policy_type;
+
+    typedef typename context_type::outermost_context_base_type
+      outermost_context_base_type;
+    typedef typename context_type::inner_context_ptr_type context_ptr_type;
+    typedef typename context_type::state_list_type state_list_type;
+    typedef intrusive_ptr< inner_context_type > inner_context_ptr_type;
+    typedef typename detail::make_list< InnerInitial >::type
+      inner_initial_list;
+    typedef typename mpl::size< inner_initial_list >::type
+      inner_initial_list_size;
+    typedef mpl::integral_c<
+      detail::orthogonal_position_type,
+      inner_initial_list_size::value > no_of_orthogonal_regions;
+    typedef typename mpl::push_front<
+      typename context_type::context_type_list,
+      context_type >::type context_type_list;
+
+    // If you receive a
+    // "use of undefined type 'boost::STATIC_ASSERTION_FAILURE<x>'" or similar
+    // compiler error here then the direct or indirect context of this state
+    // has deep history _and_ this state has two or more orthogonal regions.
+    // Boost.Statechart does not currently support deep history in a state whose
+    // direct or indirect inner states have two or more orthogonal regions.
+    // Please consult the documentation on how to work around this limitation.
+    BOOST_STATIC_ASSERT( ( mpl::or_<
+      mpl::less<
+        no_of_orthogonal_regions,
+        mpl::integral_c< detail::orthogonal_position_type, 2 > >,
+      mpl::not_<
+        typename context_type::inherited_deep_history > >::value ) );
+
+    typedef mpl::bool_< ( historyMode & has_shallow_history ) != 0 >
+      shallow_history;
+    typedef typename context_type::shallow_history stores_shallow_history;
+
+    typedef mpl::bool_< ( historyMode & has_deep_history ) != 0 >
+      deep_history;
+    typedef typename mpl::or_<
+      deep_history, 
+      typename context_type::inherited_deep_history
+    >::type inherited_deep_history;
+    typedef typename mpl::and_<
+      inherited_deep_history,
+      mpl::empty< inner_initial_list > >::type stores_deep_history;
+
+    void * operator new( std::size_t size )
+    {
+      return detail::allocate< MostDerived,
+        typename outermost_context_type::allocator_type >( size );
+    }
+
+    void operator delete( void * pState )
+    {
+      detail::deallocate< MostDerived,
+        typename outermost_context_type::allocator_type >( pState );
+    }
+
+    outermost_context_base_type & outermost_context_base()
+    {
+      // This assert fails when an attempt is made to access the state machine
+      // from a constructor of a state that is *not* a subtype of state<>.
+      // To correct this, derive from state<> instead of simple_state<>.
+      BOOST_ASSERT( get_pointer( pContext_ ) != 0 );
+      return pContext_->outermost_context_base();
+    }
+
+    const outermost_context_base_type & outermost_context_base() const
+    {
+      // This assert fails when an attempt is made to access the state machine
+      // from a constructor of a state that is *not* a subtype of state<>.
+      // To correct this, derive from state<> instead of simple_state<>.
+      BOOST_ASSERT( get_pointer( pContext_ ) != 0 );
+      return pContext_->outermost_context_base();
+    }
+
+    virtual const state_base_type * outer_state_ptr() const
+    {
+      typedef typename mpl::if_<
+        is_same< outermost_context_type, context_type >,
+        outer_state_ptr_impl_outermost,
+        outer_state_ptr_impl_non_outermost
+      >::type impl;
+      return impl::outer_state_ptr_impl( *this );
+    }
+
+    virtual detail::reaction_result react_impl(
+      const event_base_type & evt,
+      typename rtti_policy_type::id_type eventType )
+    {
+      typedef typename detail::make_list<
+        typename MostDerived::reactions >::type reaction_list;
+      detail::reaction_result reactionResult =
+        local_react< reaction_list >( evt, eventType );
+
+      // At this point we can only safely access pContext_ if the handler did
+      // not return do_discard_event!
+      if ( reactionResult == detail::do_forward_event )
+      {
+        // TODO: The following call to react_impl of our outer state should
+        // be made with a context_type:: prefix to call directly instead of
+        // virtually. For some reason the compiler complains...
+        reactionResult = pContext_->react_impl( evt, eventType );
+      }
+
+      return reactionResult;
+    }
+
+    virtual void exit_impl(
+      typename base_type::direct_state_base_ptr_type & pSelf,
+      typename state_base_type::node_state_base_ptr_type &
+        pOutermostUnstableState,
+      bool performFullExit )
+    {
+      inner_context_ptr_type pMostDerivedSelf =
+        polymorphic_downcast< MostDerived * >( this );
+      pSelf = 0;
+      exit_impl( pMostDerivedSelf, pOutermostUnstableState, performFullExit );
+    }
+
+    void exit_impl(
+      inner_context_ptr_type & pSelf,
+      typename state_base_type::node_state_base_ptr_type &
+        pOutermostUnstableState,
+      bool performFullExit )
+    {
+      switch ( this->ref_count() )
+      {
+        case 2:
+          if ( get_pointer( pOutermostUnstableState ) ==
+            static_cast< state_base_type * >( this ) )
+          {
+            pContext_->set_outermost_unstable_state(
+              pOutermostUnstableState );
+            // fall through to next case intended
+          }
+          else
+          {
+            break;
+          }
+        case 1:
+        {
+          if ( get_pointer( pOutermostUnstableState ) == 0 )
+          {
+            pContext_->set_outermost_unstable_state(
+              pOutermostUnstableState );
+          }
+
+          if ( performFullExit )
+          {
+            pSelf->exit();
+            check_store_shallow_history< stores_shallow_history >();
+            check_store_deep_history< stores_deep_history >();
+          }
+
+          context_ptr_type pContext = pContext_;
+          pSelf = 0;
+          pContext->exit_impl(
+            pContext, pOutermostUnstableState, performFullExit );
+          break;
+        }
+        default:
+          break;
+      }
+    }
+
+    void set_outermost_unstable_state(
+      typename state_base_type::node_state_base_ptr_type &
+        pOutermostUnstableState )
+    {
+      pOutermostUnstableState = this;
+    }
+
+    template< class OtherContext >
+    const typename OtherContext::inner_context_ptr_type & context_ptr() const
+    {
+      typedef typename mpl::if_<
+        is_same< OtherContext, context_type >,
+        context_ptr_impl_my_context,
+        context_ptr_impl_other_context
+      >::type impl;
+
+      return impl::template context_ptr_impl< OtherContext >( *this );
+    }
+
+    static void initial_deep_construct(
+      outermost_context_base_type & outermostContextBase )
+    {
+      deep_construct( &outermostContextBase, outermostContextBase );
+    }
+
+    static void deep_construct(
+      const context_ptr_type & pContext,
+      outermost_context_base_type & outermostContextBase )
+    {
+      const inner_context_ptr_type pInnerContext(
+        shallow_construct( pContext, outermostContextBase ) );
+      deep_construct_inner< inner_initial_list >(
+        pInnerContext, outermostContextBase );
+    }
+
+    static inner_context_ptr_type shallow_construct(
+      const context_ptr_type & pContext,
+      outermost_context_base_type & outermostContextBase )
+    {
+      const inner_context_ptr_type pInnerContext( new MostDerived );
+      pInnerContext->set_context( pContext );
+      outermostContextBase.add( pInnerContext );
+      return pInnerContext;
+    }
+
+    void set_context( const context_ptr_type & pContext )
+    {
+      BOOST_ASSERT( get_pointer( pContext ) != 0 );
+      pContext_ = pContext;
+      base_type::set_context(
+        orthogonal_position::value, get_pointer( pContext ) );
+    }
+
+    template< class InnerList >
+    static void deep_construct_inner(
+      const inner_context_ptr_type & pInnerContext,
+      outermost_context_base_type & outermostContextBase )
+    {
+      typedef typename mpl::if_<
+        mpl::empty< InnerList >,
+        deep_construct_inner_impl_empty,
+        deep_construct_inner_impl_non_empty
+      >::type impl;
+      impl::template deep_construct_inner_impl< InnerList >(
+        pInnerContext, outermostContextBase );
+    }
+
+    template< class LeafState >
+    void store_deep_history_impl()
+    {
+      detail::deep_history_storer<
+        context_type::inherited_deep_history::value,
+        context_type::deep_history::value
+      >::template store_deep_history< MostDerived, LeafState >(
+        *pContext_ );
+    }
+
+  private:
+    //////////////////////////////////////////////////////////////////////////
+    struct context_ptr_impl_other_context
+    {
+      template< class OtherContext, class State >
+      static const typename OtherContext::inner_context_ptr_type &
+      context_ptr_impl( const State & stt )
+      {
+        // This assert fails when an attempt is made to access an outer 
+        // context from a constructor of a state that is *not* a subtype of
+        // state<>. To correct this, derive from state<> instead of
+        // simple_state<>.
+        BOOST_ASSERT( get_pointer( stt.pContext_ ) != 0 );
+        return stt.pContext_->template context_ptr< OtherContext >();
+      }
+    };
+    friend struct context_ptr_impl_other_context;
+
+    struct context_ptr_impl_my_context
+    {
+      template< class OtherContext, class State >
+      static const typename OtherContext::inner_context_ptr_type &
+      context_ptr_impl( const State & stt )
+      {
+        // This assert fails when an attempt is made to access an outer 
+        // context from a constructor of a state that is *not* a subtype of
+        // state<>. To correct this, derive from state<> instead of
+        // simple_state<>.
+        BOOST_ASSERT( get_pointer( stt.pContext_ ) != 0 );
+        return stt.pContext_;
+      }
+    };
+    friend struct context_ptr_impl_my_context;
+
+    struct context_impl_other_context
+    {
+      template< class OtherContext, class State >
+      static OtherContext & context_impl( State & stt )
+      {
+        // This assert fails when an attempt is made to access an outer 
+        // context from a constructor of a state that is *not* a subtype of
+        // state<>. To correct this, derive from state<> instead of
+        // simple_state<>.
+        BOOST_ASSERT( get_pointer( stt.pContext_ ) != 0 );
+        return stt.pContext_->template context< OtherContext >();
+      }
+    };
+    friend struct context_impl_other_context;
+
+    struct context_impl_this_context
+    {
+      template< class OtherContext, class State >
+      static OtherContext & context_impl( State & stt )
+      {
+        return *polymorphic_downcast< MostDerived * >( &stt );
+      }
+    };
+    friend struct context_impl_this_context;
+
+    template< class DestinationState,
+              class TransitionContext,
+              class TransitionAction >
+    result transit_impl( const TransitionAction & transitionAction )
+    {
+      typedef typename mpl::find_if<
+        context_type_list,
+        mpl::contains<
+          typename DestinationState::context_type_list,
+          mpl::placeholders::_ > >::type common_context_iter;
+      typedef typename mpl::deref< common_context_iter >::type
+        common_context_type;
+      typedef typename mpl::distance<
+        typename mpl::begin< context_type_list >::type,
+        common_context_iter >::type termination_state_position;
+      typedef typename mpl::push_front< context_type_list, MostDerived >::type
+        possible_transition_contexts;
+      typedef typename mpl::at<
+        possible_transition_contexts,
+        termination_state_position >::type termination_state_type;
+
+      termination_state_type & terminationState(
+        context< termination_state_type >() );
+      const typename
+        common_context_type::inner_context_ptr_type pCommonContext(
+          terminationState.template context_ptr< common_context_type >() );
+      outermost_context_base_type & outermostContextBase(
+        pCommonContext->outermost_context_base() );
+
+      #ifdef BOOST_STATECHART_RELAX_TRANSITION_CONTEXT
+      typedef typename mpl::distance<
+        typename mpl::begin< possible_transition_contexts >::type,
+        typename mpl::find<
+          possible_transition_contexts, TransitionContext >::type
+      >::type proposed_transition_context_position;
+
+      typedef typename mpl::plus<
+        termination_state_position,
+        mpl::long_< 1 >
+      >::type uml_transition_context_position;
+
+      typedef typename mpl::deref< typename mpl::max_element<
+        mpl::list<
+          proposed_transition_context_position,
+          uml_transition_context_position >,
+        mpl::greater< mpl::placeholders::_, mpl::placeholders::_ >
+      >::type >::type real_transition_context_position;
+
+      typedef typename mpl::at<
+        possible_transition_contexts,
+        real_transition_context_position >::type real_transition_context_type;
+
+      #ifdef BOOST_MSVC
+      #  pragma warning( push )
+      #  pragma warning( disable: 4127 ) // conditional expression is constant
+      #endif
+      if ( ( proposed_transition_context_position::value == 0 ) &&
+           ( inner_initial_list_size::value == 0 ) )
+      {
+        transitionAction( *polymorphic_downcast< MostDerived * >( this ) );
+        outermostContextBase.terminate_as_part_of_transit( terminationState );
+      }
+      else if ( proposed_transition_context_position::value >=
+                uml_transition_context_position::value )
+      {
+        real_transition_context_type & transitionContext =
+          context< real_transition_context_type >();
+        outermostContextBase.terminate_as_part_of_transit( terminationState );
+        transitionAction( transitionContext );
+      }
+      else
+      {
+        typename real_transition_context_type::inner_context_ptr_type
+          pTransitionContext = context_ptr< real_transition_context_type >();
+        outermostContextBase.terminate_as_part_of_transit(
+          *pTransitionContext );
+        transitionAction( *pTransitionContext );
+        pTransitionContext = 0;
+        outermostContextBase.terminate_as_part_of_transit( terminationState );
+      }
+      #ifdef BOOST_MSVC
+      #  pragma warning( pop )
+      #endif
+      #else
+      outermostContextBase.terminate_as_part_of_transit( terminationState );
+      transitionAction( *pCommonContext );
+      #endif
+
+      typedef typename detail::make_context_list<
+        common_context_type, DestinationState >::type context_list_type;
+
+      // If you receive a
+      // "use of undefined type 'boost::STATIC_ASSERTION_FAILURE<x>'" or
+      // similar compiler error here then you tried to make an invalid
+      // transition between different orthogonal regions.
+      BOOST_STATIC_ASSERT( ( mpl::equal_to<
+        typename termination_state_type::orthogonal_position,
+        typename mpl::front< context_list_type >::type::orthogonal_position
+      >::value ) );
+
+      detail::constructor<
+        context_list_type, outermost_context_base_type >::construct(
+          pCommonContext, outermostContextBase );
+
+      return detail::result_utility::make_result( detail::do_discard_event );
+    }
+
+    struct local_react_impl_non_empty
+    {
+      template< class ReactionList, class State >
+      static detail::reaction_result local_react_impl(
+        State & stt,
+        const event_base_type & evt,
+        typename rtti_policy_type::id_type eventType )
+      {
+        detail::reaction_result reactionResult =
+          mpl::front< ReactionList >::type::react(
+            *polymorphic_downcast< MostDerived * >( &stt ),
+            evt, eventType );
+
+        if ( reactionResult == detail::no_reaction )
+        {
+          reactionResult = stt.template local_react<
+            typename mpl::pop_front< ReactionList >::type >(
+              evt, eventType );
+        }
+
+        return reactionResult;
+      }
+    };
+    friend struct local_react_impl_non_empty;
+
+    struct local_react_impl_empty
+    {
+      template< class ReactionList, class State >
+      static detail::reaction_result local_react_impl(
+        State &, const event_base_type &, typename rtti_policy_type::id_type )
+      {
+        return detail::do_forward_event;
+      }
+    };
+
+    template< class ReactionList >
+    detail::reaction_result local_react(
+      const event_base_type & evt,
+      typename rtti_policy_type::id_type eventType )
+    {
+      typedef typename mpl::if_<
+        mpl::empty< ReactionList >,
+        local_react_impl_empty,
+        local_react_impl_non_empty
+      >::type impl;
+      return impl::template local_react_impl< ReactionList >(
+        *this, evt, eventType );
+    }
+
+    struct outer_state_ptr_impl_non_outermost
+    {
+      template< class State >
+      static const state_base_type * outer_state_ptr_impl( const State & stt )
+      {
+        return get_pointer( stt.pContext_ );
+      }
+    };
+    friend struct outer_state_ptr_impl_non_outermost;
+
+    struct outer_state_ptr_impl_outermost
+    {
+      template< class State >
+      static const state_base_type * outer_state_ptr_impl( const State & )
+      {
+        return 0;
+      }
+    };
+
+    struct deep_construct_inner_impl_non_empty
+    {
+      template< class InnerList >
+      static void deep_construct_inner_impl(
+        const inner_context_ptr_type & pInnerContext,
+        outermost_context_base_type & outermostContextBase )
+      {
+        typedef typename mpl::front< InnerList >::type current_inner;
+
+        // If you receive a
+        // "use of undefined type 'boost::STATIC_ASSERTION_FAILURE<x>'" or
+        // similar compiler error here then there is a mismatch between the
+        // orthogonal position of a state and its position in the inner
+        // initial list of its outer state.
+        BOOST_STATIC_ASSERT( ( is_same<
+          current_inner,
+          typename mpl::at<
+            typename current_inner::context_type::inner_initial_list,
+            typename current_inner::orthogonal_position >::type >::value ) );
+
+        current_inner::deep_construct( pInnerContext, outermostContextBase );
+        deep_construct_inner< typename mpl::pop_front< InnerList >::type >(
+          pInnerContext, outermostContextBase );
+      }
+    };
+
+    struct deep_construct_inner_impl_empty
+    {
+      template< class InnerList >
+      static void deep_construct_inner_impl(
+        const inner_context_ptr_type &, outermost_context_base_type & ) {}
+    };
+
+    struct check_store_shallow_history_impl_no
+    {
+      template< class State >
+      static void check_store_shallow_history_impl( State & ) {}
+    };
+
+    struct check_store_shallow_history_impl_yes
+    {
+      template< class State >
+      static void check_store_shallow_history_impl( State & stt )
+      {
+        stt.outermost_context_base().template store_shallow_history<
+          MostDerived >();
+      }
+    };
+    friend struct check_store_shallow_history_impl_yes;
+
+    template< class StoreShallowHistory >
+    void check_store_shallow_history()
+    {
+      typedef typename mpl::if_<
+        StoreShallowHistory,
+        check_store_shallow_history_impl_yes,
+        check_store_shallow_history_impl_no
+      >::type impl;
+      impl::check_store_shallow_history_impl( *this );
+    }
+
+    struct check_store_deep_history_impl_no
+    {
+      template< class State >
+      static void check_store_deep_history_impl( State & ) {}
+    };
+
+    struct check_store_deep_history_impl_yes
+    {
+      template< class State >
+      static void check_store_deep_history_impl( State & stt )
+      {
+        stt.template store_deep_history_impl< MostDerived >();
+      }
+    };
+    friend struct check_store_deep_history_impl_yes;
+
+    template< class StoreDeepHistory >
+    void check_store_deep_history()
+    {
+      typedef typename mpl::if_<
+        StoreDeepHistory,
+        check_store_deep_history_impl_yes,
+        check_store_deep_history_impl_no
+      >::type impl;
+      impl::check_store_deep_history_impl( *this );
+    }
+
+
+    context_ptr_type pContext_;
+};
+
+
+
+#ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
+} // namespace statechart
+#endif
+
+
+
+template< class MostDerived, class Context,
+          class InnerInitial, history_mode historyMode >
+inline void intrusive_ptr_release( const ::boost::statechart::simple_state<
+  MostDerived, Context, InnerInitial, historyMode > * pBase )
+{
+  if ( pBase->release() )
+  {
+    // The cast is necessary because the simple_state destructor is non-
+    // virtual (and inaccessible from this context)
+    delete polymorphic_downcast< const MostDerived * >( pBase );
+  }
+}
+
+
+
+#ifndef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
+} // namespace statechart
+#endif
+
+
+
+} // namespace boost
+
+
+
+#endif