Concurrency::details::_CancellationTokenState Class Reference

#include <pplcancellation_token.h>

Inheritance diagram for Concurrency::details::_CancellationTokenState:

Classes
class	TokenRegistrationContainer

Public Member Functions
	_CancellationTokenState ()
	~_CancellationTokenState ()
bool	_IsCanceled () const
void	_Cancel ()
_CancellationTokenRegistration *	_RegisterCallback (TaskProc_t _PCallback, _In_ void *_PData, int _InitialRefs=1)
void	_RegisterCallback (_In_ _CancellationTokenRegistration *_PRegistration)
void	_DeregisterCallback (_In_ _CancellationTokenRegistration *_PRegistration)
Public Member Functions inherited from Concurrency::details::_RefCounter
virtual	~_RefCounter ()
long	_Reference ()
long	_Release ()

Static Public Member Functions
static _CancellationTokenState *	_CancellationTokenState::_NewTokenState ()
static _CancellationTokenState *	_None ()
static bool	_IsValid (_In_opt_ _CancellationTokenState *_PToken)

Private Attributes
atomic_long	_M_stateFlag
extensibility::event_t	_M_cancelComplete
extensibility::critical_section_t	_M_listLock
TokenRegistrationContainer	_M_registrations

Additional Inherited Members
Protected Member Functions inherited from Concurrency::details::_RefCounter
virtual void	_Destroy ()
	_RefCounter (long _InitialCount=1)
Protected Attributes inherited from Concurrency::details::_RefCounter
volatile long	_M_refCount

Constructor & Destructor Documentation

Concurrency::details::_CancellationTokenState::_CancellationTokenState ( )

inline

                                  :
            _M_stateFlag(0)
        {
        }

Concurrency::details::_CancellationTokenState::~_CancellationTokenState ( )

inline

        {
            TokenRegistrationContainer rundownList;
            {
                extensibility::scoped_critical_section_t _Lock(_M_listLock);
                _M_registrations.swap(rundownList);
            }

            rundownList.for_each([](_CancellationTokenRegistration * pRegistration)
            {
                pRegistration->_M_state = _CancellationTokenRegistration::_STATE_SYNCHRONIZE;
                pRegistration->_Release();
            });
        }

Member Function Documentation

void Concurrency::details::_CancellationTokenState::_Cancel ( )

inline

        {
            if (atomic_compare_exchange(_M_stateFlag, 1l, 0l) == 0)
            {
                TokenRegistrationContainer rundownList;
                {
                    extensibility::scoped_critical_section_t _Lock(_M_listLock);
                    _M_registrations.swap(rundownList);
                }

                rundownList.for_each([](_CancellationTokenRegistration * pRegistration)
                {
                    pRegistration->_Invoke();
                });

                _M_stateFlag = 2;
                _M_cancelComplete.set();
            }
        }

static _CancellationTokenState* Concurrency::details::_CancellationTokenState::_CancellationTokenState::_NewTokenState ( )

inlinestatic

        {
            return new _CancellationTokenState();
        }

void Concurrency::details::_CancellationTokenState::_DeregisterCallback ( _In_ _CancellationTokenRegistration *  _PRegistration )

inline

        {
            bool synchronize = false;

            {
                extensibility::scoped_critical_section_t _Lock(_M_listLock);

                //
                // If a cancellation has occurred, the registration list is guaranteed to be empty if we've observed it under the auspices of the
                // lock.  In this case, we must synchronize with the cancelling thread to guarantee that the cancellation is finished by the time
                // we return from this method.
                //
                if (!_M_registrations.empty())
                {
                    _M_registrations.remove(_PRegistration);
                    _PRegistration->_M_state = _CancellationTokenRegistration::_STATE_SYNCHRONIZE;
                    _PRegistration->_Release();
                }
                else
                {
                    synchronize = true;
                }
            }

            // 
            // If the list is empty, we are in one of several situations:
            //
            // - The callback has already been made         --> do nothing
            // - The callback is about to be made           --> flag it so it doesn't happen and return
            // - The callback is in progress elsewhere      --> synchronize with it
            // - The callback is in progress on this thread --> do nothing
            //
            if (synchronize)
            {
                long result = atomic_compare_exchange(
                    _PRegistration->_M_state, 
                    _CancellationTokenRegistration::_STATE_DEFER_DELETE, 
                    _CancellationTokenRegistration::_STATE_CLEAR
                    );

                switch(result)
                {
                    case _CancellationTokenRegistration::_STATE_CLEAR:
                    case _CancellationTokenRegistration::_STATE_CALLED:
                        break;
                    case _CancellationTokenRegistration::_STATE_DEFER_DELETE:
                    case _CancellationTokenRegistration::_STATE_SYNCHRONIZE:
                        _ASSERTE(false);
                        break;
                    default:
                    {
                        long tid = result;
                        if (tid == ::Concurrency::details::platform::GetCurrentThreadId())
                        {
                            //
                            // It is entirely legal for a caller to Deregister during a callback instead of having to provide their own synchronization
                            // mechanism between the two.  In this case, we do *NOT* need to explicitly synchronize with the callback as doing so would
                            // deadlock.  If the call happens during, skip any extra synchronization.
                            //
                            break;
                        }

                        extensibility::event_t ev;
                        _PRegistration->_M_pSyncBlock = &ev;

                        long result_1 = atomic_exchange(_PRegistration->_M_state, _CancellationTokenRegistration::_STATE_SYNCHRONIZE);

                        if (result_1 != _CancellationTokenRegistration::_STATE_CALLED)
                        {
                            _PRegistration->_M_pSyncBlock->wait(::Concurrency::extensibility::event_t::timeout_infinite);
                        }

                        break;
                    }
                }
            }
        }

bool Concurrency::details::_CancellationTokenState::_IsCanceled ( ) const

inline

        {
            return (_M_stateFlag != 0);
        }

static bool Concurrency::details::_CancellationTokenState::_IsValid ( _In_opt_ _CancellationTokenState *  _PToken )

inlinestatic

        {
            return (_PToken != NULL && _PToken != _None());
        }

static _CancellationTokenState* Concurrency::details::_CancellationTokenState::_None ( )

inlinestatic

        {
            return reinterpret_cast<_CancellationTokenState *>(2);
        }

_CancellationTokenRegistration* Concurrency::details::_CancellationTokenState::_RegisterCallback ( TaskProc_t  _PCallback, _In_ void *  _PData, int  _InitialRefs = 1  )

inline

        {
            _CancellationTokenRegistration *pRegistration = new CancellationTokenRegistration_TaskProc(_PCallback, _PData, _InitialRefs);
            _RegisterCallback(pRegistration);
            return pRegistration;
        }

void Concurrency::details::_CancellationTokenState::_RegisterCallback ( _In_ _CancellationTokenRegistration *  _PRegistration )

inline

        {
            _PRegistration->_M_state = _CancellationTokenRegistration::_STATE_CLEAR;
            _PRegistration->_Reference();
            _PRegistration->_M_pTokenState = this;

            bool invoke = true;

            if (!_IsCanceled())
            {
                extensibility::scoped_critical_section_t _Lock(_M_listLock);

                if (!_IsCanceled())
                {
                    invoke = false;
                    _M_registrations.push_back(_PRegistration);
                }
            }

            if (invoke)
            {
                _PRegistration->_Invoke();
            }
        }

Member Data Documentation

extensibility::event_t Concurrency::details::_CancellationTokenState::_M_cancelComplete

private

extensibility::critical_section_t Concurrency::details::_CancellationTokenState::_M_listLock

private

TokenRegistrationContainer Concurrency::details::_CancellationTokenState::_M_registrations

private

atomic_long Concurrency::details::_CancellationTokenState::_M_stateFlag

private

---

The documentation for this class was generated from the following file:

• VS2013/inc/pplcancellation_token.h