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 *	_NewTokenState ()
static _CancellationTokenState *	_None ()
static bool	_IsValid (_In_opt_ _CancellationTokenState *_PToken)

Private Attributes
atomic_long	_M_stateFlag
std::mutex	_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;
            {
                std::lock_guard<std::mutex> _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;
                {
                    std::lock_guard<std::mutex> _Lock(_M_listLock);
                    _M_registrations.swap(_RundownList);
                }

                _RundownList.for_each([](_CancellationTokenRegistration * _PRegistration)
                {
                    _PRegistration->_Invoke();
                });

                _M_stateFlag = 2;
            }
        }

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

inline

        {
            bool _Synchronize = false;

            {
                std::lock_guard<std::mutex> _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:
                    {
                        if (_Result == ::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;
                        }

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

                        if (_Result_1 != _CancellationTokenRegistration::_STATE_CALLED)
                        {
                            std::unique_lock<std::mutex> _Lock(_PRegistration->_M_Mutex);
                            _PRegistration->_M_CondVar.wait(_Lock,
                                [_PRegistration]{ return _PRegistration->_M_signaled; });

                            _ASSERTE(_PRegistration->_M_signaled);
                        }

                        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::_NewTokenState ( )

inlinestatic

        {
            return new _CancellationTokenState();
        }

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())
            {
                std::lock_guard<std::mutex> _Lock(_M_listLock);

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

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

Member Data Documentation

std::mutex 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:

• VS2015/inc/pplcancellation_token.h