ecency/ecency-mobile
1
1
Fork 0
mirror of https://github.com/ecency/ecency-mobile.git synced 2024-12-23 05:13:04 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity
7f2db704e5
ecency-mobile/ios/Pods/boost-for-react-native/boost/statechart/state_machine.hpp

1092 lines
34 KiB
C++
Raw Blame History

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