Concurrency::cancellation_token Class Reference

The cancellation_token class represents the ability to determine whether some operation has been requested to cancel. A given token can be associated with a task_group, structured_task_group, or task to provide implicit cancellation. It can also be polled for cancellation or have a callback registered for if and when the associated cancellation_token_source is canceled. More...

#include <pplcancellation_token.h>

Public Types
typedef details::_CancellationTokenState *	_ImplType

Public Member Functions
	cancellation_token (const cancellation_token &_Src)
	cancellation_token (cancellation_token &&_Src)
cancellation_token &	operator= (const cancellation_token &_Src)
cancellation_token &	operator= (cancellation_token &&_Src)
bool	operator== (const cancellation_token &_Src) const
bool	operator!= (const cancellation_token &_Src) const
	~cancellation_token ()
bool	is_cancelable () const
	Returns an indication of whether this token can be canceled or not. More...
bool	is_canceled () const
	Returns true if the token has been canceled. More...
template<typename _Function >
::Concurrency::cancellation_token_registration	register_callback (const _Function &_Func) const
	Registers a callback function with the token. If and when the token is canceled, the callback will be made. Note that if the token is already canceled at the point where this method is called, the callback will be made immediately and synchronously. More...
void	deregister_callback (const cancellation_token_registration &_Registration) const
	Removes a callback previously registered via the register method based on the cancellation_token_registration object returned at the time of registration. More...
_ImplType	_GetImpl () const
_ImplType	_GetImplValue () const

Static Public Member Functions
static cancellation_token	none ()
	Returns a cancellation token which can never be subject to cancellation. More...
static cancellation_token	_FromImpl (_ImplType _Impl)

Private Member Functions
void	_Clear ()
void	_Assign (_ImplType _Impl)
void	_Move (_ImplType &_Impl)
	cancellation_token ()
	cancellation_token (_ImplType _Impl)

Private Attributes
_ImplType	_M_Impl

Friends
class	cancellation_token_source

Detailed Description

The cancellation_token class represents the ability to determine whether some operation has been requested to cancel. A given token can be associated with a task_group, structured_task_group, or task to provide implicit cancellation. It can also be polled for cancellation or have a callback registered for if and when the associated cancellation_token_source is canceled.

Member Typedef Documentation

typedef details::_CancellationTokenState* Concurrency::cancellation_token::_ImplType

Constructor & Destructor Documentation

Concurrency::cancellation_token::cancellation_token ( const cancellation_token &  _Src )

inline

    {
        _Assign(_Src._M_Impl);
    }

Concurrency::cancellation_token::cancellation_token ( cancellation_token &&  _Src )

inline

    {
        _Move(_Src._M_Impl);
    }

Concurrency::cancellation_token::~cancellation_token ( )

inline

    {
        _Clear();
    }

Concurrency::cancellation_token::cancellation_token ( )

inlineprivate

                         :
        _M_Impl(NULL)
    {
    }

Concurrency::cancellation_token::cancellation_token ( _ImplType  _Impl )

inlineprivate

                                        :
        _M_Impl(_Impl)
    {
        if (_M_Impl == ::Concurrency::details::_CancellationTokenState::_None())
        {
            _M_Impl = NULL;
        }

        if (_M_Impl != NULL)
        {
            _M_Impl->_Reference();
        }
    }

Member Function Documentation

void Concurrency::cancellation_token::_Assign ( _ImplType  _Impl )

inlineprivate

    {
        if (_Impl != NULL)
        {
            _Impl->_Reference();
        }
        _M_Impl = _Impl;
    }

void Concurrency::cancellation_token::_Clear ( )

inlineprivate

    {
        if (_M_Impl != NULL)
        {
            _M_Impl->_Release();
        }
        _M_Impl = NULL;
    }

static cancellation_token Concurrency::cancellation_token::_FromImpl ( _ImplType  _Impl )

inlinestatic

    {
        return cancellation_token(_Impl);
    }

_ImplType Concurrency::cancellation_token::_GetImpl ( ) const

inline

    {
        return _M_Impl;
    }

_ImplType Concurrency::cancellation_token::_GetImplValue ( ) const

inline

    {
        return (_M_Impl == NULL) ? ::Concurrency::details::_CancellationTokenState::_None() : _M_Impl;
    }

void Concurrency::cancellation_token::_Move ( _ImplType &  _Impl )

inlineprivate

    {
        _M_Impl = _Impl;
        _Impl = NULL;
    }

void Concurrency::cancellation_token::deregister_callback ( const cancellation_token_registration &  _Registration ) const

inline

Removes a callback previously registered via the register method based on the cancellation_token_registration object returned at the time of registration.

Parameters

_Registration

The cancellation_token_registration object corresponding to the callback to be deregistered. This token must have been previously returned from a call to the register method.

    {
        _M_Impl->_DeregisterCallback(_Registration._M_pRegistration);
    }

bool Concurrency::cancellation_token::is_cancelable ( ) const

inline

Returns an indication of whether this token can be canceled or not.

Returns

An indication of whether this token can be canceled or not.

    {
        return (_M_Impl != NULL);
    }

bool Concurrency::cancellation_token::is_canceled ( ) const

inline

Returns true if the token has been canceled.

Returns

The value true if the token has been canceled; otherwise, the value false.

    {
        return (_M_Impl != NULL && _M_Impl->_IsCanceled());
    }

static cancellation_token Concurrency::cancellation_token::none ( )

inlinestatic

Returns a cancellation token which can never be subject to cancellation.

Returns

A cancellation token that cannot be canceled.

    {
        return cancellation_token();
    }

bool Concurrency::cancellation_token::operator!= ( const cancellation_token &  _Src ) const

inline

    {
        return !(operator==(_Src));
    }

cancellation_token& Concurrency::cancellation_token::operator= ( const cancellation_token &  _Src )

inline

    {
        if (this != &_Src)
        {
            _Clear();
            _Assign(_Src._M_Impl);
        }
        return *this;
    }

cancellation_token& Concurrency::cancellation_token::operator= ( cancellation_token &&  _Src )

inline

    {
        if (this != &_Src)
        {
            _Clear();
            _Move(_Src._M_Impl);
        }
        return *this;
    }

bool Concurrency::cancellation_token::operator== ( const cancellation_token &  _Src ) const

inline

    {
        return _M_Impl == _Src._M_Impl;
    }

template<typename _Function >

::Concurrency::cancellation_token_registration Concurrency::cancellation_token::register_callback ( const _Function &  _Func ) const

inline

Registers a callback function with the token. If and when the token is canceled, the callback will be made. Note that if the token is already canceled at the point where this method is called, the callback will be made immediately and synchronously.

Template Parameters

_Function

The type of the function object that will be called back when this cancellation_token is canceled.

Parameters

_Func

The function object that will be called back when this cancellation_token is canceled.

Returns

A cancellation_token_registration object which can be utilized in the deregister method to deregister a previously registered callback and prevent it from being made. The method will throw an invalid_operation exception if it is called on a cancellation_token object that was created using the cancellation_token::none method.

    {
        if (_M_Impl == NULL)
        {
            // A callback cannot be registered if the token does not have an associated source.
            throw invalid_operation();
        }
#pragma warning(suppress: 28197)
        details::_CancellationTokenCallback<_Function> *_PCallback = new details::_CancellationTokenCallback<_Function>(_Func);
        _M_Impl->_RegisterCallback(_PCallback);
        return cancellation_token_registration(_PCallback);
    }

Friends And Related Function Documentation

friend class cancellation_token_source

friend

Member Data Documentation

_ImplType Concurrency::cancellation_token::_M_Impl

private

---

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

• VS2013/inc/pplcancellation_token.h