#ifndef BOOST_STATECHART_SIMPLE_STATE_HPP_INCLUDED

#define BOOST_STATECHART_SIMPLE_STATE_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/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_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:

    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_same< 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_same< 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( pEvent );

    }

    void post_event( const event_base & evt )

    {

      outermost_context_base().post_event( 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 >();

    }

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

        }

        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!

      switch ( reactionResult )

      {

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

          break;

        case detail::do_defer_event:

          outermost_context_base().defer_event( evt, this );

          break;

        default:

          break;

      }

      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.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.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