Concurrency::details::_PPLTaskHandle< _ReturnType, _DerivedTaskHandle, _BaseTaskHandle > Struct Template Reference

The _PPLTaskHandle is the strong-typed task handle base. All user task functions need to be wrapped in this task handler to be executable by PPL. By deriving from a different _BaseTaskHandle, it can be used for both initial tasks and continuation tasks. For initial tasks, _PPLTaskHandle will be derived from _UnrealizedChore_t, and for continuation tasks, it will be derived from _ContinuationTaskHandleBase. The life time of the _PPLTaskHandle object is be managed by runtime if task handle is scheduled. More...

#include <ppltasks.h>

Inheritance diagram for Concurrency::details::_PPLTaskHandle< _ReturnType, _DerivedTaskHandle, _BaseTaskHandle >:

Public Member Functions
	_PPLTaskHandle (const typename _Task_ptr< _ReturnType >::_Type &_PTask)
virtual	~_PPLTaskHandle ()
virtual void	invoke () const
_Task_ptr_base	_GetTaskImplBase () const

Public Attributes
_Task_ptr< _ReturnType >::_Type	_M_pTask

Private Member Functions
_PPLTaskHandle const &	operator= (_PPLTaskHandle const &)

Detailed Description

template<typename _ReturnType, typename _DerivedTaskHandle, typename _BaseTaskHandle>
struct Concurrency::details::_PPLTaskHandle< _ReturnType, _DerivedTaskHandle, _BaseTaskHandle >

The _PPLTaskHandle is the strong-typed task handle base. All user task functions need to be wrapped in this task handler to be executable by PPL. By deriving from a different _BaseTaskHandle, it can be used for both initial tasks and continuation tasks. For initial tasks, _PPLTaskHandle will be derived from _UnrealizedChore_t, and for continuation tasks, it will be derived from _ContinuationTaskHandleBase. The life time of the _PPLTaskHandle object is be managed by runtime if task handle is scheduled.

Template Parameters

_ReturnType	The result type of the _Task_impl.
_DerivedTaskHandle	The derived task handle class. The operator () needs to be implemented.
_BaseTaskHandle	The base class from which _PPLTaskHandle should be derived. This is either _UnrealizedChore_t or _ContinuationTaskHandleBase.

Constructor & Destructor Documentation

template<typename _ReturnType, typename _DerivedTaskHandle, typename _BaseTaskHandle>

Concurrency::details::_PPLTaskHandle< _ReturnType, _DerivedTaskHandle, _BaseTaskHandle >::_PPLTaskHandle ( const typename _Task_ptr< _ReturnType >::_Type &  _PTask )

inline

                                                                            : _M_pTask(_PTask)
        {
        }

template<typename _ReturnType, typename _DerivedTaskHandle, typename _BaseTaskHandle>

virtual Concurrency::details::_PPLTaskHandle< _ReturnType, _DerivedTaskHandle, _BaseTaskHandle >::~_PPLTaskHandle ( )

inlinevirtual

        {
            // Here is the sink of all task completion code paths
            _M_pTask->_M_taskEventLogger._LogTaskCompleted();
        }

Member Function Documentation

template<typename _ReturnType, typename _DerivedTaskHandle, typename _BaseTaskHandle>

_Task_ptr_base Concurrency::details::_PPLTaskHandle< _ReturnType, _DerivedTaskHandle, _BaseTaskHandle >::_GetTaskImplBase ( ) const

inline

        {
            return _M_pTask;
        }

template<typename _ReturnType, typename _DerivedTaskHandle, typename _BaseTaskHandle>

virtual void Concurrency::details::_PPLTaskHandle< _ReturnType, _DerivedTaskHandle, _BaseTaskHandle >::invoke ( ) const

inlinevirtual

        {
            // All exceptions should be rethrown to finish cleanup of the task collection. They will be caught and handled
            // by the runtime.
            _ASSERTE((bool)_M_pTask);
            if (!_M_pTask->_TransitionedToStarted())
            {
                static_cast<const _DerivedTaskHandle *>(this)->_SyncCancelAndPropagateException();
                return;
            }

            _M_pTask->_M_taskEventLogger._LogTaskExecutionStarted();
            try
            {
                // All derived task handle must implement this contract function.
                static_cast<const _DerivedTaskHandle *>(this)->_Perform();
            }
            catch(const task_canceled &)
            {
                _M_pTask->_Cancel(true);
            }
            catch(const _Interruption_exception &)
            {
                _M_pTask->_Cancel(true);
            }
#if defined (__cplusplus_winrt)
            catch(::Platform::Exception^ _E)
            {
                _M_pTask->_CancelWithException(_E);
            }
#endif  /* defined (__cplusplus_winrt) */
            catch(...)
            {
                _M_pTask->_CancelWithException(std::current_exception());
            }
            _M_pTask->_M_taskEventLogger._LogTaskExecutionCompleted();
        }

template<typename _ReturnType, typename _DerivedTaskHandle, typename _BaseTaskHandle>

_PPLTaskHandle const& Concurrency::details::_PPLTaskHandle< _ReturnType, _DerivedTaskHandle, _BaseTaskHandle >::operator= ( _PPLTaskHandle< _ReturnType, _DerivedTaskHandle, _BaseTaskHandle > const &  )

private

Member Data Documentation

template<typename _ReturnType, typename _DerivedTaskHandle, typename _BaseTaskHandle>

_Task_ptr<_ReturnType>::_Type Concurrency::details::_PPLTaskHandle< _ReturnType, _DerivedTaskHandle, _BaseTaskHandle >::_M_pTask

---

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

• VS2013/inc/ppltasks.h