Concurrency::_Order_combinable< _Ty, _Sym_fun > Class Template Reference

#include <ppl.h>

Classes
struct	_Bucket

Public Member Functions
_Bucket *	_Construct (_Bucket *_Par=0)
	_Order_combinable (const _Sym_fun &_Fun)
	~_Order_combinable ()
_Ty	_Serial_combine_release ()
_Bucket *	_Unsafe_push_back ()

Private Member Functions
_Order_combinable &	operator= (const _Order_combinable &other)

Private Attributes
const _Sym_fun &	_M_fun
size_t	_M_number
_Bucket *	_M_root

Constructor & Destructor Documentation

template<typename _Ty , typename _Sym_fun >

Concurrency::_Order_combinable< _Ty, _Sym_fun >::_Order_combinable ( const _Sym_fun &  _Fun )

inline

                                           : _M_fun(_Fun)
    {
        _M_root = 0;
        _M_number = 0;
    }

template<typename _Ty , typename _Sym_fun >

Concurrency::_Order_combinable< _Ty, _Sym_fun >::~_Order_combinable ( )

inline

    {
        while (_M_root)
        {
            _Bucket *_Cur = _M_root;
            _M_root = _M_root->_Next;
            reinterpret_cast<_Ty &>(_Cur->_Value).~_Ty();
            Concurrency::Free(_Cur);
        }
    }

Member Function Documentation

template<typename _Ty , typename _Sym_fun >

_Bucket* Concurrency::_Order_combinable< _Ty, _Sym_fun >::_Construct ( _Bucket *  _Par = 0 )

inline

    {
        _Bucket * _Ret = static_cast<_Bucket *>(Concurrency::Alloc(sizeof(_Bucket)));
        return new(_Ret)_Bucket(_Par);
    }

template<typename _Ty , typename _Sym_fun >

_Ty Concurrency::_Order_combinable< _Ty, _Sym_fun >::_Serial_combine_release ( )

inline

    {
        _Ty _Ret(reinterpret_cast<_Ty &>(_M_root->_Value));
        _Bucket *_Cur = _M_root;
        _M_root = _M_root->_Next;

        while (_M_root)
        {
            reinterpret_cast<_Ty &>(_Cur->_Value).~_Ty();
            Concurrency::Free(_Cur);
            _Cur = _M_root;
            _Ret = _M_fun(reinterpret_cast <_Ty &> (_Cur->_Value), _Ret);
            _M_root = _M_root->_Next;
        }

        reinterpret_cast<_Ty &>(_Cur->_Value).~_Ty();
        Concurrency::Free(_Cur);

        return _Ret;
    }

template<typename _Ty , typename _Sym_fun >

_Bucket* Concurrency::_Order_combinable< _Ty, _Sym_fun >::_Unsafe_push_back ( )

inline

    {
        return _M_root = _Construct(_M_root);
    }

template<typename _Ty , typename _Sym_fun >

_Order_combinable& Concurrency::_Order_combinable< _Ty, _Sym_fun >::operator= ( const _Order_combinable< _Ty, _Sym_fun > &  other )

private

Member Data Documentation

template<typename _Ty , typename _Sym_fun >

const _Sym_fun& Concurrency::_Order_combinable< _Ty, _Sym_fun >::_M_fun

private

template<typename _Ty , typename _Sym_fun >

size_t Concurrency::_Order_combinable< _Ty, _Sym_fun >::_M_number

private

template<typename _Ty , typename _Sym_fun >

_Bucket* Concurrency::_Order_combinable< _Ty, _Sym_fun >::_M_root

private

---

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

• VS2013/inc/ppl.h